@ttsc/lint 0.18.3 → 0.19.0

package/linthost/ast_helpers.go

@@ -1,6 +1,7 @@
 package linthost
 
 import (
+  "regexp"
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
@@ -26,6 +27,36 @@ func nodeText(file *shimast.SourceFile, node *shimast.Node) string {
   return strings.TrimRight(src[pos:end], " \t\r\n")
 }
 
+// templateRawNewlinePattern is acorn's TemplateElement raw normalization
+// (`raw.replace(/\r\n?/g, "\n")` in parseTemplateElement).
+var templateRawNewlinePattern = regexp.MustCompile(`\r\n?`)
+
+// normalizeTemplateRaw reproduces the raw value ESLint sees for a template
+// quasi: acorn materializes `TemplateElement.value.raw` with CR / CRLF
+// collapsed to LF, so upstream rules both match patterns against and rewrite
+// from the LF-normalized text. TypeScript's scanner performs the same
+// collapse while cooking a template token (ECMA-262 normalizes <CR> and
+// <CRLF> to <LF> in template values), so a raw payload sliced straight out of
+// a CRLF source file must be normalized before it is compared with, or
+// substituted back into, a cooked value.
+func normalizeTemplateRaw(raw string) string {
+  return templateRawNewlinePattern.ReplaceAllString(raw, "\n")
+}
+
+// isTaggedTemplateQuasi reports whether `node` is the template argument of a
+// TaggedTemplateExpression — the position whose RAW text the tag function
+// observes, and therefore the one where escape spelling is meaningful.
+// A literal that merely appears somewhere inside a tagged template (e.g.
+// within a substitution) or that sits in the tag slot is not the quasi and
+// stays checked, mirroring upstream's isTaggedTemplateLiteral.
+func isTaggedTemplateQuasi(node *shimast.Node) bool {
+  if node == nil || node.Parent == nil || node.Parent.Kind != shimast.KindTaggedTemplateExpression {
+    return false
+  }
+  tagged := node.Parent.AsTaggedTemplateExpression()
+  return tagged != nil && tagged.Template == node
+}
+
 // keywordStart returns the source offset of a declaration keyword such as
 // `var` or `let` at the start of a node after leading trivia.
 func keywordStart(file *shimast.SourceFile, node *shimast.Node, keyword string) int {
@@ -113,6 +144,103 @@ func tokenRange(file *shimast.SourceFile, node *shimast.Node) (int, int) {
   return pos, end
 }
 
+// isTaggedTemplateElement reports whether a template token — a
+// `KindNoSubstitutionTemplateLiteral` or one of the
+// `KindTemplateHead`/`Middle`/`Tail` elements of a `KindTemplateExpression`
+// — belongs to the quasi of a TaggedTemplateExpression. The tag function
+// observes the raw text (`String.raw`, `dedent`, `gql`, `css`, …), so rules
+// that police escape spelling must leave tagged templates alone; this is
+// upstream's `isTaggedTemplateLiteral(node.parent)` guard on its
+// `TemplateElement` handlers.
+//
+// A template that merely appears inside a tagged template — nested in one of
+// its substitutions — is not tagged itself and stays checked, so the walk
+// stops at the element's own enclosing template instead of searching upward
+// for any tag. Template literal *types* can never be tagged and always
+// answer false.
+func isTaggedTemplateElement(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  template := node
+  switch node.Kind {
+  case shimast.KindNoSubstitutionTemplateLiteral:
+    // The literal is the whole template; the tag, if any, is its parent.
+  case shimast.KindTemplateHead:
+    template = node.Parent
+  case shimast.KindTemplateMiddle, shimast.KindTemplateTail:
+    if node.Parent == nil {
+      return false
+    }
+    template = node.Parent.Parent
+  default:
+    return false
+  }
+  if template == nil || template.Parent == nil ||
+    template.Parent.Kind != shimast.KindTaggedTemplateExpression {
+    return false
+  }
+  tagged := template.Parent.AsTaggedTemplateExpression()
+  return tagged != nil && tagged.Template == template
+}
+
+// isInsideTaggedTemplate reports whether a whole-template node — a
+// `KindNoSubstitutionTemplateLiteral` or a `KindTemplateExpression` — sits
+// anywhere inside a TaggedTemplateExpression, walking up to three ancestors so
+// a template reached through a substitution span also answers true. Unlike the
+// precise `isTaggedTemplateElement`, which asks only whether a template token's
+// OWN enclosing template is tagged, this treats any enclosing tag as tainting.
+// Used by `typescript/no-unnecessary-template-expression`.
+func isInsideTaggedTemplate(node *shimast.Node) bool {
+  if node == nil || node.Parent == nil {
+    return false
+  }
+  parent := node.Parent
+  if parent.Kind == shimast.KindTaggedTemplateExpression {
+    return true
+  }
+  // Walk up at most two more hops to reach the TaggedTemplateExpression
+  // for the spans family.
+  for i := 0; i < 2 && parent.Parent != nil; i++ {
+    parent = parent.Parent
+    if parent.Kind == shimast.KindTaggedTemplateExpression {
+      return true
+    }
+  }
+  return false
+}
+
+// hasCommentBetween reports whether a comment begins anywhere in the source
+// range [from, to). Fixers whose TextEdit keeps only part of the replaced
+// span use it on the discarded sub-ranges: a comment there would be silently
+// deleted by the edit, so the fix must be declined.
+//
+// The scan alternates SkipTriviaEx (whitespace, with StopAtComments so a
+// comment opener is not consumed) with a two-byte opener check that
+// distinguishes `//` and `/*` from a bare slash token. Non-trivia token
+// bytes are stepped over one at a time, so an opener lookalike inside a
+// string literal within the range would over-detect; callers only ever
+// decline an autofix on a hit, which is the safe direction.
+func hasCommentBetween(src string, from, to int) bool {
+  if from < 0 {
+    return false
+  }
+  if to > len(src) {
+    to = len(src)
+  }
+  for pos := from; pos < to; {
+    next := shimscanner.SkipTriviaEx(src, pos, &shimscanner.SkipTriviaOptions{StopAtComments: true})
+    if next < pos || next >= to {
+      return false
+    }
+    if src[next] == '/' && next+1 < len(src) && (src[next+1] == '/' || src[next+1] == '*') {
+      return true
+    }
+    pos = next + 1
+  }
+  return false
+}
+
 // isIdentifierPart reports whether `ch` can appear inside a JavaScript
 // identifier — used as a word-boundary guard by keyword search helpers.
 // Handles only ASCII; multibyte Unicode identifier parts are treated as
@@ -152,6 +280,184 @@ func stripParens(node *shimast.Node) *shimast.Node {
   return node
 }
 
+// sameReferenceExpression reports whether two expressions denote the same
+// repeatable runtime reference. Parentheses and TypeScript's type-only
+// expression wrappers are transparent; identifiers, primitive literals,
+// `this` / `super`, and property or element-access chains are compared
+// recursively. Calls and other effectful expressions are deliberately rejected
+// even when their source text is identical because evaluating them twice need
+// not produce the same value.
+//
+// Static member keys are normalized to their runtime property key, so `x.y`
+// and `x["y"]` compare equal. Optional and non-optional member accesses remain
+// distinct because optional chaining changes evaluation semantics.
+func sameReferenceExpression(left, right *shimast.Node) bool {
+  left = unwrapReferenceExpression(left)
+  right = unwrapReferenceExpression(right)
+  if left == nil || right == nil {
+    return false
+  }
+
+  switch left.Kind {
+  case shimast.KindIdentifier, shimast.KindPrivateIdentifier:
+    return left.Kind == right.Kind && shimast.NodeText(left) == shimast.NodeText(right)
+  case shimast.KindThisKeyword, shimast.KindSuperKeyword:
+    return left.Kind == right.Kind
+  case shimast.KindPropertyAccessExpression, shimast.KindElementAccessExpression:
+    leftMember, ok := referenceMemberParts(left)
+    if !ok {
+      return false
+    }
+    rightMember, ok := referenceMemberParts(right)
+    if !ok || leftMember.optional != rightMember.optional ||
+      !sameReferenceExpression(leftMember.object, rightMember.object) {
+      return false
+    }
+    if leftMember.staticKey != nil || rightMember.staticKey != nil {
+      return leftMember.staticKey != nil && rightMember.staticKey != nil &&
+        *leftMember.staticKey == *rightMember.staticKey &&
+        leftMember.private == rightMember.private
+    }
+    return sameReferenceExpression(leftMember.dynamicKey, rightMember.dynamicKey)
+  default:
+    leftValue, leftKind, leftOK := referencePrimitiveValue(left)
+    rightValue, rightKind, rightOK := referencePrimitiveValue(right)
+    return leftOK && rightOK && leftKind == rightKind && leftValue == rightValue
+  }
+}
+
+// unwrapReferenceExpression removes syntax that has no runtime evaluation of
+// its own. Keep this list explicit: optional chains, calls, and instantiation
+// expressions are not harmless wrappers and must remain visible to callers.
+func unwrapReferenceExpression(node *shimast.Node) *shimast.Node {
+  for node != nil {
+    switch node.Kind {
+    case shimast.KindParenthesizedExpression,
+      shimast.KindAsExpression,
+      shimast.KindSatisfiesExpression,
+      shimast.KindNonNullExpression,
+      shimast.KindTypeAssertionExpression:
+      next := node.Expression()
+      if next == nil {
+        return node
+      }
+      node = next
+    default:
+      return node
+    }
+  }
+  return nil
+}
+
+type referenceMember struct {
+  object     *shimast.Node
+  staticKey  *string
+  dynamicKey *shimast.Node
+  optional   bool
+  private    bool
+}
+
+func referenceMemberParts(node *shimast.Node) (referenceMember, bool) {
+  switch node.Kind {
+  case shimast.KindPropertyAccessExpression:
+    access := node.AsPropertyAccessExpression()
+    if access == nil || access.Expression == nil || access.Name() == nil {
+      return referenceMember{}, false
+    }
+    name := access.Name()
+    if name.Kind != shimast.KindIdentifier && name.Kind != shimast.KindPrivateIdentifier {
+      return referenceMember{}, false
+    }
+    key := shimast.NodeText(name)
+    return referenceMember{
+      object:    access.Expression,
+      staticKey: &key,
+      optional:  access.QuestionDotToken != nil,
+      private:   name.Kind == shimast.KindPrivateIdentifier,
+    }, true
+  case shimast.KindElementAccessExpression:
+    access := node.AsElementAccessExpression()
+    if access == nil || access.Expression == nil || access.ArgumentExpression == nil {
+      return referenceMember{}, false
+    }
+    member := referenceMember{
+      object:     access.Expression,
+      dynamicKey: access.ArgumentExpression,
+      optional:   access.QuestionDotToken != nil,
+    }
+    if key, ok := referenceStaticPropertyKey(access.ArgumentExpression); ok {
+      member.staticKey = &key
+      member.dynamicKey = nil
+    }
+    return member, true
+  default:
+    return referenceMember{}, false
+  }
+}
+
+func referenceStaticPropertyKey(node *shimast.Node) (string, bool) {
+  node = unwrapReferenceExpression(node)
+  if node == nil {
+    return "", false
+  }
+  value, kind, ok := referencePrimitiveValue(node)
+  if ok {
+    if kind == "bigint" {
+      value = strings.TrimSuffix(value, "n")
+    }
+    return value, true
+  }
+  if node.Kind != shimast.KindPrefixUnaryExpression {
+    return "", false
+  }
+  prefix := node.AsPrefixUnaryExpression()
+  if prefix == nil || prefix.Operand == nil {
+    return "", false
+  }
+  value, kind, ok = referencePrimitiveValue(prefix.Operand)
+  if !ok || (kind != "number" && kind != "bigint") {
+    return "", false
+  }
+  value = strings.TrimSuffix(value, "n")
+  switch prefix.Operator {
+  case shimast.KindPlusToken:
+    return value, kind == "number"
+  case shimast.KindMinusToken:
+    if strings.Trim(value, "0.") == "" {
+      return "0", true
+    }
+    return "-" + value, true
+  default:
+    return "", false
+  }
+}
+
+// referencePrimitiveValue returns a normalized value plus a runtime-kind tag.
+// The tag keeps numerically similar values such as `1` and `1n` distinct when
+// they are receivers; referenceStaticPropertyKey intentionally collapses them
+// later because JavaScript converts both to the same string property key.
+func referencePrimitiveValue(node *shimast.Node) (value, kind string, ok bool) {
+  if node == nil {
+    return "", "", false
+  }
+  switch node.Kind {
+  case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+    return stringLiteralText(node), "string", true
+  case shimast.KindNumericLiteral:
+    return numericLiteralText(node), "number", true
+  case shimast.KindBigIntLiteral:
+    return numericLiteralText(node), "bigint", true
+  case shimast.KindTrueKeyword:
+    return "true", "boolean", true
+  case shimast.KindFalseKeyword:
+    return "false", "boolean", true
+  case shimast.KindNullKeyword:
+    return "null", "null", true
+  default:
+    return "", "", false
+  }
+}
+
 // isMatchingPropertyAccess reports whether `node` reads the chain
 // `head.tail[0].tail[1]…`. Useful for detecting `obj.__proto__` or
 // `console.log` shapes regardless of nesting.
@@ -305,83 +611,275 @@ func (w *descendantsWalker) visitChild(child *shimast.Node) bool {
   return false
 }
 
-// assignmentTargetNames collects the identifier names written by an
-// assignment's left-hand side. A bare Identifier yields one name. A
+// assignmentTargetIdentifiers collects the Identifier nodes written by an
+// assignment's left-hand side. A bare Identifier yields one node. A
 // destructuring-assignment target — parsed as an ArrayLiteralExpression
 // (`[a, b] = …`) or ObjectLiteralExpression (`({a} = …)`) rather than a
 // binding pattern — is walked so every nested write position is counted:
 // array elements, object property values, shorthand properties, defaults
 // (`[a = 1]`, `{a = 1}`), nested patterns, and rest elements.
 //
-// Property names in `{key: target}` are read positions, not writes, so
-// only the property value contributes; member-access targets (`obj.x`)
-// declare no local binding and are skipped. Returns nil for other shapes.
-func assignmentTargetNames(node *shimast.Node) []string {
+// TypeScript assertion wrappers are transparent in reference position, so
+// `as`, angle-bracket assertions, `satisfies`, non-null assertions, and
+// parentheses are unwrapped recursively wherever they appear in a target.
+// Property names in `{key: target}` are read positions, not writes, so only
+// the property value contributes; member-access targets (`obj.x`) declare no
+// local binding and are skipped. Returns nil for other shapes.
+func assignmentTargetIdentifiers(node *shimast.Node) []*shimast.Node {
   if node == nil {
     return nil
   }
-  if name := identifierText(node); name != "" {
-    return []string{name}
+  if node.Kind == shimast.KindIdentifier {
+    return []*shimast.Node{node}
+  }
+  var identifiers []*shimast.Node
+  collectAssignmentTargetIdentifiers(node, &identifiers)
+  return identifiers
+}
+
+// valueSymbolAtIdentifier returns the checker symbol for an identifier in a
+// value position. A shorthand property assignment needs the checker's
+// dedicated value-symbol query because GetSymbolAtLocation resolves the
+// syntactic property name rather than the binding written by `({name} = value)`.
+func valueSymbolAtIdentifier(ctx *Context, identifier *shimast.Node) *shimast.Symbol {
+  if ctx == nil || ctx.Checker == nil || identifier == nil || identifier.Kind != shimast.KindIdentifier {
+    return nil
+  }
+  if parent := identifier.Parent; parent != nil && parent.Kind == shimast.KindShorthandPropertyAssignment {
+    if shorthand := parent.AsShorthandPropertyAssignment(); shorthand != nil && shorthand.Name() == identifier {
+      return ctx.Checker.GetShorthandAssignmentValueSymbol(parent)
+    }
+  }
+  return ctx.Checker.GetSymbolAtLocation(identifier)
+}
+
+// canonicalValueSymbol resolves an identifier in value position and
+// normalizes exported local/export pairs and declaration merges to one binding
+// identity. TypeScript binds an exported declaration to both a local symbol
+// (used by references in the declaring module) and its ExportSymbol (returned
+// for the declaration name), so both sides must converge before comparison.
+// Rules that protect declarations from writes use this for both the
+// declaration name and every modifying reference, including shorthand
+// destructuring targets.
+func canonicalValueSymbol(ctx *Context, identifier *shimast.Node) *shimast.Symbol {
+  symbol := valueSymbolAtIdentifier(ctx, identifier)
+  if symbol == nil {
+    return nil
+  }
+  if symbol.Flags&shimast.SymbolFlagsExportValue != 0 && symbol.ExportSymbol != nil {
+    symbol = symbol.ExportSymbol
+  }
+  return ctx.Checker.GetMergedSymbol(symbol)
+}
+
+// writeTargetIdentifiers returns every identifier written by one reference-
+// modifying syntax node. It recognizes assignment operators, update
+// expressions, and expression initializers of for-in/of statements; nested
+// destructuring and TypeScript assertion wrappers are delegated to the shared
+// assignment-target walker.
+//
+// Walking all nodes can encounter a destructuring default both through its
+// outer pattern and as a nested binary expression. Callers that report a full
+// tree must therefore deduplicate the returned identifier nodes.
+func writeTargetIdentifiers(node *shimast.Node) []*shimast.Node {
+  if node == nil {
+    return nil
+  }
+  switch node.Kind {
+  case shimast.KindBinaryExpression:
+    expression := node.AsBinaryExpression()
+    if expression != nil && expression.OperatorToken != nil &&
+      isAssignmentOperator(expression.OperatorToken.Kind) {
+      return assignmentTargetIdentifiers(expression.Left)
+    }
+  case shimast.KindPrefixUnaryExpression:
+    expression := node.AsPrefixUnaryExpression()
+    if expression != nil &&
+      (expression.Operator == shimast.KindPlusPlusToken || expression.Operator == shimast.KindMinusMinusToken) {
+      return assignmentTargetIdentifiers(expression.Operand)
+    }
+  case shimast.KindPostfixUnaryExpression:
+    expression := node.AsPostfixUnaryExpression()
+    if expression != nil &&
+      (expression.Operator == shimast.KindPlusPlusToken || expression.Operator == shimast.KindMinusMinusToken) {
+      return assignmentTargetIdentifiers(expression.Operand)
+    }
+  case shimast.KindForInStatement, shimast.KindForOfStatement:
+    statement := node.AsForInOrOfStatement()
+    if statement != nil && statement.Initializer != nil &&
+      statement.Initializer.Kind != shimast.KindVariableDeclarationList {
+      return assignmentTargetIdentifiers(statement.Initializer)
+    }
+  }
+  return nil
+}
+
+// assignmentTargetNames is the text-only projection used by rules that do not
+// need binding identity.
+func assignmentTargetNames(node *shimast.Node) []string {
+  identifiers := assignmentTargetIdentifiers(node)
+  if len(identifiers) == 0 {
+    return nil
+  }
+  names := make([]string, 0, len(identifiers))
+  for _, identifier := range identifiers {
+    if name := identifierText(identifier); name != "" {
+      names = append(names, name)
+    }
   }
-  var names []string
-  collectAssignmentTargetNames(node, &names)
   return names
 }
 
-// collectAssignmentTargetNames appends to `names` every identifier in a
+// isDestructuringAssignmentTarget reports whether node belongs to the left
+// side of a destructuring assignment. TypeScript-Go represents those targets
+// as array/object literal expressions rather than binding-pattern nodes.
+// Property keys, computed names, and default-value expressions are reads and
+// therefore stop the target walk.
+func isDestructuringAssignmentTarget(node *shimast.Node) bool {
+  child := node
+  for child != nil && child.Parent != nil {
+    parent := child.Parent
+    switch parent.Kind {
+    case shimast.KindBindingElement:
+      binding := parent.AsBindingElement()
+      if binding != nil &&
+        (binding.PropertyName == child || binding.Initializer == child) {
+        return false
+      }
+    case shimast.KindPropertyAssignment:
+      property := parent.AsPropertyAssignment()
+      if property != nil && property.Name() == child {
+        return false
+      }
+    case shimast.KindShorthandPropertyAssignment:
+      property := parent.AsShorthandPropertyAssignment()
+      if property != nil && property.ObjectAssignmentInitializer == child {
+        return false
+      }
+    case shimast.KindComputedPropertyName:
+      return false
+    case shimast.KindForInStatement, shimast.KindForOfStatement:
+      statement := parent.AsForInOrOfStatement()
+      return statement != nil && statement.Initializer == child
+    }
+    if parent.Kind == shimast.KindBinaryExpression {
+      expression := parent.AsBinaryExpression()
+      if expression != nil && expression.OperatorToken != nil &&
+        expression.OperatorToken.Kind == shimast.KindEqualsToken {
+        if expression.Left == child {
+          return true
+        }
+        if expression.Right == child {
+          return false
+        }
+      }
+    }
+    child = parent
+  }
+  return false
+}
+
+// collectAssignmentTargetIdentifiers appends to `identifiers` every identifier in a
 // destructuring-assignment target. It descends only through write-target
 // positions so reads (object property keys, computed-member expressions)
 // never count as reassignments.
-func collectAssignmentTargetNames(node *shimast.Node, names *[]string) {
+func collectAssignmentTargetIdentifiers(node *shimast.Node, identifiers *[]*shimast.Node) {
   if node == nil {
     return
   }
   switch node.Kind {
   case shimast.KindIdentifier:
-    if name := identifierText(node); name != "" {
-      *names = append(*names, name)
-    }
+    *identifiers = append(*identifiers, node)
   case shimast.KindParenthesizedExpression:
-    collectAssignmentTargetNames(stripParens(node), names)
+    collectAssignmentTargetIdentifiers(stripParens(node), identifiers)
+  case shimast.KindNonNullExpression:
+    if expression := node.AsNonNullExpression(); expression != nil {
+      collectAssignmentTargetIdentifiers(expression.Expression, identifiers)
+    }
+  case shimast.KindAsExpression:
+    if expression := node.AsAsExpression(); expression != nil {
+      collectAssignmentTargetIdentifiers(expression.Expression, identifiers)
+    }
+  case shimast.KindTypeAssertionExpression:
+    if expression := node.AsTypeAssertion(); expression != nil {
+      collectAssignmentTargetIdentifiers(expression.Expression, identifiers)
+    }
+  case shimast.KindSatisfiesExpression:
+    if expression := node.AsSatisfiesExpression(); expression != nil {
+      collectAssignmentTargetIdentifiers(expression.Expression, identifiers)
+    }
   case shimast.KindArrayLiteralExpression:
     if arr := node.AsArrayLiteralExpression(); arr != nil && arr.Elements != nil {
       for _, el := range arr.Elements.Nodes {
-        collectAssignmentTargetNames(el, names)
+        collectAssignmentTargetIdentifiers(el, identifiers)
       }
     }
   case shimast.KindObjectLiteralExpression:
     if obj := node.AsObjectLiteralExpression(); obj != nil && obj.Properties != nil {
       for _, prop := range obj.Properties.Nodes {
-        collectAssignmentTargetNames(prop, names)
+        collectAssignmentTargetIdentifiers(prop, identifiers)
       }
     }
   case shimast.KindSpreadElement:
     if spread := node.AsSpreadElement(); spread != nil {
-      collectAssignmentTargetNames(spread.Expression, names)
+      collectAssignmentTargetIdentifiers(spread.Expression, identifiers)
     }
   case shimast.KindSpreadAssignment:
     if spread := node.AsSpreadAssignment(); spread != nil {
-      collectAssignmentTargetNames(spread.Expression, names)
+      collectAssignmentTargetIdentifiers(spread.Expression, identifiers)
     }
   case shimast.KindShorthandPropertyAssignment:
     // `{a}` and `{a = 1}` — the property name is the write target; any
     // ObjectAssignmentInitializer is a default value, not a target.
     if short := node.AsShorthandPropertyAssignment(); short != nil {
-      collectAssignmentTargetNames(short.Name(), names)
+      collectAssignmentTargetIdentifiers(short.Name(), identifiers)
     }
   case shimast.KindPropertyAssignment:
     // `{key: target}` — only the value (initializer) is written to.
     if assignment := node.AsPropertyAssignment(); assignment != nil {
-      collectAssignmentTargetNames(assignment.Initializer, names)
+      collectAssignmentTargetIdentifiers(assignment.Initializer, identifiers)
     }
   case shimast.KindBinaryExpression:
     // A default inside a pattern (`[a = 1]`, `{key: a = 1}`) parses as an
     // `=` BinaryExpression; only its left side is the write target.
     if expr := node.AsBinaryExpression(); expr != nil &&
       expr.OperatorToken != nil && expr.OperatorToken.Kind == shimast.KindEqualsToken {
-      collectAssignmentTargetNames(expr.Left, names)
+      collectAssignmentTargetIdentifiers(expr.Left, identifiers)
+    }
+  }
+}
+
+// isDestructuringDefaultAssignment distinguishes the `a = 1` syntax inside
+// `[a = 1]` or `{a = 1}` from a second assignment. A real assignment nested
+// in the default expression's right side leaves the outer target path and is
+// therefore not classified as a default.
+func isDestructuringDefaultAssignment(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  current := node
+  for parent := node.Parent; parent != nil; parent = parent.Parent {
+    switch parent.Kind {
+    case shimast.KindParenthesizedExpression,
+      shimast.KindArrayLiteralExpression,
+      shimast.KindObjectLiteralExpression,
+      shimast.KindPropertyAssignment,
+      shimast.KindSpreadElement,
+      shimast.KindSpreadAssignment:
+      current = parent
+      continue
+    case shimast.KindShorthandPropertyAssignment:
+      return false
+    case shimast.KindBinaryExpression:
+      expression := parent.AsBinaryExpression()
+      return expression != nil && expression.OperatorToken != nil &&
+        isAssignmentOperator(expression.OperatorToken.Kind) &&
+        current.Pos() >= expression.Left.Pos() && current.End() <= expression.Left.End()
+    default:
+      return false
     }
   }
+  return false
 }
 
 // isLiteralLike reports whether `node` (after stripping parentheses) is a