feat: port rule no-setter-return

Author: fansenze

internal/config/config.go

@@ -123,6 +123,7 @@ import (
 	"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"
+	"github.com/web-infra-dev/rslint/internal/rules/no_setter_return"
 )
 
 // RslintConfig represents the top-level configuration array
@@ -422,6 +423,7 @@ func registerAllCoreEslintRules() {
 	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)
+	GlobalRuleRegistry.Register("no-setter-return", no_setter_return.NoSetterReturnRule)
 }
 
 // getAllTypeScriptEslintPluginRules returns all rules from the global registry.

internal/rules/no_setter_return/no_setter_return.go

@@ -0,0 +1,58 @@
+package no_setter_return
+
+import (
+	"github.com/microsoft/typescript-go/shim/ast"
+	"github.com/web-infra-dev/rslint/internal/rule"
+)
+
+// buildSetterMessage returns the diagnostic message for a return-with-value in a setter.
+func buildSetterMessage() rule.RuleMessage {
+	return rule.RuleMessage{
+		Id:          "setter",
+		Description: "Setter cannot return a value.",
+	}
+}
+
+// findEnclosingSetter walks up the parent chain to find if the node is inside a setter.
+// Returns the setter node if found, or nil if a different function boundary is hit first.
+func findEnclosingSetter(node *ast.Node) *ast.Node {
+	current := node.Parent
+	for current != nil {
+		switch current.Kind {
+		case ast.KindSetAccessor:
+			return current
+		case ast.KindFunctionDeclaration,
+			ast.KindFunctionExpression,
+			ast.KindArrowFunction,
+			ast.KindMethodDeclaration,
+			ast.KindGetAccessor,
+			ast.KindConstructor:
+			// Hit a different function boundary; stop searching.
+			return nil
+		}
+		current = current.Parent
+	}
+	return nil
+}
+
+// NoSetterReturnRule disallows returning a value from a setter.
+// Setters cannot meaningfully return values; any return value is silently ignored.
+// A bare `return;` (without a value) is allowed for control flow.
+var NoSetterReturnRule = rule.Rule{
+	Name: "no-setter-return",
+	Run: func(ctx rule.RuleContext, options any) rule.RuleListeners {
+		return rule.RuleListeners{
+			ast.KindReturnStatement: func(node *ast.Node) {
+				ret := node.AsReturnStatement()
+				// Allow bare return (no expression)
+				if ret.Expression == nil {
+					return
+				}
+				// Check if the return statement is inside a setter
+				if findEnclosingSetter(node) != nil {
+					ctx.ReportNode(node, buildSetterMessage())
+				}
+			},
+		}
+	},
+}

internal/rules/no_setter_return/no_setter_return.md

@@ -0,0 +1,56 @@
+# no-setter-return
+
+## Rule Details
+
+Disallows returning a value from a setter. Setters cannot meaningfully return values since any return value is silently ignored by the JavaScript engine. A bare `return;` (without a value) is allowed for control flow purposes.
+
+Examples of **incorrect** code for this rule:
+
+```javascript
+var foo = {
+  set a(val) {
+    return 1;
+  },
+};
+
+class A {
+  set a(val) {
+    return val;
+  }
+}
+
+var bar = {
+  set a(val) {
+    return undefined;
+  },
+};
+```
+
+Examples of **correct** code for this rule:
+
+```javascript
+var foo = {
+  set a(val) {
+    val = 1;
+  },
+};
+
+class A {
+  set a(val) {
+    if (!val) {
+      return; // bare return for flow control is fine
+    }
+    this._a = val;
+  }
+}
+
+class B {
+  get a() {
+    return this._a; // getters can return values
+  }
+}
+```
+
+## Original Documentation
+
+- [ESLint no-setter-return](https://eslint.org/docs/latest/rules/no-setter-return)

internal/rules/no_setter_return/no_setter_return_test.go

@@ -0,0 +1,91 @@
+package no_setter_return
+
+import (
+	"testing"
+
+	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/fixtures"
+	"github.com/web-infra-dev/rslint/internal/rule_tester"
+)
+
+func TestNoSetterReturnRule(t *testing.T) {
+	rule_tester.RunRuleTester(
+		fixtures.GetRootDir(),
+		"tsconfig.json",
+		t,
+		&NoSetterReturnRule,
+		// Valid cases
+		[]rule_tester.ValidTestCase{
+			// Object literal setter with assignment (no return)
+			{Code: `var foo = { set a(val) { val = 1; } };`},
+			// Class setter with assignment (no return)
+			{Code: `class A { set a(val) { val = 1; } }`},
+			// Object literal setter with bare return (allowed)
+			{Code: `var foo = { set a(val) { return; } };`},
+			// Getter returning a value (not a setter)
+			{Code: `class A { get a() { return 1; } }`},
+			// Object literal getter returning a value
+			{Code: `var foo = { get a() { return 1; } };`},
+			// Setter with conditional bare return
+			{Code: `var foo = { set a(val) { if (val) { return; } } };`},
+			// Class setter with bare return
+			{Code: `class A { set a(val) { return; } }`},
+			// Nested function inside setter can return values
+			{Code: `var foo = { set a(val) { function inner() { return 1; } } };`},
+			// Arrow function inside setter can return values
+			{Code: `class A { set a(val) { const fn = () => { return 1; }; } }`},
+			// Function expression inside setter can return values
+			{Code: `var foo = { set a(val) { var fn = function() { return 1; }; } };`},
+			// Regular method returning a value
+			{Code: `class A { method() { return 1; } }`},
+			// Regular function returning a value
+			{Code: `function fn() { return 1; }`},
+		},
+		// Invalid cases
+		[]rule_tester.InvalidTestCase{
+			// Object literal setter returning a number
+			{
+				Code: `var foo = { set a(val) { return 1; } };`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{
+						MessageId: "setter",
+						Line:      1,
+						Column:    26,
+					},
+				},
+			},
+			// Class setter returning the parameter
+			{
+				Code: `class A { set a(val) { return val; } }`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{
+						MessageId: "setter",
+						Line:      1,
+						Column:    24,
+					},
+				},
+			},
+			// Object literal setter returning undefined explicitly
+			{
+				Code: `var foo = { set a(val) { return undefined; } };`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{
+						MessageId: "setter",
+						Line:      1,
+						Column:    26,
+					},
+				},
+			},
+			// Class setter with conditional return of a value
+			{
+				Code: `class A { set a(val) { if (val) { return 1; } } }`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{
+						MessageId: "setter",
+						Line:      1,
+						Column:    35,
+					},
+				},
+			},
+		},
+	)
+}

