@ttsc/lint 0.18.3 → 0.19.0

package/linthost/rules_no_param_reassign.go

@@ -1,96 +1,411 @@
-// noParamReassign: reassigning a function parameter inside the body of
-// the function it belongs to. Mutating the binding makes the declared
-// name stop pointing at the caller's argument and is the usual ESLint
-// baseline of `no-param-reassign` — without the `props: true` extension
-// that would also flag `param.foo = …`.
+// noParamReassign rejects writes to the binding introduced by a function
+// parameter. Binding identity comes from the TypeScript checker, so a local
+// shadow is independent while a nested function that closes over the parameter
+// still counts. Destructured, defaulted, and rest parameters are resolved by
+// their individual binding leaves.
 //
-// Conservative scope tracking: collect simple-identifier parameter
-// names, walk the body until a nested function-like introduces a fresh
-// scope, and flag `name = …` / `name op= …` / `++name` / `name--` at
-// any depth in between. A local `const name = 1` that shadows a
-// parameter name will produce a false positive in v1 — proper scope
-// tracking needs the resolver, which the AST-only baseline avoids.
-// Destructured parameter bindings are skipped for the same reason.
+// With `props: true`, the rule also follows the parameter reference through
+// member, call, conditional-result, and destructuring-target syntax to find
+// property writes. The two official ignore lists apply only to those property
+// writes; assigning the parameter binding itself is always reported.
 // https://eslint.org/docs/latest/rules/no-param-reassign
 package linthost
 
