@ttsc/lint 0.18.4 → 0.19.0

package/linthost/rules_core_extra.go

@@ -3,7 +3,7 @@
 // hadn't migrated yet.
 //
 // Implemented here:
-//   - no-await-in-loop: await inside a loop body iterates sequentially
+//   - no-await-in-loop: explicit or implicit await in a repeated loop position
 //   - no-dupe-class-members: duplicate class member declarations
 //   - no-this-before-super: `this` (or `super.x`) before `super()` in
 //     derived constructors
@@ -14,75 +14,85 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
-// noAwaitInLoop reports an `await` expression evaluated inside the body
-// of a sequential loop (for / while / do-while / for-in / for-of). Each
-// iteration of the loop blocks on the previous one's microtask hop, so
-// the loop body runs strictly serially even when the underlying
-// operations are independent and could overlap with Promise.all.
+// noAwaitInLoop reports explicit and implicit awaits evaluated in a repeated
+// loop position. Initializers and iterable expressions run only once per loop,
+// while tests, updates, bodies, nested for-await statements, and await-using
+// declarations in repeated positions serialize iterations.
 // https://eslint.org/docs/latest/rules/no-await-in-loop
-//
-// `for await … of` loops are exempt — the for-await iterator protocol
-// is the whole reason the loop exists, and rejecting its `await` would
-// just suggest the developer abandon the iterator.
 type noAwaitInLoop struct{}
 
 func (noAwaitInLoop) Name() string { return "no-await-in-loop" }
 func (noAwaitInLoop) Visits() []shimast.Kind {
-  return []shimast.Kind{shimast.KindAwaitExpression}
+  return []shimast.Kind{
+    shimast.KindAwaitExpression,
+    shimast.KindForOfStatement,
+    shimast.KindVariableDeclarationList,
+  }
 }
 func (noAwaitInLoop) Check(ctx *Context, node *shimast.Node) {
-  for cur := node.Parent; cur != nil; cur = cur.Parent {
-    if isFunctionLikeKind(cur) {
-      return
-    }
-    switch cur.Kind {
-    case shimast.KindForStatement,
-      shimast.KindWhileStatement,
-      shimast.KindDoStatement,
-      shimast.KindForInStatement:
-      ctx.Report(node, "Unexpected `await` inside a loop — iterations run sequentially; prefer `Promise.all` when independent.")
-      return
-    case shimast.KindForOfStatement:
-      // `for await … of` loops are exempt by design — the await
-      // is the iteration itself, not a sequential block.
-      if isForAwaitOfStatement(ctx.File, cur) {
-        return
-      }
+  if node == nil || !isAwaitInLoopCandidate(node) {
+    return
+  }
+  child := node
+  for parent := node.Parent; parent != nil && !isAwaitInLoopBoundary(parent); parent = parent.Parent {
+    if isRepeatedLoopPosition(child, parent) {
       ctx.Report(node, "Unexpected `await` inside a loop — iterations run sequentially; prefer `Promise.all` when independent.")
       return
     }
+    child = parent
   }
 }
 
-// isForAwaitOfStatement reports whether the for-of statement at `node`
-// is a `for await … of` (rather than a plain `for … of`). The shim AST
-// does not expose `AwaitModifier` as a typed field, so the check is
-// textual: locate the `for` keyword and look for the `await` keyword
-// in the small window before the opening parenthesis. The width 24
-// covers any reasonable spacing/comment-free header.
-func isForAwaitOfStatement(file *shimast.SourceFile, node *shimast.Node) bool {
-  if file == nil || node == nil {
-    return false
-  }
-  forPos := keywordStart(file, node, "for")
-  if forPos < 0 {
+func isAwaitInLoopCandidate(node *shimast.Node) bool {
+  switch node.Kind {
+  case shimast.KindAwaitExpression:
+    return true
+  case shimast.KindForOfStatement:
+    statement := node.AsForInOrOfStatement()
+    return statement != nil && statement.AwaitModifier != nil
+  case shimast.KindVariableDeclarationList:
+    return isAwaitUsingDeclarationList(node)
+  default:
     return false
   }
-  src := file.Text()
-  limit := forPos + 24
-  if limit > len(src) {
-    limit = len(src)
+}
+
+func isAwaitInLoopBoundary(node *shimast.Node) bool {
+  if isFunctionLikeKind(node) {
+    return true
   }
-  if node.End() < limit {
-    limit = node.End()
+  if node == nil || node.Kind != shimast.KindForOfStatement {
+    return false
   }
-  for i := forPos + 3; i < limit; i++ {
-    if src[i] == '(' {
-      limit = i
-      break
-    }
+  statement := node.AsForInOrOfStatement()
+  return statement != nil && statement.AwaitModifier != nil
+}
+
+func isRepeatedLoopPosition(child, parent *shimast.Node) bool {
+  switch parent.Kind {
+  case shimast.KindForStatement:
+    statement := parent.AsForStatement()
+    return statement != nil &&
+      (child == statement.Condition || child == statement.Incrementor || child == statement.Statement)
+  case shimast.KindForInStatement, shimast.KindForOfStatement:
+    statement := parent.AsForInOrOfStatement()
+    return statement != nil &&
+      (child == statement.Statement ||
+        (child == statement.Initializer && isAwaitUsingDeclarationList(child)))
+  case shimast.KindWhileStatement:
+    statement := parent.AsWhileStatement()
+    return statement != nil && (child == statement.Expression || child == statement.Statement)
+  case shimast.KindDoStatement:
+    statement := parent.AsDoStatement()
+    return statement != nil && (child == statement.Expression || child == statement.Statement)
+  default:
+    return false
   }
-  return findKeyword(file, forPos+3, limit, "await") >= 0
+}
+
+func isAwaitUsingDeclarationList(node *shimast.Node) bool {
+  return node != nil && node.Kind == shimast.KindVariableDeclarationList &&
+    shimast.GetCombinedNodeFlags(node)&shimast.NodeFlagsBlockScoped == shimast.NodeFlagsAwaitUsing
 }
 
 // noDupeClassMembers reports two declarations of the same member on a
@@ -377,45 +387,6 @@ func objectLiteralIsEmpty(node *shimast.Node) bool {
   return len(lit.Properties.Nodes) == 0
 }
 
-// noDuplicateImports reports two import declarations that resolve to
-// the same module specifier. Consolidating them into one import keeps
-// the dependency graph at the head of the file readable and avoids
-// surprising load-order interactions when the import has side effects.
-// https://eslint.org/docs/latest/rules/no-duplicate-imports
-//
-// The check is textual on the module specifier string — two imports
-// with the same exact string literal collide. `import type { … } from`
-// is folded together with value imports because the runtime sees only
-// one module load.
-type noDuplicateImports struct{}
-
-func (noDuplicateImports) Name() string { return "no-duplicate-imports" }
-func (noDuplicateImports) Visits() []shimast.Kind {
-  return []shimast.Kind{shimast.KindSourceFile}
-}
-func (noDuplicateImports) Check(ctx *Context, node *shimast.Node) {
-  seen := map[string]bool{}
-  node.ForEachChild(func(child *shimast.Node) bool {
-    if child == nil || child.Kind != shimast.KindImportDeclaration {
-      return false
-    }
-    decl := child.AsImportDeclaration()
-    if decl == nil || decl.ModuleSpecifier == nil {
-      return false
-    }
-    spec := stringLiteralText(decl.ModuleSpecifier)
-    if spec == "" {
-      return false
-    }
-    if seen[spec] {
-      ctx.Report(child, "Module `"+spec+"` is already imported above; consolidate the imports.")
-      return false
-    }
-    seen[spec] = true
-    return false
-  })
-}
-
 // getterReturn reports a `get` accessor whose body completes without
 // returning a value. The runtime returns `undefined` from such a
 // getter; in practice that is always a bug — the caller expects the
@@ -728,7 +699,6 @@ func init() {
   Register(noAwaitInLoop{})
   Register(noConstructorReturn{})
   Register(noDupeClassMembers{})
-  Register(noDuplicateImports{})
   Register(noImplicitCoercion{})
   Register(noNewSymbol{})
   Register(noThisBeforeSuper{})

package/linthost/rules_cypress.go

@@ -12,7 +12,7 @@ type cypressNoUnnecessaryWaiting struct{}
 type cypressNoForce struct{}
 type cypressNoPause struct{}
 type cypressNoDebug struct{}
-type cypressUnsafeToChainCommand struct{}
+type cypressUnsafeToChainCommand struct{ optionsRule }
 type cypressAssertionBeforeScreenshot struct{}
 type cypressNoAsyncTests struct{}
 type cypressNoAsyncBefore struct{}

package/linthost/rules_default_case.go

@@ -1,39 +1,115 @@
 // defaultCase: a `switch` statement that omits the `default` clause
 // silently drops every discriminant value not matched by an explicit
-// `case` label. The rule wants the catch-all path written out so an
-// unhandled discriminant becomes an intentional branch — even if that
-// branch is a `// no default` comment marker.
+// `case` label. The rule wants the catch-all path written out — unless the
+// omission is deliberately marked by a trailing `// no default` comment.
 //
-// AST-only: each visited `SwitchStatement` checks its `CaseBlock`
-// clauses for any node of kind `DefaultClause`. The rule reports on the
-// switch keyword itself rather than the case block so the diagnostic
-// lands at the head of the statement.
+// Behavior mirrors ESLint's `default-case`:
+//
+//   - An empty switch (`switch (x) {}`, zero clauses) is skipped: an empty
+//     case block has no clause to attach the marker comment to, so upstream
+//     bails with `if (!node.cases.length) return;`.
+//   - A `default` clause anywhere in the block satisfies the rule.
+//   - Otherwise the LAST comment trailing the final clause (between its end
+//     and the case block's `}`) is tested against `commentPattern`. When the
+//     comment's trimmed text matches, the omission is intentional and the
+//     switch is left alone; otherwise the rule reports on the `switch`
+//     keyword so the diagnostic lands at the head of the statement.
+//
+// `commentPattern` replaces the default marker pattern `/^no default$/i`
+// (ESLint's DEFAULT_COMMENT_PATTERN). The trailing-comment scan reuses
+// comment_scan.go's parser-aware gap scanner over the trivia-only region
+// after the last clause.
 // https://eslint.org/docs/latest/rules/default-case
 package linthost
 
-import shimast "github.com/microsoft/typescript-go/shim/ast"
+import (
+  "regexp"
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+// defaultCaseDefaultCommentPattern is ESLint's DEFAULT_COMMENT_PATTERN
+// (`/^no default$/iu`) in RE2: the trailing comment's trimmed text must be
+// exactly `no default`, in any letter case.
+var defaultCaseDefaultCommentPattern = regexp.MustCompile(`(?i)^no default$`)
+
+// defaultCaseOptions mirrors the upstream rule's single-object schema.
+type defaultCaseOptions struct {
+  // CommentPattern replaces the default `no default` marker pattern when
+  // non-empty. Upstream compiles it with the `u` flag and no `i`, so the
+  // custom pattern is case-sensitive unless it opts in. An uncompilable
+  // pattern falls back to the default marker (matching no-fallthrough) so a
+  // config typo cannot silently turn every marked switch into a finding.
+  CommentPattern string `json:"commentPattern"`
+}
 
-type defaultCase struct{}
+type defaultCase struct{ optionsRule }
 
 func (defaultCase) Name() string           { return "default-case" }
 func (defaultCase) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSwitchStatement} }
 func (defaultCase) Check(ctx *Context, node *shimast.Node) {
   sw := node.AsSwitchStatement()
-  if sw == nil || sw.CaseBlock == nil {
+  if sw == nil || sw.CaseBlock == nil || ctx.File == nil {
     return
   }
   block := sw.CaseBlock.AsCaseBlock()
   if block == nil || block.Clauses == nil {
     return
   }
-  for _, clause := range block.Clauses.Nodes {
+  clauses := block.Clauses.Nodes
+  // Empty switch: upstream skips it because an empty case block offers no
+  // clause to read the marker comment from.
+  if len(clauses) == 0 {
+    return
+  }
+  for _, clause := range clauses {
     if clause != nil && clause.Kind == shimast.KindDefaultClause {
       return
     }
   }
+
+  var opts defaultCaseOptions
+  ctx.DecodeOptions(&opts)
+  pattern := defaultCaseDefaultCommentPattern
+  if opts.CommentPattern != "" {
+    if custom, err := compileUserPattern(opts.CommentPattern); err == nil {
+      pattern = custom
+    }
+  }
+
+  // ESLint's sourceCode.getCommentsAfter(lastCase).at(-1): the LAST comment
+  // between the final clause and the case block's closing brace marks the
+  // omission intentional when its trimmed text matches the pattern. A
+  // trailing non-marker comment after a `// no default` therefore invalidates
+  // the marker.
+  if lastClause := clauses[len(clauses)-1]; lastClause != nil {
+    text := ctx.File.Text()
+    closeBrace := sw.CaseBlock.End() - 1 // exclusive End covers the `}` token
+    if pos, end, ok := defaultCaseLastTrailingComment(text, lastClause.End(), closeBrace); ok &&
+      pattern.MatchString(strings.TrimSpace(commentInnerText(text[pos:end]))) {
+      return
+    }
+  }
+
   ctx.Report(node, "Expected a default case.")
 }
 
+// defaultCaseLastTrailingComment returns the source range of the LAST comment
+// in the trivia region [from, to), reusing comment_scan.go's parser-aware gap
+// scanner. The region between a switch's last clause and its closing brace is
+// trivia-only by construction, so scanning the isolated gap is exact.
+func defaultCaseLastTrailingComment(text string, from, to int) (pos, end int, ok bool) {
+  if from < 0 || to > len(text) || from >= to {
+    return 0, 0, false
+  }
+  scanCommentGap(shimscanner.NewScanner(), text, from, to, func(_ shimast.Kind, p, e int) {
+    pos, end, ok = p, e, true
+  })
+  return pos, end, ok
+}
+
 func init() {
   Register(defaultCase{})
 }

package/linthost/rules_dupes.go

@@ -99,11 +99,11 @@ func (noDupeArgs) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// propertyKey returns a stable key for a property in an object literal.
-// Computed names without a literal payload return "" so the dedupe pass
-// can skip them safely (a typed field is fine — duplicate identical
-// expressions still won't cause false positives because the same expr
-// produces the same source text).
+// propertyKey returns a stable dedupe key for a property in an object literal,
+// mirroring ESLint's getStaticPropertyName. A property whose name is not
+// statically known — a computed name built from a non-constant expression —
+// returns "" so the dedupe pass skips it and never treats two distinct dynamic
+// keys as duplicates.
 func propertyKey(file *shimast.SourceFile, prop *shimast.Node) string {
   if prop == nil {
     return ""
@@ -152,11 +152,15 @@ func propertyKey(file *shimast.SourceFile, prop *shimast.Node) string {
   return ""
 }
 
-// staticPropertyKey extracts a comparable string key from a property name node.
-// Identifiers, string/numeric literals, and computed names with a literal
-// payload all produce a stable string. Other computed names (dynamic
-// expressions) return "" so the caller skips them without false positives.
-func staticPropertyKey(file *shimast.SourceFile, name *shimast.Node) string {
+// staticPropertyKey extracts a comparable string key from a property name node,
+// mirroring ESLint's getStaticPropertyName. A bare identifier yields its name,
+// and string / numeric / bigint literals yield their text. A computed name
+// yields a key only when its bracketed expression is itself a constant literal
+// (resolved like getStaticStringValue): `["a"]` resolves to `a` so it collides
+// with the identifier key `a`, while a non-constant computed name such as
+// `[f()]` or `[x]` resolves to "" and the caller skips it. The file argument is
+// unused here but kept so the whole property-key family shares one signature.
+func staticPropertyKey(_ *shimast.SourceFile, name *shimast.Node) string {
   if name == nil {
     return ""
   }
@@ -168,9 +172,30 @@ func staticPropertyKey(file *shimast.SourceFile, name *shimast.Node) string {
   case shimast.KindNumericLiteral, shimast.KindBigIntLiteral:
     return numericLiteralText(name)
   case shimast.KindComputedPropertyName:
-    // fall back to source text so a computed `[`foo`]` still compares
-    // against the literal `foo` form when both appear together.
-    return nodeText(file, name)
+    computed := name.AsComputedPropertyName()
+    if computed == nil {
+      return ""
+    }
+    return staticComputedKey(computed.Expression)
+  }
+  return ""
+}
+
+// staticComputedKey resolves the expression inside a `[...]` computed property
+// name to a static key, mirroring ESLint's getStaticStringValue: only a
+// constant literal (string, template without substitutions, numeric, or bigint)
+// contributes a key. Parentheses are transparent, matching ESTree, which has no
+// parenthesized-expression node. Any other expression contributes "".
+func staticComputedKey(expr *shimast.Node) string {
+  expr = stripParens(expr)
+  if expr == nil {
+    return ""
+  }
+  switch expr.Kind {
+  case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+    return stringLiteralText(expr)
+  case shimast.KindNumericLiteral, shimast.KindBigIntLiteral:
+    return numericLiteralText(expr)
   }
   return ""
 }

package/linthost/rules_empty.go

@@ -1,35 +1,67 @@
 package linthost
 
-import shimast "github.com/microsoft/typescript-go/shim/ast"
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
 
-// noEmpty: empty block statements (`{}`), but allow empty catch
-// clauses since they're idiomatic for "ignore the error".
+// noEmpty rejects empty block and switch statements unless an interior
+// comment documents the intentional no-op.
 // https://eslint.org/docs/latest/rules/no-empty
-type noEmpty struct{}
+type noEmpty struct{ optionsRule }
 
-func (noEmpty) Name() string           { return "no-empty" }
-func (noEmpty) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBlock} }
+type noEmptyOptions struct {
+  AllowEmptyCatch bool `json:"allowEmptyCatch"`
+}
+
+func (noEmpty) Name() string { return "no-empty" }
+func (noEmpty) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindBlock, shimast.KindSwitchStatement}
+}
 func (noEmpty) Check(ctx *Context, node *shimast.Node) {
-  block := node.AsBlock()
-  if block == nil || block.Statements == nil {
+  if node.Kind == shimast.KindSwitchStatement {
+    statement := node.AsSwitchStatement()
+    if statement == nil || statement.CaseBlock == nil {
+      return
+    }
+    caseBlock := statement.CaseBlock.AsCaseBlock()
+    if caseBlock == nil || caseBlock.Clauses != nil && len(caseBlock.Clauses.Nodes) != 0 {
+      return
+    }
+    if !emptyBracedBodyHasComment(ctx.File, statement.CaseBlock) {
+      ctx.Report(statement.CaseBlock, "Empty switch statement.")
+    }
     return
   }
-  if len(block.Statements.Nodes) > 0 {
+
+  block := node.AsBlock()
+  if block == nil || block.Statements != nil && len(block.Statements.Nodes) != 0 {
     return
   }
   parent := node.Parent
-  if parent != nil && parent.Kind == shimast.KindCatchClause {
-    return // tolerated — see ESLint default options
-  }
   if isFunctionLikeKind(parent) {
     return // empty function body is `no-empty-function`'s job
   }
-  ctx.Report(node, "Empty block statement.")
+  if parent != nil && parent.Kind == shimast.KindClassStaticBlockDeclaration {
+    return // static blocks have their own rule and are not BlockStatement in ESTree
+  }
+  var options noEmptyOptions
+  _ = ctx.DecodeOptions(&options)
+  if options.AllowEmptyCatch && parent != nil && parent.Kind == shimast.KindCatchClause {
+    return
+  }
+  if !emptyBracedBodyHasComment(ctx.File, node) {
+    ctx.Report(node, "Empty block statement.")
+  }
 }
 
 // noEmptyFunction: empty function / method / arrow / accessor bodies.
 // https://eslint.org/docs/latest/rules/no-empty-function
-type noEmptyFunction struct{}
+type noEmptyFunction struct{ optionsRule }
+
+type noEmptyFunctionOptions struct {
+  Allow []string `json:"allow"`
+}
 
 func (noEmptyFunction) Name() string { return "no-empty-function" }
 func (noEmptyFunction) Visits() []shimast.Kind {
@@ -45,19 +77,155 @@ func (noEmptyFunction) Visits() []shimast.Kind {
 }
 func (noEmptyFunction) Check(ctx *Context, node *shimast.Node) {
   body := node.Body()
-  if body == nil {
+  if body == nil || body.Kind != shimast.KindBlock {
     return
   }
-  if body.Kind != shimast.KindBlock {
+  block := body.AsBlock()
+  if block == nil || block.Statements != nil && len(block.Statements.Nodes) != 0 {
     return
   }
-  block := body.AsBlock()
-  if block == nil || block.Statements == nil {
+  var options noEmptyFunctionOptions
+  _ = ctx.DecodeOptions(&options)
+  kind := noEmptyFunctionKind(node)
+  if kind == "" || noEmptyFunctionAllowed(node, kind, options.Allow) || emptyBracedBodyHasComment(ctx.File, body) {
     return
   }
-  if len(block.Statements.Nodes) == 0 {
-    ctx.Report(node, "Unexpected empty function.")
+  ctx.Report(body, "Unexpected empty "+noEmptyFunctionLabel(kind)+".")
+}
+
+func noEmptyFunctionKind(node *shimast.Node) string {
+  if node == nil {
+    return ""
+  }
+  switch node.Kind {
+  case shimast.KindArrowFunction:
+    return "arrowFunctions"
+  case shimast.KindConstructor:
+    return "constructors"
+  case shimast.KindGetAccessor:
+    return "getters"
+  case shimast.KindSetAccessor:
+    return "setters"
+  case shimast.KindMethodDeclaration:
+    if noEmptyFunctionIsGenerator(node) {
+      return "generatorMethods"
+    }
+    if node.ModifierFlags()&shimast.ModifierFlagsAsync != 0 {
+      return "asyncMethods"
+    }
+    return "methods"
+  case shimast.KindFunctionDeclaration, shimast.KindFunctionExpression:
+    if noEmptyFunctionIsGenerator(node) {
+      return "generatorFunctions"
+    }
+    if node.ModifierFlags()&shimast.ModifierFlagsAsync != 0 {
+      return "asyncFunctions"
+    }
+    return "functions"
+  default:
+    return ""
+  }
+}
+
+func noEmptyFunctionIsGenerator(node *shimast.Node) bool {
+  switch node.Kind {
+  case shimast.KindFunctionDeclaration:
+    declaration := node.AsFunctionDeclaration()
+    return declaration != nil && declaration.AsteriskToken != nil
+  case shimast.KindFunctionExpression:
+    expression := node.AsFunctionExpression()
+    return expression != nil && expression.AsteriskToken != nil
+  case shimast.KindMethodDeclaration:
+    declaration := node.AsMethodDeclaration()
+    return declaration != nil && declaration.AsteriskToken != nil
+  default:
+    return false
+  }
+}
+
+func noEmptyFunctionAllowed(node *shimast.Node, kind string, allow []string) bool {
+  if noEmptyFunctionOptionIncludes(allow, kind) {
+    return true
+  }
+  if kind == "constructors" {
+    if hasParameterProperty(node) {
+      return true
+    }
+    modifiers := node.ModifierFlags()
+    if modifiers&shimast.ModifierFlagsPrivate != 0 && noEmptyFunctionOptionIncludes(allow, "privateConstructors") {
+      return true
+    }
+    if modifiers&shimast.ModifierFlagsProtected != 0 && noEmptyFunctionOptionIncludes(allow, "protectedConstructors") {
+      return true
+    }
+  }
+  switch kind {
+  case "methods", "generatorMethods", "asyncMethods", "getters", "setters":
+    if len(node.Decorators()) != 0 && noEmptyFunctionOptionIncludes(allow, "decoratedFunctions") {
+      return true
+    }
+    if node.ModifierFlags()&shimast.ModifierFlagsOverride != 0 && noEmptyFunctionOptionIncludes(allow, "overrideMethods") {
+      return true
+    }
+  }
+  return false
+}
+
+func noEmptyFunctionOptionIncludes(allow []string, candidate string) bool {
+  for _, option := range allow {
+    if option == candidate {
+      return true
+    }
+  }
+  return false
+}
+
+func noEmptyFunctionLabel(kind string) string {
+  switch kind {
+  case "arrowFunctions":
+    return "arrow function"
+  case "generatorFunctions":
+    return "generator function"
+  case "methods":
+    return "method"
+  case "generatorMethods":
+    return "generator method"
+  case "getters":
+    return "getter"
+  case "setters":
+    return "setter"
+  case "constructors":
+    return "constructor"
+  case "asyncFunctions":
+    return "async function"
+  case "asyncMethods":
+    return "async method"
+  default:
+    return "function"
+  }
+}
+
+// emptyBracedBodyHasComment scans only the trivia between the parser-owned
+// opening and closing brace tokens of an already-proven empty body. Exterior
+// comments cannot enter this range, and context-sensitive expression tokens
+// cannot occur because the body has no statements or switch clauses.
+func emptyBracedBodyHasComment(file *shimast.SourceFile, body *shimast.Node) bool {
+  if file == nil || body == nil {
+    return false
+  }
+  opening := shimscanner.GetScannerForSourceFile(file, body.Pos())
+  if opening.Token() != shimast.KindOpenBraceToken || opening.TokenEnd() > body.End() {
+    return false
+  }
+  closing := shimscanner.GetScannerForSourceFile(file, opening.TokenEnd())
+  if closing.Token() != shimast.KindCloseBraceToken || closing.TokenEnd() > body.End() {
+    return false
   }
+  found := false
+  scanCommentGap(shimscanner.NewScanner(), file.Text(), opening.TokenEnd(), closing.TokenStart(), func(_ shimast.Kind, _, _ int) {
+    found = true
+  })
+  return found
 }
 
 // noEmptyPattern: `({}) => x` or `function ({}) {}` — destructuring