@ttsc/lint 0.18.4 → 0.19.1

package/linthost/rules_suggestions.go

@@ -4,6 +4,7 @@
 package linthost
 
 import (
+  "encoding/json"
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
@@ -166,68 +167,179 @@ func isNullLiteral(node *shimast.Node) bool {
   return node != nil && node.Kind == shimast.KindNullKeyword
 }
 
-// noExtraBind: `(function () {}).bind(this)` where `this` isn't used
-// — only flag the case where the bind target is empty/parameterless,
-// keeping false-positives down.
+// noExtraBind reports `.bind(thisArg)` on arrow functions and regular
+// functions whose own lexical/function scope never reads `this`. Calls that
+// also bind ordinary arguments are partial applications and remain untouched.
+// https://eslint.org/docs/latest/rules/no-extra-bind
 type noExtraBind struct{}
 
 func (noExtraBind) Name() string           { return "no-extra-bind" }
 func (noExtraBind) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindCallExpression} }
 func (noExtraBind) Check(ctx *Context, node *shimast.Node) {
   call := node.AsCallExpression()
-  if call == nil || call.Expression == nil {
+  target, member, receiver, ok := noExtraBindCallParts(call)
+  if !ok {
     return
   }
-  if call.Expression.Kind != shimast.KindPropertyAccessExpression {
+  if target.Kind == shimast.KindFunctionExpression && functionScopeReferencesThis(target) {
     return
   }
-  access := call.Expression.AsPropertyAccessExpression()
-  if access == nil || identifierText(access.Name()) != "bind" {
-    return
+
+  edits := noExtraBindFixEdits(ctx, node, call, member, receiver)
+  if len(edits) == 0 {
+    ctx.Report(node, "The function binding is unnecessary.")
+  } else {
+    ctx.ReportFix(node, "The function binding is unnecessary.", edits...)
   }
-  target := stripParens(access.Expression)
-  if target == nil {
-    return
+}
+
+// noExtraBindCallParts recognizes the complete syntactic bind call. Static
+// computed keys and optional member/call chains are accepted, but a dynamic
+// computed property is not assumed to be Function.prototype.bind. Exactly one
+// non-spread argument is required: zero arguments are not the canonical bind
+// shape, while later arguments perform meaningful partial application.
+func noExtraBindCallParts(call *shimast.CallExpression) (
+  target *shimast.Node,
+  member *shimast.Node,
+  receiver *shimast.Node,
+  ok bool,
+) {
+  if call == nil || call.Expression == nil || call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return nil, nil, nil, false
   }
-  if target.Kind != shimast.KindArrowFunction && target.Kind != shimast.KindFunctionExpression {
-    return
+  receiver = call.Arguments.Nodes[0]
+  if receiver == nil || receiver.Kind == shimast.KindSpreadElement {
+    return nil, nil, nil, false
   }
-  // Arrow functions don't have their own `this`; `.bind` is always
-  // useless on them.
-  if target.Kind == shimast.KindArrowFunction {
-    ctx.Report(node, "The function binding is unnecessary.")
-    return
+
+  member = stripParens(call.Expression)
+  parts, matched := referenceMemberParts(member)
+  if !matched || parts.private || parts.staticKey == nil || *parts.staticKey != "bind" {
+    return nil, nil, nil, false
   }
-  body := target.Body()
-  if body != nil && !bodyReferencesThis(body) {
-    ctx.Report(node, "The function binding is unnecessary.")
+  target = stripParens(parts.object)
+  if target == nil || (target.Kind != shimast.KindArrowFunction && target.Kind != shimast.KindFunctionExpression) {
+    return nil, nil, nil, false
   }
+  return target, member, receiver, true
 }
 
-func bodyReferencesThis(node *shimast.Node) bool {
-  if node == nil {
+// functionScopeReferencesThis searches the bound regular function itself.
+// Nested arrows inherit that function's `this`; nested regular functions and
+// class-owned initializers do not. Computed class/object keys and decorators
+// are evaluated outside their owning method or field, so their `this` still
+// belongs to the enclosing function.
+func functionScopeReferencesThis(root *shimast.Node) bool {
+  if root == nil {
     return false
   }
-  if node.Kind == shimast.KindThisKeyword {
-    return true
-  }
-  // Don't descend into nested function-likes — their `this` is
-  // independent.
-  if isFunctionLikeKind(node) && node.Parent != nil {
-    return false
+  var visit func(*shimast.Node) bool
+  visit = func(node *shimast.Node) bool {
+    if node == nil {
+      return false
+    }
+    if node.Kind == shimast.KindThisKeyword {
+      return noExtraBindThisBelongsToFunction(node, root)
+    }
+    found := false
+    node.ForEachChild(func(child *shimast.Node) bool {
+      found = visit(child)
+      return found
+    })
+    return found
   }
-  found := false
-  node.ForEachChild(func(child *shimast.Node) bool {
-    if found {
+  return visit(root)
+}
+
+func noExtraBindThisBelongsToFunction(node, root *shimast.Node) bool {
+  outerEvaluation := false
+  for ancestor := node.Parent; ancestor != nil; ancestor = ancestor.Parent {
+    if ancestor == root {
       return true
     }
-    if bodyReferencesThis(child) {
-      found = true
-      return true
+    switch ancestor.Kind {
+    case shimast.KindComputedPropertyName, shimast.KindDecorator:
+      outerEvaluation = true
+    case shimast.KindClassDeclaration, shimast.KindClassExpression:
+      // A class decorator runs outside that class, but still inside any
+      // enclosing method/function. Do not carry its marker across the class
+      // and accidentally skip an unrelated outer method boundary.
+      outerEvaluation = false
+    case shimast.KindClassStaticBlockDeclaration:
+      return false
+    case shimast.KindPropertyDeclaration:
+      if outerEvaluation {
+        outerEvaluation = false
+        continue
+      }
+      return false
+    case shimast.KindArrowFunction:
+      continue
+    }
+    if !isFunctionLikeKind(ancestor) {
+      continue
+    }
+    switch ancestor.Kind {
+    case shimast.KindMethodDeclaration,
+      shimast.KindGetAccessor,
+      shimast.KindSetAccessor,
+      shimast.KindConstructor:
+      if outerEvaluation {
+        outerEvaluation = false
+        continue
+      }
     }
     return false
-  })
-  return found
+  }
+  return false
+}
+
+// noExtraBindFixEdits removes the member access and its one-argument call as
+// separate ranges. Parentheses and comments before the member operator remain
+// byte-for-byte intact. The fix is withheld when evaluating the receiver may
+// have effects or when any comment lies inside discarded syntax.
+func noExtraBindFixEdits(
+  ctx *Context,
+  callNode *shimast.Node,
+  call *shimast.CallExpression,
+  member *shimast.Node,
+  receiver *shimast.Node,
+) []TextEdit {
+  if ctx == nil || ctx.File == nil || callNode == nil || call == nil || call.Expression == nil || member == nil ||
+    !noExtraBindReceiverIsSideEffectFree(receiver) {
+    return nil
+  }
+  parts, ok := referenceMemberParts(member)
+  if !ok || parts.object == nil {
+    return nil
+  }
+
+  src := ctx.File.Text()
+  memberStart := shimscanner.SkipTrivia(src, parts.object.End())
+  memberEnd := member.End()
+  callStart := shimscanner.SkipTrivia(src, call.Expression.End())
+  callEnd := callNode.End()
+  if memberStart < 0 || memberStart >= memberEnd || memberEnd > callStart || callStart >= callEnd || callEnd > len(src) {
+    return nil
+  }
+  if hasCommentBetween(src, memberStart, callEnd) {
+    return nil
+  }
+  return []TextEdit{
+    {Pos: memberStart, End: memberEnd, Text: ""},
+    {Pos: callStart, End: callEnd, Text: ""},
+  }
+}
+
+func noExtraBindReceiverIsSideEffectFree(node *shimast.Node) bool {
+  node = stripParens(node)
+  if node == nil {
+    return false
+  }
+  return isLiteralExpression(node) ||
+    node.Kind == shimast.KindIdentifier ||
+    node.Kind == shimast.KindThisKeyword ||
+    node.Kind == shimast.KindFunctionExpression
 }
 
 // noLabels: labels (`outer: for (...) { break outer; }`) are
@@ -598,20 +710,21 @@ func regexHasMultipleSpaces(src string) bool {
 }
 
 // noReturnAssign: `return a = b` mixes assignment with return.
-type noReturnAssign struct{}
+type noReturnAssign struct{ optionsRule }
 
 func (noReturnAssign) Name() string { return "no-return-assign" }
 func (noReturnAssign) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindReturnStatement, shimast.KindArrowFunction}
 }
 func (noReturnAssign) Check(ctx *Context, node *shimast.Node) {
+  always := noReturnAssignAlways(ctx)
   switch node.Kind {
   case shimast.KindReturnStatement:
     ret := node.AsReturnStatement()
     if ret == nil || ret.Expression == nil {
       return
     }
-    if isAssignmentExpression(stripParens(ret.Expression)) {
+    if noReturnAssignFlags(ret.Expression, always) {
       ctx.Report(node, "Return statement should not contain assignment.")
     }
   case shimast.KindArrowFunction:
@@ -619,12 +732,53 @@ func (noReturnAssign) Check(ctx *Context, node *shimast.Node) {
     if arrow == nil || arrow.Body == nil || arrow.Body.Kind == shimast.KindBlock {
       return
     }
-    if isAssignmentExpression(stripParens(arrow.Body)) {
+    if noReturnAssignFlags(arrow.Body, always) {
       ctx.Report(node, "Arrow function should not return an assignment.")
     }
   }
 }
 
+// noReturnAssignFlags reports whether a return/arrow operand should be flagged.
+// Under the default `except-parens` an explicitly parenthesized assignment
+// (`return (a = 1)`) is allowed, so the operand is tested as written: a
+// wrapping ParenthesizedExpression is not a BinaryExpression and fails the
+// assignment test. Under `always` the parentheses are stripped first so the
+// wrapped assignment is flagged too. This matches ESLint no-return-assign's
+// default and the parenthesis exemption `no-cond-assign` already applies.
+func noReturnAssignFlags(expr *shimast.Node, always bool) bool {
+  if always {
+    return isAssignmentExpression(stripParens(expr))
+  }
+  return isAssignmentExpression(expr)
+}
+
+// noReturnAssignAlways reports whether the rule runs in `always` mode, where a
+// parenthesized assignment is flagged as well. The single positional string
+// option arrives either bare (`"always"`) or as the first slot of an array,
+// mirroring the transport `resolveNoInnerDeclarationsOptions` documents.
+func noReturnAssignAlways(ctx *Context) bool {
+  if ctx == nil || len(ctx.Options) == 0 {
+    return false
+  }
+  raw := strings.TrimSpace(string(ctx.Options))
+  if raw == "" {
+    return false
+  }
+  var slots []json.RawMessage
+  if raw[0] == '[' {
+    if err := json.Unmarshal([]byte(raw), &slots); err != nil {
+      return false
+    }
+  } else {
+    slots = []json.RawMessage{json.RawMessage(raw)}
+  }
+  if len(slots) == 0 {
+    return false
+  }
+  var mode string
+  return json.Unmarshal(slots[0], &mode) == nil && mode == "always"
+}
+
 // noSequences: `(a, b)` — comma operator. Almost always a confusing
 // pattern outside of `for` headers.
 type noSequences struct{}
@@ -812,8 +966,23 @@ func needsParensForUnaryNegation(node *shimast.Node) bool {
 }
 
 // noUnusedExpressions: an expression statement whose value isn't used.
-// Filtered down to common patterns ESLint flags by default.
-type noUnusedExpressions struct{}
+// Direct port of ESLint's default semantics: a disallow-list of
+// side-effect-free expression shapes (unknown shapes are ignored, the way
+// upstream treats unknown node types), directive prologues exempted by AST
+// position rather than by recognized text, and the upstream option set
+// (`allowShortCircuit`, `allowTernary`, `allowTaggedTemplates`,
+// `enforceForJSX`, `ignoreDirectives`) decoded from the rule's options blob.
+type noUnusedExpressions struct{ optionsRule }
+
+// noUnusedExpressionsOptions mirrors the upstream ESLint option object;
+// every flag defaults to false, matching the rule's `defaultOptions`.
+type noUnusedExpressionsOptions struct {
+  AllowShortCircuit    bool `json:"allowShortCircuit"`
+  AllowTernary         bool `json:"allowTernary"`
+  AllowTaggedTemplates bool `json:"allowTaggedTemplates"`
+  EnforceForJSX        bool `json:"enforceForJSX"`
+  IgnoreDirectives     bool `json:"ignoreDirectives"`
+}
 
 func (noUnusedExpressions) Name() string { return "no-unused-expressions" }
 func (noUnusedExpressions) Visits() []shimast.Kind {
@@ -824,61 +993,198 @@ func (noUnusedExpressions) Check(ctx *Context, node *shimast.Node) {
   if stmt == nil || stmt.Expression == nil {
     return
   }
-  if isProductiveExpression(stmt.Expression) {
+  var opts noUnusedExpressionsOptions
+  _ = ctx.DecodeOptions(&opts)
+  if !noUnusedExpressionsDisallows(stmt.Expression, opts) {
+    return
+  }
+  // A directive prologue member ("use strict", "use client", …) is
+  // positionally meaningful whatever its text; never report it. The
+  // `ignoreDirectives` variant additionally applies upstream's loose
+  // ESTree view, in which parentheses are invisible, so a parenthesized
+  // string inside the leading string run is exempted too.
+  if noUnusedExpressionsIsDirective(node, false) {
+    return
+  }
+  if opts.IgnoreDirectives && noUnusedExpressionsIsDirective(node, true) {
     return
   }
   ctx.Report(node, "Expected an assignment or function call and instead saw an expression.")
 }
 
-func isProductiveExpression(node *shimast.Node) bool {
-  expr := stripParens(node)
+// noUnusedExpressionsDisallows reports whether expr is a side-effect-free
+// shape the rule must flag when it stands alone as a statement. Ports the
+// upstream Checker disallow-list: shapes not listed (calls, `new`,
+// assignments, updates, `await`, `yield`, `void`, `delete`, dynamic
+// `import()`, `satisfies`, …) are ignored, mirroring ESLint's "unknown
+// nodes are handled as false" contract. Parenthesized expressions are
+// transparent because ESTree has no parenthesized-expression node, and the
+// TypeScript wrapper expressions (`as`, angle assertions, non-null `!`,
+// instantiation expressions) inherit the classification of the expression
+// they wrap.
+func noUnusedExpressionsDisallows(expr *shimast.Node, opts noUnusedExpressionsOptions) bool {
+  expr = stripParens(expr)
   if expr == nil {
     return false
   }
   switch expr.Kind {
-  case shimast.KindCallExpression,
-    shimast.KindNewExpression,
-    shimast.KindAwaitExpression,
-    shimast.KindYieldExpression,
-    shimast.KindDeleteExpression,
-    shimast.KindBinaryExpression,
-    shimast.KindPrefixUnaryExpression,
-    shimast.KindPostfixUnaryExpression,
-    shimast.KindTaggedTemplateExpression:
-    // Most of these kinds are unconditionally productive (call, new, await,
-    // yield, delete, tagged template). The inner switch narrows the two kinds
-    // that can be non-productive: a BinaryExpression is only productive when
-    // it is an assignment, and a PrefixUnaryExpression is only productive when
-    // it is ++ or --. KindPostfixUnaryExpression is always productive (++ and
-    // -- are the only postfix operators). All un-matched cases reach the
-    // outer `return true` below.
-    switch expr.Kind {
-    case shimast.KindBinaryExpression:
-      bin := expr.AsBinaryExpression()
-      if bin != nil && bin.OperatorToken != nil && isAssignmentOperator(bin.OperatorToken.Kind) {
-        return true
-      }
+  case shimast.KindArrayLiteralExpression,
+    shimast.KindObjectLiteralExpression,
+    shimast.KindArrowFunction,
+    shimast.KindFunctionExpression,
+    shimast.KindClassExpression,
+    shimast.KindIdentifier,
+    shimast.KindPropertyAccessExpression,
+    shimast.KindElementAccessExpression,
+    shimast.KindMetaProperty,
+    shimast.KindThisKeyword,
+    shimast.KindStringLiteral,
+    shimast.KindNumericLiteral,
+    shimast.KindBigIntLiteral,
+    shimast.KindRegularExpressionLiteral,
+    shimast.KindTrueKeyword,
+    shimast.KindFalseKeyword,
+    shimast.KindNullKeyword,
+    shimast.KindTemplateExpression,
+    shimast.KindNoSubstitutionTemplateLiteral,
+    shimast.KindTypeOfExpression:
+    return true
+  case shimast.KindBinaryExpression:
+    bin := expr.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil {
       return false
-    case shimast.KindPrefixUnaryExpression:
-      prefix := expr.AsPrefixUnaryExpression()
-      if prefix != nil && (prefix.Operator == shimast.KindPlusPlusToken || prefix.Operator == shimast.KindMinusMinusToken) {
-        return true
+    }
+    switch bin.OperatorToken.Kind {
+    case shimast.KindAmpersandAmpersandToken,
+      shimast.KindBarBarToken,
+      shimast.KindQuestionQuestionToken:
+      // ESTree LogicalExpression: only the right operand's value goes
+      // unused, so `allowShortCircuit` defers to its classification.
+      if opts.AllowShortCircuit {
+        return noUnusedExpressionsDisallows(bin.Right, opts)
       }
-      return false
-    case shimast.KindPostfixUnaryExpression:
       return true
     }
+    if isAssignmentOperator(bin.OperatorToken.Kind) {
+      // ESTree AssignmentExpression (including `&&=`, `||=`, `??=`) —
+      // productive.
+      return false
+    }
+    // Comma sequences and ordinary binary operators (`a + b`,
+    // `a === b`, `key in obj`, …) compute a value nobody reads.
     return true
-  case shimast.KindStringLiteral:
-    // "use strict" prologue.
-    text := expr.AsStringLiteral()
-    if text != nil && (text.Text == "use strict" || text.Text == "use asm") {
+  case shimast.KindPrefixUnaryExpression:
+    prefix := expr.AsPrefixUnaryExpression()
+    if prefix == nil {
+      return false
+    }
+    // `++x` / `--x` are ESTree UpdateExpressions (productive); the
+    // remaining prefix operators (`+`, `-`, `!`, `~`) are pure.
+    return prefix.Operator != shimast.KindPlusPlusToken &&
+      prefix.Operator != shimast.KindMinusMinusToken
+  case shimast.KindConditionalExpression:
+    cond := expr.AsConditionalExpression()
+    if cond == nil {
+      return false
+    }
+    if opts.AllowTernary {
+      // Disallowed when either result branch is itself side-effect
+      // free; recursion keeps nested allowances working.
+      return noUnusedExpressionsDisallows(cond.WhenTrue, opts) ||
+        noUnusedExpressionsDisallows(cond.WhenFalse, opts)
+    }
+    return true
+  case shimast.KindTaggedTemplateExpression:
+    return !opts.AllowTaggedTemplates
+  case shimast.KindJsxElement,
+    shimast.KindJsxSelfClosingElement,
+    shimast.KindJsxFragment:
+    return opts.EnforceForJSX
+  case shimast.KindAsExpression:
+    as := expr.AsAsExpression()
+    return as != nil && as.Expression != nil &&
+      noUnusedExpressionsDisallows(as.Expression, opts)
+  case shimast.KindTypeAssertionExpression:
+    assertion := expr.AsTypeAssertion()
+    return assertion != nil && assertion.Expression != nil &&
+      noUnusedExpressionsDisallows(assertion.Expression, opts)
+  case shimast.KindNonNullExpression:
+    nonNull := expr.AsNonNullExpression()
+    return nonNull != nil && nonNull.Expression != nil &&
+      noUnusedExpressionsDisallows(nonNull.Expression, opts)
+  case shimast.KindExpressionWithTypeArguments:
+    instantiation := expr.AsExpressionWithTypeArguments()
+    return instantiation != nil && instantiation.Expression != nil &&
+      noUnusedExpressionsDisallows(instantiation.Expression, opts)
+  }
+  return false
+}
+
+// noUnusedExpressionsIsDirective reports whether stmt sits inside its
+// container's directive prologue — the leading run of string-literal
+// expression statements of a script or module body, a function body, or a
+// TypeScript namespace/module block
+// (https://tc39.es/ecma262/#directive-prologue). Class static blocks and
+// plain nested blocks own no prologue.
+//
+// seeThroughParens selects the `ignoreDirectives` variant: upstream ESLint
+// evaluates that option against an ESTree, which has no
+// parenthesized-expression nodes, so the loose variant lets a
+// parenthesized string participate in the leading run. The strict variant
+// matches the parser's directive notion, where `("use strict")` is not a
+// directive and terminates the prologue.
+func noUnusedExpressionsIsDirective(stmt *shimast.Node, seeThroughParens bool) bool {
+  if stmt == nil || !noUnusedExpressionsCanOwnPrologue(stmt.Parent) {
+    return false
+  }
+  for _, sibling := range parentStatements(stmt.Parent) {
+    if !noUnusedExpressionsIsStringStatement(sibling, seeThroughParens) {
+      return false
+    }
+    if nodesShareLoc(sibling, stmt) {
       return true
     }
   }
   return false
 }
 
+// noUnusedExpressionsCanOwnPrologue reports whether parent is a statement
+// container whose leading string statements form a directive prologue: a
+// source file (script or module), a namespace/module block, or the body
+// block of a function-like declaration. Mirrors upstream ESLint's
+// isTopLevelExpressionStatement (Program | TSModuleBlock | function body).
+func noUnusedExpressionsCanOwnPrologue(parent *shimast.Node) bool {
+  if parent == nil {
+    return false
+  }
+  switch parent.Kind {
+  case shimast.KindSourceFile, shimast.KindModuleBlock:
+    return true
+  case shimast.KindBlock:
+    return isFunctionLikeKind(parent.Parent)
+  }
+  return false
+}
+
+// noUnusedExpressionsIsStringStatement reports whether stmt is an
+// expression statement consisting of a string literal — the shape that can
+// extend a directive prologue. With seeThroughParens the string may sit
+// behind parentheses (the ESTree view used by `ignoreDirectives`).
+func noUnusedExpressionsIsStringStatement(stmt *shimast.Node, seeThroughParens bool) bool {
+  if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
+    return false
+  }
+  inner := stmt.AsExpressionStatement()
+  if inner == nil || inner.Expression == nil {
+    return false
+  }
+  expr := inner.Expression
+  if seeThroughParens {
+    expr = stripParens(expr)
+  }
+  return expr != nil && expr.Kind == shimast.KindStringLiteral
+}
+
 // noUselessCall: `func.call(undefined, ...args)` / `func.apply(undefined, args)`
 // — call/apply with no this binding is just a regular call.
 type noUselessCall struct{}
@@ -1006,6 +1312,14 @@ func reportUselessRenameFix(ctx *Context, node, propertyName, name *shimast.Node
     ctx.Report(node, message)
     return
   }
+  // A comment between the two names (`{ a as /* c */ a }`) sits inside the
+  // deleted rename tail; dropping it would be silent data loss, so decline to
+  // a report-only diagnostic. Mirrors ESLint no-useless-rename's
+  // `commentsExistBetween` guard.
+  if hasCommentBetween(ctx.File.Text(), propertyName.End(), name.End()) {
+    ctx.Report(node, message)
+    return
+  }
   ctx.ReportFix(
     node,
     message,
@@ -1035,6 +1349,14 @@ func (objectShorthand) Check(ctx *Context, node *shimast.Node) {
   // at the end of the property name and ends at the end of the
   // initializer; any whitespace between `:` and the value is part of
   // that range.
+  //
+  // A comment inside that range (`{ x: /* c */ x }`) would be dropped by the
+  // deletion, so decline to a report-only diagnostic. Mirrors ESLint
+  // object-shorthand's `commentsExistBetween` guard.
+  if hasCommentBetween(ctx.File.Text(), prop.Name().End(), prop.Initializer.End()) {
+    ctx.Report(node, "Expected property shorthand.")
+    return
+  }
   ctx.ReportFix(
     node,
     "Expected property shorthand.",
@@ -1172,6 +1494,16 @@ func (preferTemplate) Check(ctx *Context, node *shimast.Node) {
     ctx.Report(node, message)
     return
   }
+  // A comment in an operator seam (`"a" + /* c */ b`) is dropped by the
+  // template rebuild, so decline to a report-only diagnostic. Mirrors ESLint
+  // prefer-template's `commentsExistBetween` guard. Only the seams are scanned:
+  // operand interiors are copied verbatim (their comments survive) and string
+  // contents are cooked, so scanning the whole span would misread a `//` or
+  // `/*` inside a string literal (`"https://" + host`) as a comment.
+  if concatOperandSeamsHaveComment(src, operands) {
+    ctx.Report(node, message)
+    return
+  }
   ctx.ReportFix(
     node,
     message,
@@ -1179,6 +1511,27 @@ func (preferTemplate) Check(ctx *Context, node *shimast.Node) {
   )
 }
 
+// concatOperandSeamsHaveComment reports whether a comment sits in any seam
+// between the flattened concat operands — the `+`-operator gaps the template
+// rebuild collapses. A leading comment before an operand is skipped by the
+// renderer (both string and expression operands begin at their trimmed token),
+// so a seam comment would be lost and the fix must decline. Operand interiors
+// are excluded because the renderer copies expression operands verbatim and
+// cooks string operands, so their contents — including a `//`-bearing URL
+// string — never trigger a false positive.
+func concatOperandSeamsHaveComment(src string, operands []*shimast.Node) bool {
+  for i := 0; i+1 < len(operands); i++ {
+    left, right := operands[i], operands[i+1]
+    if left == nil || right == nil {
+      continue
+    }
+    if hasCommentBetween(src, left.End(), shimscanner.SkipTrivia(src, right.Pos())) {
+      return true
+    }
+  }
+  return false
+}
+
 func concatChainShape(node *shimast.Node) (hasString bool, hasOther bool) {
   if node == nil {
     return false, false
@@ -1198,17 +1551,24 @@ func concatChainShape(node *shimast.Node) (hasString bool, hasOther bool) {
 }
 
 // flattenConcatOperands walks a `+` chain left-to-right and returns each
-// leaf operand in source order. Parenthesized sub-expressions are kept as
-// a single operand so the rendered template literal does not lose their
-// grouping. Mirrors ESLint's behavior of treating `("a" + b)` as one
-// expression slot when it appears inside a larger chain.
+// leaf operand in source order. It only descends into a `+` subtree that
+// itself contains a string-like operand (see
+// concatChainContainsString): a subtree without one — the `a + b` in
+// `a + b + " items"` — evaluates BEFORE any string concatenation, so
+// splitting it into separate `${a}${b}` slots would change the runtime
+// value (numeric 3 becomes the digits "12"). Such a subtree stays one
+// operand and renders as a single `${a + b}` slot, mirroring upstream
+// ESLint prefer-template, which embeds non-string sub-chains as one
+// expression. Parenthesized sub-expressions are likewise kept as a
+// single operand so the rendered template literal does not lose their
+// grouping.
 func flattenConcatOperands(node *shimast.Node) []*shimast.Node {
   if node == nil {
     return nil
   }
   if node.Kind == shimast.KindBinaryExpression {
     bin := node.AsBinaryExpression()
-    if bin != nil && bin.OperatorToken != nil && bin.OperatorToken.Kind == shimast.KindPlusToken {
+    if bin != nil && bin.OperatorToken != nil && bin.OperatorToken.Kind == shimast.KindPlusToken && concatChainContainsString(node) {
       out := flattenConcatOperands(bin.Left)
       out = append(out, flattenConcatOperands(bin.Right)...)
       return out
@@ -1217,17 +1577,61 @@ func flattenConcatOperands(node *shimast.Node) []*shimast.Node {
   return []*shimast.Node{node}
 }
 
+// concatChainContainsString reports whether a `+` chain (or a single
+// operand) contains a string-like operand: a string literal, a template
+// literal (with or without substitutions), or a nested `+` chain —
+// parenthesized or not — that itself contains one. This is the
+// flattening gate for flattenConcatOperands. Once a string-like operand
+// appears in a left-associative chain, every later `+` is string
+// concatenation, so splitting the chain into template segments preserves
+// the value; a chain with none may be numeric addition and must stay
+// whole. Parentheses are transparent to the DECISION (`("a" + b) + c`
+// is a string chain, so `c` still gets its own slot) even though the
+// flattener keeps the parenthesized operand itself as one slot. A
+// string-like node under any other operator (e.g. `a * "x"`) does NOT
+// qualify: that subexpression coerces away from string, so its chain
+// may still be numeric addition.
+func concatChainContainsString(node *shimast.Node) bool {
+  node = stripParens(node)
+  if node == nil {
+    return false
+  }
+  if node.Kind == shimast.KindBinaryExpression {
+    bin := node.AsBinaryExpression()
+    if bin != nil && bin.OperatorToken != nil && bin.OperatorToken.Kind == shimast.KindPlusToken {
+      return concatChainContainsString(bin.Left) || concatChainContainsString(bin.Right)
+    }
+  }
+  return isStringLikeLiteral(node) || node.Kind == shimast.KindTemplateExpression
+}
+
 // renderConcatAsTemplate renders the flattened concat operands as a single
 // backtick template literal. String-like literals contribute their value
 // directly (with template-specific escaping); any other expression becomes
 // a `${…}` placeholder copied verbatim from the source text. Returns ok=false
 // when an operand cannot be rendered (typically because its source range is
 // unavailable), so the caller falls back to detection-only.
+//
+// Adjacent literal operands are merged into one cooked run BEFORE
+// escaping. Escaping each literal on its own cannot see across the seam,
+// so `"$" + "{"` would emit `$` then `{` — fusing into a live `${`
+// interpolation opener in the rendered template. Escaping the merged run
+// makes escapeTemplateLiteralBody's `${` lookahead total over the body.
+// The only other seam, a literal's trailing `$` followed by an emitted
+// `${…}` placeholder, is safe: `$${expr}` parses as a literal `$` plus
+// the interpolation, which matches the original `"$" + expr` value.
 func renderConcatAsTemplate(src string, operands []*shimast.Node) (string, bool) {
   if len(operands) == 0 {
     return "", false
   }
   var sb strings.Builder
+  var literal strings.Builder
+  flushLiteral := func() {
+    if literal.Len() > 0 {
+      sb.WriteString(escapeTemplateLiteralBody(literal.String()))
+      literal.Reset()
+    }
+  }
   sb.WriteByte('`')
   for _, operand := range operands {
     if operand == nil {
@@ -1235,7 +1639,7 @@ func renderConcatAsTemplate(src string, operands []*shimast.Node) (string, bool)
     }
     inner := stripParens(operand)
     if isStringLikeLiteral(inner) {
-      sb.WriteString(escapeTemplateLiteralBody(stringLiteralText(inner)))
+      literal.WriteString(stringLiteralText(inner))
       continue
     }
     pos := shimscanner.SkipTrivia(src, operand.Pos())
@@ -1243,10 +1647,12 @@ func renderConcatAsTemplate(src string, operands []*shimast.Node) (string, bool)
     if pos < 0 || pos >= end || end > len(src) {
       return "", false
     }
+    flushLiteral()
     sb.WriteString("${")
     sb.WriteString(src[pos:end])
     sb.WriteByte('}')
   }
+  flushLiteral()
   sb.WriteByte('`')
   return sb.String(), true
 }