microsoft/TypeScript · error · Error

The generated content was "undefined". Return "null" if no…

Error message

The generated content was "undefined". Return "null" if no baselining is required."

What it means

Thrown by runBaseline (harnessIO.ts:1506) when the caller passes `undefined` (not `null`) as the actual content. The harness deliberately distinguishes `null` (= no baseline to write, legitimate skip) from `undefined` (= a generator bug that returned no value) and rejects the latter.

Solutions

Change the generator to `return null;` on the no-content path instead of returning undefined.
Tighten the generator's TypeScript return type to `string | null` so the compiler flags the undefined path at build time.
Coalesce at the call site: `runBaseline(name, content ?? null, opts)`.

Example fix

// before — returns undefined when no content
function gen(): string | null {
  if (!hasOutput) return;
  return buildOutput();
}

// after — explicit null
function gen(): string | null {
  if (!hasOutput) return null;
  return buildOutput();
}

Defensive patterns

Strategy: type-guard

Validate before calling

// Coalesce undefined to null before calling runBaseline.
const safe: string | null = generatedContent ?? null;
runBaseline(relativeFileName, safe, opts);

Type guard

function isBaselineContent(value: unknown): value is string | null {
  return value === null || typeof value === 'string';
}

// usage:
if (!isBaselineContent(generatedContent)) {
  throw new TypeError('Generator must return string | null, got ' + typeof generatedContent);
}

Prevention

Type generator returns as `string | null` so the compiler rejects implicit undefined.
Always `return null;` explicitly on the no-content branch.
Coalesce at the call site with `content ?? null`.

When it happens

Trigger: A baseline generator function returns `undefined` — e.g. `return;`, `return someVar;` where someVar is undefined, or an arrow whose branch yields nothing — and that value reaches runBaseline. The type signature permits `string | null` but JavaScript lets `undefined` through at runtime.

Common situations: Refactoring a generator to conditionally return without a value; loosening a function's return type; a code path that forgets to return null explicitly; migrating from a default-null to an explicit-return pattern.

Related errors

AI-assisted analysis of microsoft/TypeScript@b465fdbfe1 (2026-08-12). Data as JSON: /api/errors/7381f9f3963a5e62. Report an issue: GitHub.

Appendix: source

Thrown at src/harness/harnessIO.ts:1506

            else {
                if (!IO.fileExists(expected)) {
                    throw new Error(`New baseline created at ${IO.joinPath("tests", "baselines", "local", relativeFileName)}`);
                }
                else {
                    throw new Error(errorMessage);
                }
            }
        }
    }

    function getBaselineFileChangedErrorMessage(relativeFileName: string): string {
        return `The baseline file ${relativeFileName} has changed. (Run "hereby baseline-accept" if the new baseline is correct.)`;
    }

    export function runBaseline(relativeFileName: string, actual: string | null, opts?: BaselineOptions): void { // eslint-disable-line no-restricted-syntax
        const actualFileName = localPath(relativeFileName, opts && opts.Baselinefolder, opts && opts.Subfolder);
        if (actual === undefined) {
            throw new Error('The generated content was "undefined". Return "null" if no baselining is required."');
        }
        const comparison = compareToBaseline(actual, relativeFileName, opts);
        writeComparison(comparison.expected, comparison.actual, relativeFileName, actualFileName, opts);
    }

    export function runMultifileBaseline(relativeFileBase: string, extension: string, generateContent: () => IterableIterator<[string, string, number]> | IterableIterator<[string, string]> | null, opts?: BaselineOptions, referencedExtensions?: string[]): void { // eslint-disable-line no-restricted-syntax
        const gen = generateContent();
        const writtenFiles = new Map<string, true>();
        const errors: Error[] = [];

        // eslint-disable-next-line no-restricted-syntax
        if (gen !== null) {
            for (const value of gen) {
                const [name, content, count] = value as [string, string, number | undefined];
                if (count === 0) continue; // Allow error reporter to skip writing files without errors
                const relativeFileName = relativeFileBase + "/" + name + extension;
                const actualFileName = localPath(relativeFileName, opts && opts.Baselinefolder, opts && opts.Subfolder);
                const comparison = compareToBaseline(content, relativeFileName, opts);

View on GitHub (pinned to b465fdbfe1)