`EFNoLeadingComments` suppresses synthesized leading comments in tsgo; Strada only suppresses source comments

从 internal/printer/printer.go 中的 emitLeadingSyntheticCommentsOfNode 和 emitTrailingSyntheticCommentsOfNode 开始，然后运行 issue 中的 TestSyntheticLeadingCommentWithNoLeadingComments 示例。将输出与 Strada 的 printer 行为进行比较，并为使用 EFNoLeadingComments、EFNoTrailingComments 和 EFNoComments 时的前导和尾随合成注释添加有针对性的覆盖。完成的标准是可以抑制源代码注释，而不会抑制合成的替代内容。

🔎 Search Terms

NoLeadingComments, EFNoLeadingComments, synthesized comments, setSyntheticLeadingComments, emitLeadingSyntheticCommentsOfNode, printer, comment emit

🕗 Version & Regression Information

• This changed between TypeScript 6.0.3 and tsgo built from main at df1a31e6d5.
• The tsgo behavior has been there since synthesized comment emit was first ported, in microsoft/typescript-go#1599 (commit 809b2c09, "Const enum inlining and synthetic comment emit support").

⏯ Playground Link

None. This is only reachable through the transformer/printer API, so the repros below use the API directly.

💻 Code

Strada, run with Node against [email protected]:

const ts = require('typescript');
const f = ts.factory;
const sf = ts.createSourceFile('a.ts', '', ts.ScriptTarget.Latest);
const printer = ts.createPrinter();
const comment = {kind: ts.SyntaxKind.MultiLineCommentTrivia, text: '* synthesized ', hasTrailingNewLine: true, pos: -1, end: -1};

for (const [label, flags] of [['no flags', 0], ['NoLeadingComments', ts.EmitFlags.NoLeadingComments], ['NoComments', ts.EmitFlags.NoComments]]) {
  const stmt = f.createExpressionStatement(f.createIdentifier('x'));
  ts.setSyntheticLeadingComments(stmt, [comment]);
  if (flags) ts.setEmitFlags(stmt, flags);
  console.log(`--- ${label}\n` + printer.printNode(ts.EmitHint.Unspecified, stmt, sf));
}

tsgo, the same thing as a test in internal/printer:

func TestSyntheticLeadingCommentWithNoLeadingComments(t *testing.T) {
  for _, c := range []struct {
    name  string
    flags EmitFlags
  }{{"no flags", 0}, {"EFNoLeadingComments", EFNoLeadingComments}, {"EFNoComments", EFNoComments}} {
    sf := parser.ParseSourceFile(ast.SourceFileParseOptions{FileName: "/a.ts", Path: "/a.ts"}, "", core.ScriptKindTS)
    ec := NewEmitContext()
    stmt := ec.Factory.NewExpressionStatement(ec.Factory.NewIdentifier("x"))
    ec.SetSyntheticLeadingComments(stmt, []SynthesizedComment{{Kind: ast.KindMultiLineCommentTrivia, Text: "* synthesized ", HasTrailingNewLine: true, Loc: core.UndefinedTextRange()}})
    ec.SetEmitFlags(stmt, c.flags)
    t.Logf("--- %s\n%s", c.name, NewPrinter(PrinterOptions{}, PrintHandlers{}, ec).Emit(stmt, sf))
  }
}

🙁 Actual behavior

tsgo drops the synthesized comment as soon as EFNoLeadingComments is set:

--- no flags
/** synthesized */
x;
--- EFNoLeadingComments
x;
--- EFNoComments
x;

🙂 Expected behavior

Same as TypeScript 6.0.3, which keeps the synthesized comment in all three cases:

--- no flags
/** synthesized */
x;
--- NoLeadingComments
/** synthesized */
x;
--- NoComments
/** synthesized */
x;

Additional information about the issue

Where the two differ. In Strada, emitLeadingCommentsOfNode in src/compiler/emitter.ts uses NoLeadingComments (and a negative pos) only to decide whether to emit the comments found in the source text for the node's range. The synthesized comments are emitted after that check, unconditionally:

const skipLeadingComments = pos < 0 || (emitFlags & EmitFlags.NoLeadingComments) !== 0 || node.kind === SyntaxKind.JsxText;
// ...
if (!skipLeadingComments) {
    emitLeadingComments(pos, /*isEmittedNode*/ node.kind !== SyntaxKind.NotEmittedStatement);
}
// ...
forEach(getSyntheticLeadingComments(node), emitLeadingSynthesizedComment);

In tsgo, the synthesized comments go through their own function, emitLeadingSyntheticCommentsOfNode in internal/printer/printer.go, which returns early on the flag:

func (p *Printer) emitLeadingSyntheticCommentsOfNode(node *ast.Node, emitFlags EmitFlags) {
  if emitFlags&EFNoLeadingComments != 0 {
    return
  }
  synth := p.emitContext.GetSyntheticLeadingComments(node)
  // ...

Trailing comments have the same shape: Strada's emitTrailingCommentsOfNode emits getSyntheticTrailingComments(node) unconditionally, and tsgo's emitTrailingSyntheticCommentsOfNode returns early on EFNoTrailingComments. I measured only the leading case; the trailing one is from reading the code.

These lines came in with microsoft/typescript-go#1599, the PR that first added synthesized comment emit. I couldn't find any discussion of the flag in that PR, so this looks like it was introduced in the original port rather than chosen deliberately.

Why it matters. A transformer that rewrites a comment needs to hide the node's original source comment and print its replacement. In Strada, that means setting NoLeadingComments and attaching the replacement with setSyntheticLeadingComments. tsickle, which rewrites TypeScript JSDoc into Closure Compiler annotations, relies on this. In tsgo, EFNoLeadingComments also suppresses the synthesized replacement, so the pattern breaks: the transformer can hide both comments or neither. For our Go port of tsickle, this means decorated class members get printed with both the original JSDoc and the rewritten JSDoc. Closure Compiler rejects that output, so builds that pass with TypeScript 6.0.3 fail with tsgo.

Possible fix. Emit synthesized comments regardless of EFNoLeadingComments / EFNoTrailingComments, as Strada does, so the flags only control comments taken from the source text:

--- a/internal/printer/printer.go
+++ b/internal/printer/printer.go
 func (p *Printer) emitLeadingSyntheticCommentsOfNode(node *ast.Node, emitFlags EmitFlags) {
- if emitFlags&EFNoLeadingComments != 0 {
-   return
- }
  synth := p.emitContext.GetSyntheticLeadingComments(node)
  for _, c := range synth {
    p.emitLeadingSynthesizedComment(c)
  }
 }
@@
 func (p *Printer) emitTrailingSyntheticCommentsOfNode(node *ast.Node, emitFlags EmitFlags) {
- if emitFlags&EFNoTrailingComments != 0 {
-   return
- }
  synth := p.emitContext.GetSyntheticTrailingComments(node)
  for _, c := range synth {
    p.emitTrailingSynthesizedComment(c)
  }
 }

This leaves emitFlags unused in both functions. I kept the signatures unchanged to keep the diff small. I haven't run tsgo's test suite with this change, so I don't know whether anything in tsgo itself now depends on the current behavior.