[7.0] Downlevel emit places a comment after a synthesized return, causing arrow functions to return undefined

[diego9497]

🔎 Search Terms

"arrow function", "optional chaining", "comment", "return undefined", "ASI", "downlevel emit"

🕗 Version & Regression Information

• This changed between versions 6.0.3 and 7.0.2

⏯ Playground Link

No response

💻 Code

const before: { color?: { text: string } } = {
  color: { text: "black" },
};

const after: { color?: { text: string } } = {
  color: { text: "white" },
};

const changed = () =>
  // Compare the colors.
  before.color?.text !== after.color?.text;

console.log(changed());

Compiler options

{
  "compilerOptions": {
    "target": "es2019",
    "module": "commonjs"
  }
}

🙁 Actual behavior

TypeScript 7.0.2 emits:

const changed = () => {
    var _a, _b;
    return
    // Compare the colors.
    ((_a = before.color) === null || _a === void 0
        ? void 0
        : _a.text) !==
        ((_b = after.color) === null || _b === void 0
            ? void 0
            : _b.text);
};

Due to JavaScript automatic semicolon insertion, the generated function is equivalent to:

const changed = () => {
    return;
};

Runtime output:
undefined
The comparison is never evaluated.

🙂 Expected behavior

The generated return statement should contain the transformed expression.
TypeScript 6.0.3 emits code equivalent to:

const changed = () => {
    var _a, _b;
    // Compare the colors.
    return ((_a = before.color) === null || _a === void 0
        ? void 0
        : _a.text) !==
        ((_b = after.color) === null || _b === void 0
            ? void 0
            : _b.text);
};

Runtime output:
true

Additional information about the issue

Reproduction commands
TypeScript 7:

npx -p typescript@7.0.2 tsc repro.ts \
  --ignoreConfig \
  --target es2019 \
  --module commonjs

node repro.js
Output:
undefined
TypeScript 6:
npx -p typescript@6.0.3 tsc repro.ts \
  --ignoreConfig \
  --target es2019 \
  --module commonjs

node repro.js

Output:
true

The issue appears when all of the following are present:

• An arrow function uses a concise expression body.
• A comment appears immediately after =>.
• The expression requires downlevel transformation, such as optional chaining when targeting ES2019.
• The emitter converts the arrow body into a block and synthesizes a return.
• The comment is emitted after the synthesized return, separated by a newline, which changes the runtime semantics due to automatic semicolon insertion.

Known workarounds:

• Use an explicit block and return (...).
• Move the comment before the arrow function declaration.
• Remove the comment.
• Target ES2020 or newer so optional chaining is not downleveled.
• Compile with TypeScript 6.

[SnowingFox]

I reproduced this on the TS 7.0 native compiler (@typescript/native-preview 7.0.0-dev.20260707.2). Confirming it is a native-port regression, not a JS-emitter bug.

Repro

const before: { color?: { text: string } } = { color: { text: "black" } };
const after: { color?: { text: string } } = { color: { text: "white" } };
const changed = () =>
  // Compare the colors.
  before.color?.text !== after.color?.text;
console.log(changed());

tsconfig.json: { "compilerOptions": { "target": "es2019", "module": "commonjs" } }

Native emit (broken) — return followed by newline + comment, so ASI makes it return;:

const changed = () => { var _a, _b; return
// Compare the colors.
((_a = before.color) === null || _a === void 0 ? void 0 : _a.text) !== ((_b = after.color) === null || _b === void 0 ? void 0 : _b.text); };

node repro.js prints undefined.

microsoft/TypeScript JS emitter (main, 6.0.0-dev) is correct — comment is emitted before return, runtime true:

const changed = () => { var _a, _b;
// Compare the colors.
return ((_a = before.color) === null || _a === void 0 ? void 0 : _a.text) !== ((_b = after.color) === null || _b === void 0 ? void 0 : _b.text); };

So this is a bug in the native port, which lives in microsoft/typescript-go (the fix should be filed/PR'd there, not against the JS emitter in this repo).

Root cause (typescript-go): when downleveling an optional chain inside a concise arrow body, temp vars _a/_b are hoisted, so the concise body is converted to a block body. This happens in EmitContext.VisitFunctionBody (internal/printer/emitcontext.go, ~line 916): c.Factory.NewReturnStatement(updated) is synthesized without transferring the concise body's source range to the return statement. The JS emitter's equivalent (convertToFunctionBlock in src/compiler/factory/nodeConverters.ts) does setTextRange(returnStatement, node), which attributes the body's leading comment to the return statement so it is emitted before return. Without that transfer, the leading comment stays attached to the expression and the printer emits return → comment → expression, which ASI rewrites as return;.

Additionally, the ASI guard parenthesizeExpressionForNoAsi in internal/printer/printer.go only adds parens for a leading-newline-emitting comment when the node is a PartiallyEmittedExpression; here the top-level transformed node is a BinaryExpression, so it isn't parenthesized. Either transferring the source range onto the synthesized return (matching the JS emitter) or widening the ASI guard to the top-level node would fix this.

Happy to open a PR in microsoft/typescript-go if that's the right place.

[MartinJohns]

Duplicate of microsoft/typescript-go#4722.