feat: port eslint core rule no-ex-assign (#485)

Author: eryue0220

internal/config/config.go

@@ -79,6 +79,7 @@ import (
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/prefer_namespace_keyword"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/prefer_promise_reject_errors"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/prefer_readonly"
+
 	// "github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/prefer_readonly_parameter_types" // Temporarily disabled - incomplete implementation
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/prefer_reduce_type_parameter"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/prefer_regexp_exec"
@@ -120,6 +121,7 @@ import (
 	"github.com/web-infra-dev/rslint/internal/rules/no_duplicate_case"
 	"github.com/web-infra-dev/rslint/internal/rules/no_empty"
 	"github.com/web-infra-dev/rslint/internal/rules/no_empty_pattern"
+	"github.com/web-infra-dev/rslint/internal/rules/no_ex_assign"
 	"github.com/web-infra-dev/rslint/internal/rules/no_loss_of_precision"
 	"github.com/web-infra-dev/rslint/internal/rules/no_sparse_arrays"
 	"github.com/web-infra-dev/rslint/internal/rules/no_template_curly_in_string"
@@ -419,6 +421,7 @@ func registerAllCoreEslintRules() {
 	GlobalRuleRegistry.Register("no-duplicate-case", no_duplicate_case.NoDuplicateCaseRule)
 	GlobalRuleRegistry.Register("no-empty", no_empty.NoEmptyRule)
 	GlobalRuleRegistry.Register("no-empty-pattern", no_empty_pattern.NoEmptyPatternRule)
+	GlobalRuleRegistry.Register("no-ex-assign", no_ex_assign.NoExAssignRule)
 	GlobalRuleRegistry.Register("no-loss-of-precision", no_loss_of_precision.NoLossOfPrecisionRule)
 	GlobalRuleRegistry.Register("no-template-curly-in-string", no_template_curly_in_string.NoTemplateCurlyInString)
 	GlobalRuleRegistry.Register("no-sparse-arrays", no_sparse_arrays.NoSparseArraysRule)

internal/rules/no_ex_assign/no_ex_assign.go

@@ -0,0 +1,299 @@
+package no_ex_assign
+
+import (
+	"slices"
+
+	"github.com/microsoft/typescript-go/shim/ast"
+	"github.com/web-infra-dev/rslint/internal/rule"
+	"github.com/web-infra-dev/rslint/internal/utils"
+)
+
+// Message builder
+func buildExAssignMessage() rule.RuleMessage {
+	return rule.RuleMessage{
+		Id:          "unexpected",
+		Description: "Do not assign to the exception parameter.",
+	}
+}
+
+func collectCatchBindingNamesAndSymbols(node *ast.Node, ctx rule.RuleContext) ([]string, []*ast.Symbol) {
+	if node == nil {
+		return nil, nil
+	}
+	if ast.IsIdentifier(node) {
+		return []string{node.Text()}, []*ast.Symbol{ctx.TypeChecker.GetSymbolAtLocation(node)}
+	}
+	if ast.IsBindingPattern(node) {
+		var names []string
+		var symbols []*ast.Symbol
+		for _, elem := range node.Elements() {
+			if elem == nil || !ast.IsBindingElement(elem) {
+				continue
+			}
+			be := elem.AsBindingElement()
+			if be == nil || be.Name() == nil {
+				continue
+			}
+			utils.CollectBindingNames(be.Name(), func(ident *ast.Node, name string) {
+				names = append(names, name)
+				symbols = append(symbols, ctx.TypeChecker.GetSymbolAtLocation(ident))
+			})
+		}
+		return names, symbols
+	}
+	return nil, nil
+}
+
+func isBindingPatternInAssignment(node *ast.Node) bool {
+	if node == nil {
+		return false
+	}
+
+	parent := node.Parent
+
+	for parent != nil && parent.Kind == ast.KindParenthesizedExpression {
+		parent = parent.Parent
+	}
+
+	if parent == nil || parent.Kind != ast.KindBinaryExpression {
+		return false
+	}
+
+	binary := parent.AsBinaryExpression()
+	if binary == nil || binary.OperatorToken == nil {
+		return false
+	}
+
+	switch binary.OperatorToken.Kind {
+	case ast.KindEqualsToken:
+		return binary.Left == node
+	}
+
+	return false
+}
+
+func isInDestructuringAssignment(node *ast.Node) bool {
+	current := node
+	for current != nil {
+		parent := current.Parent
+		if parent == nil {
+			return false
+		}
+
+		switch parent.Kind {
+		case ast.KindBinaryExpression:
+			binary := parent.AsBinaryExpression()
+			if binary != nil && binary.OperatorToken != nil &&
+				binary.OperatorToken.Kind == ast.KindEqualsToken {
+				return binary.Left == current
+			}
+			return false
+		case ast.KindParenthesizedExpression,
+			ast.KindObjectLiteralExpression,
+			ast.KindArrayLiteralExpression,
+			ast.KindPropertyAssignment,
+			ast.KindShorthandPropertyAssignment,
+			ast.KindSpreadAssignment:
+			current = parent
+		default:
+			return false
+		}
+	}
+	return false
+}
+
+func isWriteReference(node *ast.Node) bool {
+	if node == nil || node.Parent == nil {
+		return false
+	}
+
+	parent := node.Parent
+
+	switch parent.Kind {
+	case ast.KindBinaryExpression:
+		binary := parent.AsBinaryExpression()
+		if binary == nil || binary.OperatorToken == nil {
+			return false
+		}
+
+		switch binary.OperatorToken.Kind {
+		case ast.KindEqualsToken,
+			ast.KindPlusEqualsToken,
+			ast.KindMinusEqualsToken,
+			ast.KindAsteriskAsteriskEqualsToken,
+			ast.KindAsteriskEqualsToken,
+			ast.KindSlashEqualsToken,
+			ast.KindPercentEqualsToken,
+			ast.KindLessThanLessThanEqualsToken,
+			ast.KindGreaterThanGreaterThanEqualsToken,
+			ast.KindGreaterThanGreaterThanGreaterThanEqualsToken,
+			ast.KindAmpersandEqualsToken,
+			ast.KindBarEqualsToken,
+			ast.KindCaretEqualsToken,
+			ast.KindBarBarEqualsToken,
+			ast.KindAmpersandAmpersandEqualsToken,
+			ast.KindQuestionQuestionEqualsToken:
+			return binary.Left == node
+		}
+	case ast.KindPostfixUnaryExpression:
+		postfix := parent.AsPostfixUnaryExpression()
+		if postfix == nil {
+			return false
+		}
+		switch postfix.Operator {
+		case ast.KindPlusPlusToken, ast.KindMinusMinusToken:
+			return postfix.Operand == node
+		}
+	case ast.KindPrefixUnaryExpression:
+		prefix := parent.AsPrefixUnaryExpression()
+		if prefix == nil {
+			return false
+		}
+		switch prefix.Operator {
+		case ast.KindPlusPlusToken, ast.KindMinusMinusToken:
+			return prefix.Operand == node
+		}
+	case ast.KindForInStatement:
+		forIn := parent.AsForInOrOfStatement()
+		if forIn == nil {
+			return false
+		}
+		return forIn.Initializer == node
+	case ast.KindForOfStatement:
+		forOf := parent.AsForInOrOfStatement()
+		if forOf == nil {
+			return false
+		}
+		return forOf.Initializer == node
+	case ast.KindObjectBindingPattern:
+		return isBindingPatternInAssignment(parent)
+	case ast.KindArrayBindingPattern:
+		return isBindingPatternInAssignment(parent)
+	case ast.KindBindingElement:
+		return isWriteReference(parent)
+	case ast.KindShorthandPropertyAssignment:
+		shorthand := parent.AsShorthandPropertyAssignment()
+		if shorthand != nil && shorthand.Name() == node {
+			return isInDestructuringAssignment(parent)
+		}
+	case ast.KindPropertyAssignment:
+		propAssignment := parent.AsPropertyAssignment()
+		if propAssignment != nil && propAssignment.Initializer == node {
+			return isInDestructuringAssignment(parent)
+		}
+	case ast.KindObjectLiteralExpression:
+		return isInDestructuringAssignment(parent)
+	case ast.KindArrayLiteralExpression:
+		return isInDestructuringAssignment(parent)
+	case ast.KindParenthesizedExpression:
+		return isWriteReference(parent)
+	case ast.KindAsExpression, ast.KindTypeAssertionExpression:
+		return isWriteReference(parent)
+	}
+
+	return false
+}
+
+func getReferenceSymbol(node *ast.Node, ctx rule.RuleContext) *ast.Symbol {
+	if node == nil || ctx.TypeChecker == nil {
+		return nil
+	}
+
+	parent := node.Parent
+	if parent != nil && parent.Kind == ast.KindShorthandPropertyAssignment {
+		shorthand := parent.AsShorthandPropertyAssignment()
+		if shorthand != nil && shorthand.Name() == node {
+			if symbol := ctx.TypeChecker.GetShorthandAssignmentValueSymbol(parent); symbol != nil {
+				return symbol
+			}
+		}
+	}
+
+	return ctx.TypeChecker.GetSymbolAtLocation(node)
+}
+
+func isNameShadowed(node *ast.Node, symbols []*ast.Symbol, ctx rule.RuleContext) bool {
+	if node == nil || ctx.TypeChecker == nil || len(symbols) == 0 {
+		return false
+	}
+
+	symbol := getReferenceSymbol(node, ctx)
+	if symbol == nil {
+		return false
+	}
+
+	for _, s := range symbols {
+		if s == symbol {
+			return false
+		}
+	}
+	return true
+}
+
+func getIdentifierName(node *ast.Node) string {
+	if node == nil || node.Kind != ast.KindIdentifier {
+		return ""
+	}
+	return node.Text()
+}
+
+func checkReassignments(block *ast.Node, names []string, symbols []*ast.Symbol, ctx rule.RuleContext) {
+	if block == nil || ctx.TypeChecker == nil || len(names) == 0 || len(symbols) == 0 {
+		return
+	}
+
+	var walk func(*ast.Node)
+	walk = func(block *ast.Node) {
+		if block == nil {
+			return
+		}
+
+		block.ForEachChild(func(child *ast.Node) bool {
+			if child == nil {
+				return false
+			}
+
+			childName := getIdentifierName(child)
+			if child.Kind == ast.KindIdentifier && slices.Contains(names, childName) {
+				if isWriteReference(child) {
+					shadowed := isNameShadowed(child, symbols, ctx)
+					if !shadowed {
+						ctx.ReportNode(child, buildExAssignMessage())
+					}
+				}
+			} else {
+				walk(child)
+			}
+
+			return false
+		})
+	}
+
+	walk(block)
+}
+
+var NoExAssignRule = rule.Rule{
+	Name: "no-ex-assign",
+	Run: func(ctx rule.RuleContext, options any) rule.RuleListeners {
+		return rule.RuleListeners{
+			ast.KindCatchClause: func(node *ast.Node) {
+				if node.AsCatchClause().VariableDeclaration == nil {
+					return
+				}
+
+				varDecl := node.AsCatchClause().VariableDeclaration.AsVariableDeclaration()
+				if varDecl == nil || varDecl.Name() == nil {
+					return
+				}
+
+				block := node.AsCatchClause().Block
+				if block == nil {
+					return
+				}
+
+				names, symbols := collectCatchBindingNamesAndSymbols(varDecl.Name(), ctx)
+				checkReassignments(block, names, symbols, ctx)
+			},
+		}
+	},
+}

internal/rules/no_ex_assign/no_ex_assign.md

@@ -0,0 +1,53 @@
+# no-ex-assign
+
+## Rule Details
+
+Disallow assign another value to the exception parameter a catch clause in a try statement accidentally or purposely. Since there is no arguments object to offer alternative access to this data, assignment of the parameter is absolutely destructive.
+
+Examples of **correct** code for this rule:
+
+```javascript
+try {
+} catch (e) {
+  three = 2 + 1;
+}
+try {
+} catch ({ e }) {
+  this.something = 2;
+}
+function foo() {
+  try {
+  } catch (e) {
+    return false;
+  }
+}
+```
+
+Examples of **incorrect** code for this rule:
+
+```javascript
+try {
+} catch (e) {
+  e = 10;
+}
+try {
+} catch (ex) {
+  ex = 10;
+}
+try {
+} catch (ex) {
+  [ex] = [];
+}
+try {
+} catch (ex) {
+  ({ x: ex = 0 } = {});
+}
+try {
+} catch ({ message }) {
+  message = 10;
+}
+```
+
+## Original Documentation
+
+https://eslint.org/docs/latest/rules/no-ex-assign