packages/rslint-test-tools/rstest.config.mts

@@ -20,6 +20,7 @@ export default defineConfig({
     './tests/eslint/rules/no-empty-pattern.test.ts',
     './tests/eslint/rules/getter-return.test.ts',
     './tests/eslint/rules/no-loss-of-precision.test.ts',
+    './tests/eslint/rules/no-setter-return.test.ts',
 
     // eslint-plugin-import
     './tests/eslint-plugin-import/rules/no-self-import.test.ts',
@@ -110,6 +111,7 @@ export default defineConfig({
     './tests/typescript-eslint/rules/no-invalid-void-type.test.ts',
     // './tests/typescript-eslint/rules/no-loop-func.test.ts',
     // './tests/typescript-eslint/rules/no-loss-of-precision.test.ts',
+    './tests/eslint/rules/no-setter-return.test.ts',
     // './tests/typescript-eslint/rules/no-magic-numbers.test.ts',
     // './tests/typescript-eslint/rules/no-meaningless-void-operator.test.ts',
     './tests/typescript-eslint/rules/no-misused-new.test.ts',

packages/rslint-test-tools/tests/eslint/rules/__snapshots__/no-setter-return.test.ts.snap

@@ -0,0 +1,53 @@
+// Rstest Snapshot v1
+
+exports[`no-setter-return > invalid 1`] = `
+{
+  "code": "var foo = { set a(val) { return 1; } };",
+  "diagnostics": [
+    {
+      "message": "Setter cannot return a value.",
+      "messageId": "setter",
+      "range": {
+        "end": {
+          "column": 35,
+          "line": 1,
+        },
+        "start": {
+          "column": 26,
+          "line": 1,
+        },
+      },
+      "ruleName": "no-setter-return",
+    },
+  ],
+  "errorCount": 1,
+  "fileCount": 1,
+  "ruleCount": 1,
+}
+`;
+
+exports[`no-setter-return > invalid 2`] = `
+{
+  "code": "class A { set a(val) { return val; } }",
+  "diagnostics": [
+    {
+      "message": "Setter cannot return a value.",
+      "messageId": "setter",
+      "range": {
+        "end": {
+          "column": 35,
+          "line": 1,
+        },
+        "start": {
+          "column": 24,
+          "line": 1,
+        },
+      },
+      "ruleName": "no-setter-return",
+    },
+  ],
+  "errorCount": 1,
+  "fileCount": 1,
+  "ruleCount": 1,
+}
+`;

packages/rslint-test-tools/tests/eslint/rules/no-setter-return.test.ts

@@ -0,0 +1,20 @@
+import { RuleTester } from '../rule-tester';
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('no-setter-return', {
+  valid: [
+    'var foo = { set a(val) { val = 1; } };',
+    'class A { set a(val) { return; } }',
+  ],
+  invalid: [
+    {
+      code: 'var foo = { set a(val) { return 1; } };',
+      errors: [{ messageId: 'setter' }],
+    },
+    {
+      code: 'class A { set a(val) { return val; } }',
+      errors: [{ messageId: 'setter' }],
+    },
+  ],
+});