-import shimast "github.com/microsoft/typescript-go/shim/ast"
+import (
+  "encoding/json"
+  "fmt"
+  "regexp"
+  "sort"
 
-type noParamReassign struct{}
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type noParamReassign struct{ optionsRule }
+
+type noParamReassignOptions struct {
+  Props                               bool     `json:"props"`
+  IgnorePropertyModificationsFor      []string `json:"ignorePropertyModificationsFor"`
+  IgnorePropertyModificationsForRegex []string `json:"ignorePropertyModificationsForRegex"`
+}
+
+type noParamReassignParameter struct {
+  name string
+}
 
 func (noParamReassign) Name() string { return "no-param-reassign" }
-func (noParamReassign) Visits() []shimast.Kind {
-  return []shimast.Kind{
-    shimast.KindFunctionDeclaration,
-    shimast.KindFunctionExpression,
-    shimast.KindArrowFunction,
-    shimast.KindMethodDeclaration,
-    shimast.KindConstructor,
-    shimast.KindGetAccessor,
-    shimast.KindSetAccessor,
+func (noParamReassign) NeedsTypeChecker() bool {
+  return true
+}
+func (noParamReassign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+
+func (noParamReassign) ValidateOptions(raw json.RawMessage) error {
+  if len(raw) == 0 {
+    return nil
+  }
+
+  var decoded any
+  if err := json.Unmarshal(raw, &decoded); err != nil {
+    return fmt.Errorf("options must be valid JSON: %w", err)
+  }
+  options, ok := decoded.(map[string]any)
+  if !ok {
+    return fmt.Errorf("options must be an object")
+  }
+
+  unknown := make([]string, 0)
+  for name := range options {
+    switch name {
+    case "props", "ignorePropertyModificationsFor", "ignorePropertyModificationsForRegex":
+    default:
+      unknown = append(unknown, name)
+    }
   }
+  if len(unknown) > 0 {
+    sort.Strings(unknown)
+    return fmt.Errorf("unknown option %q", unknown[0])
+  }
+
+  props := false
+  propsPresent := false
+  if value, present := options["props"]; present {
+    propsPresent = true
+    configured, valid := value.(bool)
+    if !valid {
+      return fmt.Errorf("option %q must be a boolean", "props")
+    }
+    props = configured
+  }
+
+  _, exactPresent, err := noParamReassignStringListOption(
+    options,
+    "ignorePropertyModificationsFor",
+  )
+  if err != nil {
+    return err
+  }
+  patterns, regexPresent, err := noParamReassignStringListOption(
+    options,
+    "ignorePropertyModificationsForRegex",
+  )
+  if err != nil {
+    return err
+  }
+  for index, pattern := range patterns {
+    if _, err := regexp.Compile(pattern); err != nil {
+      return fmt.Errorf(
+        "option %q[%d] must be a valid regular expression: %w",
+        "ignorePropertyModificationsForRegex",
+        index,
+        err,
+      )
+    }
+  }
+  if propsPresent && !props && (exactPresent || regexPresent) {
+    return fmt.Errorf("ignore options cannot be combined with %q set to false", "props")
+  }
+  return nil
 }
+
+func noParamReassignStringListOption(
+  options map[string]any,
+  name string,
+) ([]string, bool, error) {
+  value, present := options[name]
+  if !present {
+    return nil, false, nil
+  }
+  values, valid := value.([]any)
+  if !valid {
+    return nil, true, fmt.Errorf("option %q must be an array of strings", name)
+  }
+  decoded := make([]string, 0, len(values))
+  seen := make(map[string]struct{}, len(values))
+  for index, item := range values {
+    text, valid := item.(string)
+    if !valid {
+      return nil, true, fmt.Errorf("option %q[%d] must be a string", name, index)
+    }
+    if _, duplicate := seen[text]; duplicate {
+      return nil, true, fmt.Errorf("option %q contains duplicate value %q", name, text)
+    }
+    seen[text] = struct{}{}
+    decoded = append(decoded, text)
+  }
+  return decoded, true, nil
+}
+
 func (noParamReassign) Check(ctx *Context, node *shimast.Node) {
-  body := node.Body()
-  if body == nil {
+  if ctx == nil || ctx.Checker == nil || node == nil {
     return
   }
-  names := map[string]bool{}
-  for _, p := range node.Parameters() {
-    if decl := p.AsParameterDeclaration(); decl != nil {
-      if name := identifierText(decl.Name()); name != "" {
-        names[name] = true
+
+  var options noParamReassignOptions
+  if err := ctx.DecodeOptions(&options); err != nil {
+    return
+  }
+
+  parameters := make(map[*shimast.Symbol]noParamReassignParameter)
+  parameterNames := make(map[string]struct{})
+  walkDescendants(node, func(child *shimast.Node) {
+    if !isFunctionLikeKind(child) {
+      return
+    }
+    for _, parameterNode := range child.Parameters() {
+      parameter := parameterNode.AsParameterDeclaration()
+      if parameter == nil {
+        continue
+      }
+      for _, nameNode := range bindingIdentifierNodes(parameter.Name()) {
+        name := identifierText(nameNode)
+        symbol := noParamReassignParameterSymbol(ctx, parameterNode, nameNode, name)
+        if symbol == nil || name == "" {
+          continue
+        }
+        parameters[symbol] = noParamReassignParameter{name: name}
+        parameterNames[name] = struct{}{}
       }
     }
-  }
-  if len(names) == 0 {
+  })
+  if len(parameters) == 0 {
     return
   }
-  walkParamReassignBody(body, names, func(target *shimast.Node) {
-    ctx.Report(target, "Assignment to function parameter.")
+
+  directTargets := make(map[*shimast.Node]struct{})
+  reportDirectTarget := func(target *shimast.Node) {
+    if target == nil || target.Kind != shimast.KindIdentifier {
+      return
+    }
+    if _, reported := directTargets[target]; reported {
+      return
+    }
+    parameter, ok := parameters[valueSymbolAtIdentifier(ctx, target)]
+    if !ok {
+      return
+    }
+    directTargets[target] = struct{}{}
+    ctx.Report(target, "Assignment to function parameter '"+parameter.name+"'.")
+  }
+
+  walkDescendants(node, func(child *shimast.Node) {
+    switch child.Kind {
+    case shimast.KindBinaryExpression:
+      expression := child.AsBinaryExpression()
+      if expression == nil || expression.OperatorToken == nil ||
+        !isAssignmentOperator(expression.OperatorToken.Kind) ||
+        isDestructuringDefaultAssignment(child) {
+        return
+      }
+      for _, target := range assignmentTargetIdentifiers(expression.Left) {
+        reportDirectTarget(target)
+      }
+    case shimast.KindPrefixUnaryExpression:
+      expression := child.AsPrefixUnaryExpression()
+      if expression == nil ||
+        (expression.Operator != shimast.KindPlusPlusToken && expression.Operator != shimast.KindMinusMinusToken) {
+        return
+      }
+      for _, target := range assignmentTargetIdentifiers(expression.Operand) {
+        reportDirectTarget(target)
+      }
+    case shimast.KindPostfixUnaryExpression:
+      expression := child.AsPostfixUnaryExpression()
+      if expression == nil ||
+        (expression.Operator != shimast.KindPlusPlusToken && expression.Operator != shimast.KindMinusMinusToken) {
+        return
+      }
+      for _, target := range assignmentTargetIdentifiers(expression.Operand) {
+        reportDirectTarget(target)
+      }
+    case shimast.KindForInStatement, shimast.KindForOfStatement:
+      statement := child.AsForInOrOfStatement()
+      if statement == nil || statement.Initializer == nil ||
+        statement.Initializer.Kind == shimast.KindVariableDeclarationList {
+        return
+      }
+      for _, target := range assignmentTargetIdentifiers(statement.Initializer) {
+        reportDirectTarget(target)
+      }
+    }
   })
-}
 
-// walkParamReassignBody visits every assignment-like write in `root`
-// without crossing nested function-like scopes. The target identifier
-// must be a bare name in `names` for `report` to fire.
-func walkParamReassignBody(root *shimast.Node, names map[string]bool, report func(*shimast.Node)) {
-  if root == nil {
+  if !options.Props {
     return
   }
-  var walk func(*shimast.Node)
-  hits := func(operand *shimast.Node) bool {
-    name := identifierText(stripParens(operand))
-    return name != "" && names[name]
+  ignoredNames := make(map[string]struct{}, len(options.IgnorePropertyModificationsFor))
+  for _, name := range options.IgnorePropertyModificationsFor {
+    ignoredNames[name] = struct{}{}
   }
-  walk = func(node *shimast.Node) {
-    if node == nil || (node != root && isFunctionLikeKind(node)) {
+  ignoredPatterns := make([]*regexp.Regexp, 0, len(options.IgnorePropertyModificationsForRegex))
+  for _, pattern := range options.IgnorePropertyModificationsForRegex {
+    compiled, err := compileUserPattern(pattern)
+    if err != nil {
       return
     }
-    switch node.Kind {
+    ignoredPatterns = append(ignoredPatterns, compiled)
+  }
+
+  walkDescendants(node, func(child *shimast.Node) {
+    if child.Kind != shimast.KindIdentifier {
+      return
+    }
+    if _, direct := directTargets[child]; direct {
+      return
+    }
+    if _, possibleParameter := parameterNames[identifierText(child)]; !possibleParameter {
+      return
+    }
+    parameter, ok := parameters[valueSymbolAtIdentifier(ctx, child)]
+    if !ok || noParamReassignIgnoresProperty(parameter.name, ignoredNames, ignoredPatterns) {
+      return
+    }
+    if noParamReassignModifiesProperty(child) {
+      ctx.Report(child, "Assignment to property of function parameter '"+parameter.name+"'.")
+    }
+  })
+}
+
+// A TypeScript parameter property has two symbols at one declaration: the
+// constructor-local parameter and the class member. GetSymbolAtLocation is
+// deliberately fuzzy for declaration names and may select the member, while
+// references in the constructor body resolve to the parameter. The constructor
+// locals are the canonical binding table for body references; looking up that
+// table also avoids the checker's pair API, which panics on malformed parameter
+// properties instead of returning a partial result.
+func noParamReassignParameterSymbol(
+  ctx *Context,
+  parameterNode *shimast.Node,
+  nameNode *shimast.Node,
+  name string,
+) *shimast.Symbol {
+  if ctx == nil || ctx.Checker == nil || parameterNode == nil || nameNode == nil || name == "" {
+    return nil
+  }
+  if parameterNode.Parent != nil && parameterNode.Parent.Kind == shimast.KindConstructor &&
+    isParameterProperty(parameterNode) {
+    return parameterNode.Parent.Locals()[name]
+  }
+  return ctx.Checker.GetSymbolAtLocation(nameNode)
+}
+
+func noParamReassignIgnoresProperty(
+  name string,
+  names map[string]struct{},
+  patterns []*regexp.Regexp,
+) bool {
+  if _, ignored := names[name]; ignored {
+    return true
+  }
+  for _, pattern := range patterns {
+    if pattern.MatchString(name) {
+      return true
+    }
+  }
+  return false
+}
+
+// noParamReassignModifiesProperty mirrors ESLint's reference-parent walk. A
+// parameter reference contributes to the value being mutated only through the
+// receiver/callee side of member and call expressions. Computed keys, call
+// arguments, property names, and conditional tests are read-only branches.
+func noParamReassignModifiesProperty(identifier *shimast.Node) bool {
+  current := identifier
+  for current != nil && current.Parent != nil {
+    parent := current.Parent
+    switch parent.Kind {
     case shimast.KindBinaryExpression:
-      expr := node.AsBinaryExpression()
-      if expr != nil && expr.OperatorToken != nil &&
-        isAssignmentOperator(expr.OperatorToken.Kind) && hits(expr.Left) {
-        report(node)
+      expression := parent.AsBinaryExpression()
+      if expression != nil && expression.OperatorToken != nil && isAssignmentOperator(expression.OperatorToken.Kind) {
+        return expression.Left == current
       }
     case shimast.KindPrefixUnaryExpression:
-      pre := node.AsPrefixUnaryExpression()
-      if pre != nil && (pre.Operator == shimast.KindPlusPlusToken || pre.Operator == shimast.KindMinusMinusToken) && hits(pre.Operand) {
-        report(node)
+      expression := parent.AsPrefixUnaryExpression()
+      if expression != nil &&
+        (expression.Operator == shimast.KindPlusPlusToken || expression.Operator == shimast.KindMinusMinusToken) {
+        return expression.Operand == current
       }
     case shimast.KindPostfixUnaryExpression:
-      post := node.AsPostfixUnaryExpression()
-      if post != nil && (post.Operator == shimast.KindPlusPlusToken || post.Operator == shimast.KindMinusMinusToken) && hits(post.Operand) {
-        report(node)
+      expression := parent.AsPostfixUnaryExpression()
+      if expression != nil &&
+        (expression.Operator == shimast.KindPlusPlusToken || expression.Operator == shimast.KindMinusMinusToken) {
+        return expression.Operand == current
+      }
+    case shimast.KindDeleteExpression:
+      expression := parent.AsDeleteExpression()
+      return expression != nil && expression.Expression == current
+    case shimast.KindForInStatement, shimast.KindForOfStatement:
+      statement := parent.AsForInOrOfStatement()
+      return statement != nil && statement.Initializer == current
+    case shimast.KindCallExpression:
+      expression := parent.AsCallExpression()
+      if expression == nil || expression.Expression != current {
+        return false
+      }
+    case shimast.KindNewExpression:
+      expression := parent.AsNewExpression()
+      if expression == nil || expression.Expression != current {
+        return false
+      }
+    case shimast.KindPropertyAccessExpression:
+      expression := parent.AsPropertyAccessExpression()
+      if expression == nil || expression.Expression != current {
+        return false
+      }
+    case shimast.KindElementAccessExpression:
+      expression := parent.AsElementAccessExpression()
+      if expression == nil || expression.Expression != current {
+        return false
       }
+    case shimast.KindConditionalExpression:
+      expression := parent.AsConditionalExpression()
+      if expression == nil || expression.Condition == current {
+        return false
+      }
+    case shimast.KindPropertyAssignment:
+      property := parent.AsPropertyAssignment()
+      if property == nil || property.Name() == current {
+        return false
+      }
+    case shimast.KindShorthandPropertyAssignment:
+      property := parent.AsShorthandPropertyAssignment()
+      if property == nil || property.Name() == current {
+        return false
+      }
+    case shimast.KindBindingElement:
+      element := parent.AsBindingElement()
+      if element == nil || element.PropertyName == current || element.Initializer == current {
+        return false
+      }
+    case shimast.KindComputedPropertyName:
+      return false
     }
-    node.ForEachChild(func(child *shimast.Node) bool {
-      walk(child)
+
+    if noParamReassignPropertyWalkStopsAt(parent) {
       return false
-    })
+    }
+    current = parent
+  }
+  return false
+}
+
+func noParamReassignPropertyWalkStopsAt(node *shimast.Node) bool {
+  if node == nil || node.Kind == shimast.KindSourceFile || isFunctionLikeKind(node) {
+    return true
+  }
+  if node.Kind >= shimast.KindFirstStatement && node.Kind <= shimast.KindLastStatement {
+    return true
+  }
+  switch node.Kind {
+  case shimast.KindParameter,
+    shimast.KindVariableDeclaration,
+    shimast.KindPropertyDeclaration,
+    shimast.KindClassDeclaration,
+    shimast.KindInterfaceDeclaration,
+    shimast.KindTypeAliasDeclaration,
+    shimast.KindEnumDeclaration,
+    shimast.KindModuleDeclaration:
+    return true
   }
-  walk(root)
+  return false
 }
 
 func init() {

package/linthost/rules_no_promise_executor_return.go

@@ -0,0 +1,156 @@
+// noPromiseExecutorReturn rejects values returned by the callback passed as
+// the first argument to the global Promise constructor. Promise ignores its
+// executor's return value, so a value return almost always reflects a missing
+// resolve/reject call or an accidentally concise arrow body.
+//
+// The rule uses checker binding identity rather than identifier text: a local
+// class, variable, import, or parameter named Promise is a different
+// constructor and remains untouched. It walks every statement nested inside
+// the executor, but stops at nested function-like boundaries so those
+// functions retain their own return scopes.
+// https://eslint.org/docs/latest/rules/no-promise-executor-return
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+const noPromiseExecutorReturnMessage = "Return values from promise executor functions cannot be read."
+
+type noPromiseExecutorReturn struct{ optionsRule }
+
+type noPromiseExecutorReturnOptions struct {
+  AllowVoid bool `json:"allowVoid"`
+}
+
+func (noPromiseExecutorReturn) Name() string { return "no-promise-executor-return" }
+func (noPromiseExecutorReturn) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindNewExpression}
+}
+func (noPromiseExecutorReturn) NeedsTypeChecker() bool { return true }
+func (noPromiseExecutorReturn) Check(ctx *Context, node *shimast.Node) {
+  expression := node.AsNewExpression()
+  if expression == nil || expression.Arguments == nil || len(expression.Arguments.Nodes) == 0 {
+    return
+  }
+  callee := stripParens(expression.Expression)
+  if !isGlobalPromiseConstructor(ctx, callee) {
+    return
+  }
+
+  executor := stripParens(expression.Arguments.Nodes[0])
+  if executor == nil || (executor.Kind != shimast.KindArrowFunction && executor.Kind != shimast.KindFunctionExpression) {
+    return
+  }
+  body := executor.Body()
+  if body == nil {
+    return
+  }
+
+  var options noPromiseExecutorReturnOptions
+  _ = ctx.DecodeOptions(&options)
+  if executor.Kind == shimast.KindArrowFunction && body.Kind != shimast.KindBlock {
+    reportPromiseExecutorReturn(ctx, body, body, options)
+    return
+  }
+  walkPromiseExecutorReturns(body, func(returnNode, value *shimast.Node) {
+    reportPromiseExecutorReturn(ctx, returnNode, value, options)
+  })
+}
+
+// isGlobalPromiseConstructor proves that callee resolves to the program's
+// global Promise value. The declaration guard handles script files whose
+// top-level value declaration can merge into the checker global table: such a
+// declaration still shadows the built-in for this source file and must not be
+// treated as the standard Promise constructor.
+func isGlobalPromiseConstructor(ctx *Context, callee *shimast.Node) bool {
+  if ctx == nil || ctx.Checker == nil || ctx.File == nil || identifierText(callee) != "Promise" {
+    return false
+  }
+  resolved := ctx.Checker.GetSymbolAtLocation(callee)
+  global := ctx.Checker.GetGlobalSymbol("Promise", shimast.SymbolFlagsValue, nil)
+  if resolved == nil || global == nil {
+    return false
+  }
+  resolved = ctx.Checker.GetMergedSymbol(resolved)
+  global = ctx.Checker.GetMergedSymbol(global)
+  if resolved != global {
+    return false
+  }
+  for _, declaration := range resolved.Declarations {
+    if declaration != nil && shimast.GetSourceFileOfNode(declaration) == ctx.File &&
+      promiseDeclarationIntroducesValue(declaration) {
+      return false
+    }
+  }
+  return true
+}
+
+// promiseDeclarationIntroducesValue distinguishes same-file value bindings
+// from type-only declarations that legitimately merge with the global Promise
+// interface. The checker already resolves nested lexical bindings to a
+// different symbol; this list is only needed for declarations merged into a
+// script's global symbol table.
+func promiseDeclarationIntroducesValue(declaration *shimast.Node) bool {
+  switch declaration.Kind {
+  case
+    shimast.KindVariableDeclaration,
+    shimast.KindBindingElement,
+    shimast.KindFunctionDeclaration,
+    shimast.KindClassDeclaration,
+    shimast.KindEnumDeclaration,
+    shimast.KindModuleDeclaration,
+    shimast.KindImportEqualsDeclaration:
+    return true
+  }
+  return false
+}
+
+// walkPromiseExecutorReturns visits all explicit return statements owned by
+// root. Nested control-flow statements are traversed naturally; nested
+// functions are pruned because their return values belong to another call.
+func walkPromiseExecutorReturns(root *shimast.Node, visit func(returnNode, value *shimast.Node)) {
+  if root == nil {
+    return
+  }
+  var walk func(*shimast.Node)
+  walk = func(node *shimast.Node) {
+    if node == nil {
+      return
+    }
+    if node != root && isFunctionLikeKind(node) {
+      return
+    }
+    if node.Kind == shimast.KindReturnStatement {
+      statement := node.AsReturnStatement()
+      if statement != nil && statement.Expression != nil {
+        visit(node, statement.Expression)
+      }
+      return
+    }
+    node.ForEachChild(func(child *shimast.Node) bool {
+      walk(child)
+      return false
+    })
+  }
+  walk(root)
+}
+
+func reportPromiseExecutorReturn(
+  ctx *Context,
+  reportNode *shimast.Node,
+  value *shimast.Node,
+  options noPromiseExecutorReturnOptions,
+) {
+  if options.AllowVoid && isExplicitVoidExpression(value) {
+    return
+  }
+  ctx.Report(reportNode, noPromiseExecutorReturnMessage)
+}
+
+func isExplicitVoidExpression(node *shimast.Node) bool {
+  node = stripParens(node)
+  return node != nil && node.Kind == shimast.KindVoidExpression
+}
+
+func init() {
+  Register(noPromiseExecutorReturn{})
+}