@ttsc/lint 0.18.4 → 0.19.0

package/linthost/rules_no_func_assign.go

@@ -0,0 +1,70 @@
+// noFuncAssign rejects writes to bindings introduced by function declarations
+// and named function expressions. It follows checker symbols instead of names,
+// so hoisted references resolve correctly while parameter, catch, block, and
+// sibling-scope shadows remain independent.
+// https://eslint.org/docs/latest/rules/no-func-assign
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type noFuncAssign struct{}
+
+func (noFuncAssign) Name() string           { return "no-func-assign" }
+func (noFuncAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+func (noFuncAssign) NeedsTypeChecker() bool { return true }
+func (noFuncAssign) Check(ctx *Context, node *shimast.Node) {
+  if ctx == nil || ctx.Checker == nil || node == nil {
+    return
+  }
+
+  functionSymbols := make(map[*shimast.Symbol]struct{})
+  walkDescendants(node, func(child *shimast.Node) {
+    name := noFuncAssignDeclarationName(child)
+    symbol := canonicalValueSymbol(ctx, name)
+    if symbol != nil {
+      functionSymbols[symbol] = struct{}{}
+    }
+  })
+  if len(functionSymbols) == 0 {
+    return
+  }
+
+  reported := make(map[*shimast.Node]struct{})
+  walkDescendants(node, func(child *shimast.Node) {
+    for _, target := range writeTargetIdentifiers(child) {
+      if _, duplicate := reported[target]; duplicate {
+        continue
+      }
+      symbol := canonicalValueSymbol(ctx, target)
+      if _, isFunction := functionSymbols[symbol]; !isFunction {
+        continue
+      }
+      reported[target] = struct{}{}
+      ctx.Report(target, "'"+identifierText(target)+"' is a function.")
+    }
+  })
+}
+
+// noFuncAssignDeclarationName returns the value-binding name introduced by a
+// function declaration or named function expression. Anonymous expressions do
+// not introduce a function-name binding.
+func noFuncAssignDeclarationName(node *shimast.Node) *shimast.Node {
+  if node == nil {
+    return nil
+  }
+  switch node.Kind {
+  case shimast.KindFunctionDeclaration:
+    if declaration := node.AsFunctionDeclaration(); declaration != nil {
+      return declaration.Name()
+    }
+  case shimast.KindFunctionExpression:
+    if expression := node.AsFunctionExpression(); expression != nil {
+      return expression.Name()
+    }
+  }
+  return nil
+}
+
+func init() {
+  Register(noFuncAssign{})
+}

package/linthost/rules_no_import_assign.go

@@ -1,138 +1,330 @@
-// noImportAssign: writes to a binding introduced by an `import`
-// declaration. Imported bindings are read-only at runtime; mutating
-// them either throws under strict mode or silently desynchronises the
-// module's view of its own exports.
+// noImportAssign reports writes to bindings introduced by imports. Binding
+// identity comes from TypeScript's checker, so a same-spelled declaration in a
+// nested scope is independent from the import it shadows.
 //
-// Conservative scope tracking: collect the local names introduced by
-// every `import` declaration in the file (default specifier, named
-// specifier, namespace alias), then walk descendants once and flag
-// `name = …` / `name op= …` / `++name` / `name--` assignments whose
-// left-hand side is one of those names. Namespace imports are also
-// flagged on `ns.foo = …` / `++ns.foo` because the namespace object
-// is itself frozen — mutating any property throws in strict mode.
-//
-// Like `no-param-reassign`, this is an AST-only baseline: a later
-// `const name = …` inside an inner scope that shadows an imported
-// name will produce a false positive. Proper resolution needs the
-// real binder, which the AST-only baseline avoids.
+// Namespace imports additionally protect their direct members. This follows
+// ESLint's contract for assignments, updates, deletes, loop targets, and the
+// standard Object/Reflect mutation functions without treating deeper exported
+// objects as namespace members.
 // https://eslint.org/docs/latest/rules/no-import-assign
 package linthost
 
-import shimast "github.com/microsoft/typescript-go/shim/ast"
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
 
 type noImportAssign struct{}
 
 func (noImportAssign) Name() string           { return "no-import-assign" }
 func (noImportAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+func (noImportAssign) NeedsTypeChecker() bool { return true }
+
 func (noImportAssign) Check(ctx *Context, node *shimast.Node) {
-  if node == nil {
+  if ctx == nil || ctx.Checker == nil || node == nil {
     return
   }
-  imported := map[string]bool{}
-  namespaces := map[string]bool{}
-  collectImportedBindings(node, imported, namespaces)
+  imported, namespaces := collectNoImportAssignBindings(ctx, node)
   if len(imported) == 0 {
     return
   }
-  walkDescendants(node, func(n *shimast.Node) {
-    switch n.Kind {
+
+  walkDescendants(node, func(candidate *shimast.Node) {
+    switch candidate.Kind {
     case shimast.KindBinaryExpression:
-      expr := n.AsBinaryExpression()
-      if expr == nil || expr.OperatorToken == nil || !isAssignmentOperator(expr.OperatorToken.Kind) {
+      expression := candidate.AsBinaryExpression()
+      if expression == nil || expression.OperatorToken == nil ||
+        !isAssignmentOperator(expression.OperatorToken.Kind) ||
+        isDestructuringAssignmentTarget(candidate) {
         return
       }
-      reportImportTarget(ctx, expr.Left, imported, namespaces)
+      reportNoImportAssignTarget(ctx, candidate, expression.Left, imported, namespaces, true)
+
     case shimast.KindPrefixUnaryExpression:
-      pre := n.AsPrefixUnaryExpression()
-      if pre == nil || (pre.Operator != shimast.KindPlusPlusToken && pre.Operator != shimast.KindMinusMinusToken) {
+      expression := candidate.AsPrefixUnaryExpression()
+      if expression == nil ||
+        (expression.Operator != shimast.KindPlusPlusToken && expression.Operator != shimast.KindMinusMinusToken) {
         return
       }
-      reportImportTarget(ctx, pre.Operand, imported, namespaces)
+      reportNoImportAssignTarget(ctx, candidate, expression.Operand, imported, namespaces, true)
+
     case shimast.KindPostfixUnaryExpression:
-      post := n.AsPostfixUnaryExpression()
-      if post == nil || (post.Operator != shimast.KindPlusPlusToken && post.Operator != shimast.KindMinusMinusToken) {
+      expression := candidate.AsPostfixUnaryExpression()
+      if expression == nil ||
+        (expression.Operator != shimast.KindPlusPlusToken && expression.Operator != shimast.KindMinusMinusToken) {
+        return
+      }
+      reportNoImportAssignTarget(ctx, candidate, expression.Operand, imported, namespaces, true)
+
+    case shimast.KindDeleteExpression:
+      expression := candidate.AsDeleteExpression()
+      if expression != nil {
+        // ESLint treats delete as a namespace-member mutation. Bare delete is
+        // covered by no-delete-var rather than as an import assignment.
+        reportNoImportAssignTarget(ctx, candidate, expression.Expression, imported, namespaces, false)
+      }
+
+    case shimast.KindForInStatement, shimast.KindForOfStatement:
+      statement := candidate.AsForInOrOfStatement()
+      if statement == nil || statement.Initializer == nil ||
+        statement.Initializer.Kind == shimast.KindVariableDeclarationList {
         return
       }
-      reportImportTarget(ctx, post.Operand, imported, namespaces)
+      reportNoImportAssignTarget(ctx, candidate, statement.Initializer, imported, namespaces, true)
+
+    case shimast.KindCallExpression:
+      reportNoImportAssignMutationCall(ctx, candidate, namespaces)
     }
   })
 }
 
-// collectImportedBindings walks every `import` declaration in `file` and
-// records the local names introduced. Namespace bindings (`* as ns`) are
-// additionally remembered so callers can flag property mutations like
-// `ns.foo = …`.
-func collectImportedBindings(file *shimast.Node, imported, namespaces map[string]bool) {
-  walkDescendants(file, func(n *shimast.Node) {
-    if n == nil || n.Kind != shimast.KindImportDeclaration {
-      return
-    }
-    decl := n.AsImportDeclaration()
-    if decl == nil || decl.ImportClause == nil {
-      return
-    }
-    clause := decl.ImportClause.AsImportClause()
-    if clause == nil {
+// collectNoImportAssignBindings records the checker symbol owned by every
+// default, named, namespace, type-only, and import-equals local name. References
+// are compared against these symbols rather than their text.
+func collectNoImportAssignBindings(
+  ctx *Context,
+  file *shimast.Node,
+) (map[*shimast.Symbol]string, map[*shimast.Symbol]string) {
+  imported := map[*shimast.Symbol]string{}
+  namespaces := map[*shimast.Symbol]string{}
+  add := func(name *shimast.Node, namespace bool) {
+    symbol := noImportAssignValueSymbol(ctx, name)
+    localName := identifierText(name)
+    if symbol == nil || localName == "" {
       return
     }
-    // `import Default from "x"` — default specifier.
-    if name := identifierText(clause.Name()); name != "" {
-      imported[name] = true
+    imported[symbol] = localName
+    if namespace {
+      namespaces[symbol] = localName
     }
-    if clause.NamedBindings == nil {
-      return
-    }
-    switch clause.NamedBindings.Kind {
-    case shimast.KindNamedImports:
-      named := clause.NamedBindings.AsNamedImports()
-      if named == nil || named.Elements == nil {
+  }
+
+  walkDescendants(file, func(node *shimast.Node) {
+    switch node.Kind {
+    case shimast.KindImportDeclaration:
+      declaration := node.AsImportDeclaration()
+      if declaration == nil || declaration.ImportClause == nil {
         return
       }
-      for _, specNode := range named.Elements.Nodes {
-        spec := specNode.AsImportSpecifier()
-        if spec == nil {
-          continue
-        }
-        if name := identifierText(spec.Name()); name != "" {
-          imported[name] = true
-        }
+      clause := declaration.ImportClause.AsImportClause()
+      if clause == nil {
+        return
       }
-    case shimast.KindNamespaceImport:
-      ns := clause.NamedBindings.AsNamespaceImport()
-      if ns == nil {
+      add(clause.Name(), false)
+      if clause.NamedBindings == nil {
         return
       }
-      if name := identifierText(ns.Name()); name != "" {
-        imported[name] = true
-        namespaces[name] = true
+      switch clause.NamedBindings.Kind {
+      case shimast.KindNamedImports:
+        named := clause.NamedBindings.AsNamedImports()
+        if named == nil || named.Elements == nil {
+          return
+        }
+        for _, element := range named.Elements.Nodes {
+          if specifier := element.AsImportSpecifier(); specifier != nil {
+            add(specifier.Name(), false)
+          }
+        }
+      case shimast.KindNamespaceImport:
+        if namespace := clause.NamedBindings.AsNamespaceImport(); namespace != nil {
+          add(namespace.Name(), true)
+        }
+      }
+
+    case shimast.KindImportEqualsDeclaration:
+      if declaration := node.AsImportEqualsDeclaration(); declaration != nil {
+        add(declaration.Name(), false)
       }
     }
   })
+  return imported, namespaces
 }
 
-// reportImportTarget flags `target` when it writes to an imported name.
-// A bare identifier matching an imported binding is always flagged; a
-// `ns.<key>` property access is flagged when `ns` is a namespace import.
-func reportImportTarget(ctx *Context, target *shimast.Node, imported, namespaces map[string]bool) {
-  stripped := stripParens(target)
-  if stripped == nil {
+// reportNoImportAssignTarget walks only the write positions of one assignment
+// target. Object keys, computed keys, and default initializers are reads; member
+// accesses are leaves so `ns.export.value = ...` remains allowed while a direct
+// `ns.export = ...` write is reported.
+func reportNoImportAssignTarget(
+  ctx *Context,
+  reportNode *shimast.Node,
+  target *shimast.Node,
+  imported map[*shimast.Symbol]string,
+  namespaces map[*shimast.Symbol]string,
+  allowBinding bool,
+) {
+  target = unwrapReferenceExpression(target)
+  if target == nil {
     return
   }
-  if name := identifierText(stripped); name != "" {
-    if imported[name] {
-      ctx.Report(target, "'"+name+"' is read-only.")
+  switch target.Kind {
+  case shimast.KindIdentifier:
+    if !allowBinding {
+      return
+    }
+    if symbol := noImportAssignValueSymbol(ctx, target); symbol != nil {
+      if name, ok := imported[symbol]; ok {
+        ctx.Report(reportNode, "'"+name+"' is read-only.")
+      }
+    }
+
+  case shimast.KindPropertyAccessExpression, shimast.KindElementAccessExpression:
+    if name := noImportAssignDirectNamespaceName(ctx, target, namespaces); name != "" {
+      ctx.Report(reportNode, "The members of '"+name+"' are read-only.")
+    }
+
+  case shimast.KindArrayLiteralExpression:
+    if array := target.AsArrayLiteralExpression(); array != nil && array.Elements != nil {
+      for _, element := range array.Elements.Nodes {
+        reportNoImportAssignTarget(ctx, reportNode, element, imported, namespaces, allowBinding)
+      }
+    }
+
+  case shimast.KindObjectLiteralExpression:
+    if object := target.AsObjectLiteralExpression(); object != nil && object.Properties != nil {
+      for _, property := range object.Properties.Nodes {
+        reportNoImportAssignTarget(ctx, reportNode, property, imported, namespaces, allowBinding)
+      }
     }
+
+  case shimast.KindSpreadElement:
+    if spread := target.AsSpreadElement(); spread != nil {
+      reportNoImportAssignTarget(ctx, reportNode, spread.Expression, imported, namespaces, allowBinding)
+    }
+
+  case shimast.KindSpreadAssignment:
+    if spread := target.AsSpreadAssignment(); spread != nil {
+      reportNoImportAssignTarget(ctx, reportNode, spread.Expression, imported, namespaces, allowBinding)
+    }
+
+  case shimast.KindShorthandPropertyAssignment:
+    if property := target.AsShorthandPropertyAssignment(); property != nil {
+      reportNoImportAssignTarget(ctx, reportNode, property.Name(), imported, namespaces, allowBinding)
+    }
+
+  case shimast.KindPropertyAssignment:
+    if property := target.AsPropertyAssignment(); property != nil {
+      reportNoImportAssignTarget(ctx, reportNode, property.Initializer, imported, namespaces, allowBinding)
+    }
+
+  case shimast.KindBinaryExpression:
+    expression := target.AsBinaryExpression()
+    if expression != nil && expression.OperatorToken != nil &&
+      expression.OperatorToken.Kind == shimast.KindEqualsToken {
+      reportNoImportAssignTarget(ctx, reportNode, expression.Left, imported, namespaces, allowBinding)
+    }
+  }
+}
+
+func reportNoImportAssignMutationCall(
+  ctx *Context,
+  node *shimast.Node,
+  namespaces map[*shimast.Symbol]string,
+) {
+  call := node.AsCallExpression()
+  if call == nil || call.Arguments == nil || len(call.Arguments.Nodes) == 0 ||
+    !isNoImportAssignMutationFunction(ctx, call.Expression) {
     return
   }
-  if stripped.Kind == shimast.KindPropertyAccessExpression {
-    access := stripped.AsPropertyAccessExpression()
-    if access == nil || access.Expression == nil {
-      return
+  target := unwrapReferenceExpression(call.Arguments.Nodes[0])
+  if target == nil || target.Kind != shimast.KindIdentifier {
+    return
+  }
+  if symbol := noImportAssignValueSymbol(ctx, target); symbol != nil {
+    if name, ok := namespaces[symbol]; ok {
+      ctx.Report(node, "The members of '"+name+"' are read-only.")
+    }
+  }
+}
+
+func isNoImportAssignMutationFunction(ctx *Context, callee *shimast.Node) bool {
+  callee = unwrapReferenceExpression(callee)
+  if callee == nil {
+    return false
+  }
+  member, ok := referenceMemberParts(callee)
+  if !ok || member.staticKey == nil {
+    return false
+  }
+  object := unwrapReferenceExpression(member.object)
+  if object == nil || object.Kind != shimast.KindIdentifier {
+    return false
+  }
+  objectName := identifierText(object)
+  allowed := false
+  switch objectName {
+  case "Object":
+    switch *member.staticKey {
+    case "assign", "defineProperty", "defineProperties", "freeze", "setPrototypeOf":
+      allowed = true
     }
-    if ns := identifierText(stripParens(access.Expression)); ns != "" && namespaces[ns] {
-      ctx.Report(target, "The members of '"+ns+"' are read-only.")
+  case "Reflect":
+    switch *member.staticKey {
+    case "defineProperty", "deleteProperty", "set", "setPrototypeOf":
+      allowed = true
     }
   }
+  if !allowed {
+    return false
+  }
+
+  resolved := noImportAssignValueSymbol(ctx, object)
+  global := ctx.Checker.GetGlobalSymbol(objectName, shimast.SymbolFlagsValue, nil)
+  if global != nil {
+    global = ctx.Checker.GetMergedSymbol(global)
+  }
+  return resolved != nil && resolved == global
+}
+
+func noImportAssignDirectNamespaceName(
+  ctx *Context,
+  memberNode *shimast.Node,
+  namespaces map[*shimast.Symbol]string,
+) string {
+  member, ok := referenceMemberParts(memberNode)
+  if !ok {
+    return ""
+  }
+  receiver := unwrapReferenceExpression(member.object)
+  if receiver == nil || receiver.Kind != shimast.KindIdentifier {
+    return ""
+  }
+  return namespaces[noImportAssignValueSymbol(ctx, receiver)]
+}
+
+// noImportAssignValueSymbol resolves shorthand destructuring targets through
+// their value slot, then normalizes merged declarations to a stable map key.
+// A type-only import used illegally as a value has no value-position symbol;
+// in that case the checker's all-meanings entity lookup still returns the
+// lexical import alias without falling back to textual name matching.
+func noImportAssignValueSymbol(ctx *Context, identifier *shimast.Node) *shimast.Symbol {
+  if ctx == nil || ctx.Checker == nil || identifier == nil {
+    return nil
+  }
+  var symbol *shimast.Symbol
+  shorthandTarget := false
+  if parent := identifier.Parent; parent != nil && parent.Kind == shimast.KindShorthandPropertyAssignment {
+    if shorthand := parent.AsShorthandPropertyAssignment(); shorthand != nil && shorthand.Name() == identifier {
+      shorthandTarget = true
+      symbol = ctx.Checker.GetShorthandAssignmentValueSymbol(parent)
+    }
+  }
+  if symbol == nil && !shorthandTarget {
+    symbol = ctx.Checker.GetSymbolAtLocation(identifier)
+  }
+  if symbol == nil {
+    symbol = shimchecker.Checker_resolveEntityName(
+      ctx.Checker,
+      identifier,
+      shimast.SymbolFlagsValue|shimast.SymbolFlagsType|shimast.SymbolFlagsNamespace,
+      true,
+      true,
+      nil,
+    )
+  }
+  if symbol == nil {
+    return nil
+  }
+  return ctx.Checker.GetMergedSymbol(symbol)
 }
 
 func init() {

package/linthost/rules_no_inner_declarations.go

@@ -0,0 +1,186 @@
+package linthost
+
+import (
+  "bytes"
+  "encoding/json"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimcore "github.com/microsoft/typescript-go/shim/core"
+)
+
+// noInnerDeclarations enforces the root-declaration positions and option
+// defaults of ESLint's core no-inner-declarations rule. TypeScript-Go parses
+// JavaScript and TypeScript with the current ECMAScript grammar, so strict
+// functions in ordinary parsed source have ES2015 block-function semantics.
+// https://eslint.org/docs/latest/rules/no-inner-declarations
+type noInnerDeclarations struct{ optionsRule }
+
+type noInnerDeclarationsOptions struct {
+  both                 bool
+  allowBlockScopedFunc bool
+}
+
+type noInnerDeclarationsBlockOptions struct {
+  BlockScopedFunctions string `json:"blockScopedFunctions"`
+}
+
+func (noInnerDeclarations) Name() string { return "no-inner-declarations" }
+
+func (noInnerDeclarations) Visits() []shimast.Kind {
+  return []shimast.Kind{
+    shimast.KindFunctionDeclaration,
+    shimast.KindVariableDeclarationList,
+  }
+}
+
+func (noInnerDeclarations) Check(ctx *Context, node *shimast.Node) {
+  options := resolveNoInnerDeclarationsOptions(ctx)
+  declaration := node
+  declarationType := "function"
+
+  if node.Kind == shimast.KindVariableDeclarationList {
+    if !options.both || !shimast.IsVar(node) {
+      return
+    }
+    declarationType = "variable"
+    // A statement-level list is wrapped by VariableStatement in the tsgo AST.
+    // Use that wrapper for root classification and for the diagnostic range;
+    // loop-header lists have no wrapper and remain nested declarations.
+    if node.Parent != nil && node.Parent.Kind == shimast.KindVariableStatement {
+      declaration = node.Parent
+    }
+  } else if options.allowBlockScopedFunc &&
+    noInnerDeclarationsSupportsBlockFunctions(ctx.File) &&
+    noInnerDeclarationsIsStrict(ctx.File, node) {
+    return
+  }
+
+  if noInnerDeclarationsIsRoot(declaration) {
+    return
+  }
+  ctx.Report(
+    declaration,
+    "Move "+declarationType+" declaration to "+noInnerDeclarationsAllowedBody(declaration)+" root.",
+  )
+}
+
+// resolveNoInnerDeclarationsOptions reads the canonical ESLint positional
+// options. The config transport preserves one positional value directly and
+// two or more values as an array, so both [severity, mode] and
+// [severity, mode, object] arrive without rule-specific parser behavior.
+func resolveNoInnerDeclarationsOptions(ctx *Context) noInnerDeclarationsOptions {
+  resolved := noInnerDeclarationsOptions{allowBlockScopedFunc: true}
+  if ctx == nil || len(ctx.Options) == 0 {
+    return resolved
+  }
+
+  raw := bytes.TrimSpace(ctx.Options)
+  if len(raw) == 0 {
+    return resolved
+  }
+  var slots []json.RawMessage
+  if raw[0] == '[' {
+    // Decode into a zero-value slice. Seeding it with raw would let the first
+    // RawMessage reuse and overwrite Context.Options' backing bytes, changing
+    // the option seen by every later declaration in the same file.
+    if err := json.Unmarshal(raw, &slots); err != nil {
+      return resolved
+    }
+  } else {
+    slots = []json.RawMessage{raw}
+  }
+
+  if len(slots) > 0 {
+    var mode string
+    if json.Unmarshal(slots[0], &mode) == nil && mode == "both" {
+      resolved.both = true
+    }
+  }
+  if len(slots) > 1 {
+    var options noInnerDeclarationsBlockOptions
+    if json.Unmarshal(slots[1], &options) == nil && options.BlockScopedFunctions == "disallow" {
+      resolved.allowBlockScopedFunc = false
+    }
+  }
+  return resolved
+}
+
+func noInnerDeclarationsSupportsBlockFunctions(file *shimast.SourceFile) bool {
+  return file != nil && file.ScriptKind != shimcore.ScriptKindJSON
+}
+
+// noInnerDeclarationsIsStrict derives strictness from parser-owned AST facts:
+// external-module identity, class ancestry, and real directive prologues. It
+// deliberately does not infer semantics from filenames or substring searches.
+func noInnerDeclarationsIsStrict(file *shimast.SourceFile, node *shimast.Node) bool {
+  if file != nil && file.ExternalModuleIndicator != nil {
+    return true
+  }
+  for ancestor := node.Parent; ancestor != nil; ancestor = ancestor.Parent {
+    switch ancestor.Kind {
+    case shimast.KindClassDeclaration, shimast.KindClassExpression:
+      return true
+    case shimast.KindSourceFile, shimast.KindModuleBlock:
+      if noInnerDeclarationsHasUseStrictDirective(file, ancestor) {
+        return true
+      }
+    case shimast.KindBlock:
+      if isFunctionLikeKind(ancestor.Parent) && noInnerDeclarationsHasUseStrictDirective(file, ancestor) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+func noInnerDeclarationsHasUseStrictDirective(file *shimast.SourceFile, container *shimast.Node) bool {
+  for _, statement := range parentStatements(container) {
+    if statement == nil || statement.Kind != shimast.KindExpressionStatement {
+      return false
+    }
+    expressionStatement := statement.AsExpressionStatement()
+    if expressionStatement == nil || expressionStatement.Expression == nil ||
+      expressionStatement.Expression.Kind != shimast.KindStringLiteral {
+      return false
+    }
+    // ES5 forbids escapes in a Use Strict Directive. Match the parser/binder
+    // contract against the parser-classified literal token, not its cooked
+    // value (`"use\x20strict"` must stay sloppy).
+    raw := nodeText(file, expressionStatement.Expression)
+    if raw == `"use strict"` || raw == `'use strict'` {
+      return true
+    }
+  }
+  return false
+}
+
+func noInnerDeclarationsIsRoot(declaration *shimast.Node) bool {
+  if declaration == nil || declaration.Parent == nil {
+    return true
+  }
+  parent := declaration.Parent
+  switch parent.Kind {
+  case shimast.KindSourceFile, shimast.KindModuleBlock, shimast.KindClassStaticBlockDeclaration:
+    return true
+  case shimast.KindBlock:
+    return isFunctionLikeKind(parent.Parent) ||
+      (parent.Parent != nil && parent.Parent.Kind == shimast.KindClassStaticBlockDeclaration)
+  }
+  return false
+}
+
+func noInnerDeclarationsAllowedBody(declaration *shimast.Node) string {
+  for ancestor := declaration.Parent; ancestor != nil; ancestor = ancestor.Parent {
+    if ancestor.Kind == shimast.KindClassStaticBlockDeclaration {
+      return "class static block body"
+    }
+    if isFunctionLikeKind(ancestor) {
+      return "function body"
+    }
+  }
+  return "program"
+}
+
+func init() {
+  Register(noInnerDeclarations{})
+}