@typescript-eslint/max-params

internal/config/config.go

@@ -25,6 +25,7 @@ import (
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/consistent_type_imports"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/default_param_last"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/dot_notation"
+	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/max_params"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/no_array_constructor"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/no_array_delete"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/no_base_to_string"
@@ -391,6 +392,7 @@ func registerAllTypeScriptEslintPluginRules() {
 	GlobalRuleRegistry.Register("@typescript-eslint/consistent-type-imports", consistent_type_imports.ConsistentTypeImportsRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/default-param-last", default_param_last.DefaultParamLastRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/dot-notation", dot_notation.DotNotationRule)
+	GlobalRuleRegistry.Register("@typescript-eslint/max-params", max_params.MaxParamsRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/no-array-constructor", no_array_constructor.NoArrayConstructorRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/no-array-delete", no_array_delete.NoArrayDeleteRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/no-base-to-string", no_base_to_string.NoBaseToStringRule)

internal/plugins/typescript/rules/max_params/max_params.go

@@ -0,0 +1,139 @@
+package max_params
+
+import (
+	"fmt"
+
+	"github.com/microsoft/typescript-go/shim/ast"
+	"github.com/web-infra-dev/rslint/internal/rule"
+)
+
+type MaxParamsOptions struct {
+	Max           int  `json:"max"`
+	CountVoidThis bool `json:"countVoidThis"`
+}
+
+func parseNumericOption(value interface{}) (int, bool) {
+	switch v := value.(type) {
+	case int:
+		return v, true
+	case int32:
+		return int(v), true
+	case int64:
+		return int(v), true
+	case float32:
+		return int(v), true
+	case float64:
+		return int(v), true
+	default:
+		return 0, false
+	}
+}
+
+func parseOptions(options any) MaxParamsOptions {
+	opts := MaxParamsOptions{
+		Max:           3,
+		CountVoidThis: false,
+	}
+
+	if options == nil {
+		return opts
+	}
+
+	var optsMap map[string]interface{}
+	if arr, ok := options.([]interface{}); ok && len(arr) > 0 {
+		if m, ok := arr[0].(map[string]interface{}); ok {
+			optsMap = m
+		}
+	} else if m, ok := options.(map[string]interface{}); ok {
+		optsMap = m
+	}
+
+	if optsMap == nil {
+		return opts
+	}
+
+	hasMax := false
+	if value, ok := optsMap["max"]; ok {
+		if maxValue, ok := parseNumericOption(value); ok {
+			opts.Max = maxValue
+			hasMax = true
+		}
+	}
+	if !hasMax {
+		if value, ok := optsMap["maximum"]; ok {
+			if maxValue, ok := parseNumericOption(value); ok {
+				opts.Max = maxValue
+			}
+		}
+	}
+	if value, ok := optsMap["countVoidThis"]; ok {
+		if flag, ok := value.(bool); ok {
+			opts.CountVoidThis = flag
+		}
+	}
+
+	return opts
+}
+
+func isVoidThisParameter(param *ast.Node) bool {
+	if param == nil || !ast.IsParameter(param) {
+		return false
+	}
+
+	decl := param.AsParameterDeclaration()
+	if decl == nil {
+		return false
+	}
+
+	name := decl.Name()
+	if name == nil || name.Kind != ast.KindIdentifier {
+		return false
+	}
+
+	if name.AsIdentifier().Text != "this" {
+		return false
+	}
+
+	return decl.Type != nil && decl.Type.Kind == ast.KindVoidKeyword
+}
+
+func buildExceedMessage(count int, maxCount int) rule.RuleMessage {
+	return rule.RuleMessage{
+		Id:          "exceed",
+		Description: fmt.Sprintf("Function has too many parameters (%d). Maximum allowed is %d.", count, maxCount),
+	}
+}
+
+var MaxParamsRule = rule.CreateRule(rule.Rule{
+	Name: "max-params",
+	Run: func(ctx rule.RuleContext, options any) rule.RuleListeners {
+		opts := parseOptions(options)
+
+		checkParameters := func(node *ast.Node) {
+			params := node.Parameters()
+			if params == nil {
+				return
+			}
+
+			count := len(params)
+			if !opts.CountVoidThis && count > 0 && isVoidThisParameter(params[0]) {
+				count--
+			}
+
+			if count > opts.Max {
+				ctx.ReportNode(node, buildExceedMessage(count, opts.Max))
+			}
+		}
+
+		return rule.RuleListeners{
+			ast.KindFunctionDeclaration: checkParameters,
+			ast.KindFunctionExpression:  checkParameters,
+			ast.KindArrowFunction:       checkParameters,
+			ast.KindMethodDeclaration:   checkParameters,
+			ast.KindConstructor:         checkParameters,
+			ast.KindGetAccessor:         checkParameters,
+			ast.KindSetAccessor:         checkParameters,
+			ast.KindFunctionType:        checkParameters,
+		}
+	},
+})

internal/plugins/typescript/rules/max_params/max_params.md

@@ -0,0 +1,29 @@
+# max-params
+
+## Rule Details
+
+Enforce a maximum number of parameters in function-like declarations.
+
+Examples of **incorrect** code for this rule:
+
+```typescript
+function foo(a, b, c, d) {}
+
+class Foo {
+  method(this: Foo, a, b, c) {}
+}
+```
+
+Examples of **correct** code for this rule:
+
+```typescript
+function foo(a, b, c) {}
+
+class Foo {
+  method(this: void, a, b, c) {}
+}
+```
+
+## Original Documentation
+
+https://typescript-eslint.io/rules/max-params

internal/plugins/typescript/rules/max_params/max_params_test.go

@@ -0,0 +1,176 @@
+package max_params
+
+import (
+	"testing"
+
+	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/fixtures"
+	"github.com/web-infra-dev/rslint/internal/rule_tester"
+)
+
+func TestMaxParamsRule(t *testing.T) {
+	rule_tester.RunRuleTester(fixtures.GetRootDir(), "tsconfig.json", t, &MaxParamsRule, []rule_tester.ValidTestCase{
+		{Code: `function foo() {}`},
+		{Code: `const foo = function () {};`},
+		{Code: `const foo = () => {};`},
+		{Code: `function foo(a) {}`},
+		{
+			Code: `
+class Foo {
+  constructor(a) {}
+}
+			`,
+		},
+		{
+			Code: `
+class Foo {
+  method(this: void, a, b, c) {}
+}
+			`,
+		},
+		{
+			Code: `
+class Foo {
+  method(this: Foo, a, b) {}
+}
+			`,
+		},
+		{
+			Code:    `function foo(a, b, c, d) {}`,
+			Options: []interface{}{map[string]interface{}{"max": 4}},
+		},
+		{
+			Code:    `function foo(a, b, c, d) {}`,
+			Options: []interface{}{map[string]interface{}{"maximum": 4}},
+		},
+		{
+			Code: `
+class Foo {
+  method(this: void) {}
+}
+			`,
+			Options: []interface{}{map[string]interface{}{"max": 0}},
+		},
+		{
+			Code: `
+class Foo {
+  method(this: void, a) {}
+}
+			`,
+			Options: []interface{}{map[string]interface{}{"max": 1}},
+		},
+		{
+			Code: `
+class Foo {
+  method(this: void, a) {}
+}
+			`,
+			Options: []interface{}{map[string]interface{}{"countVoidThis": true, "max": 2}},
+		},
+		{
+			Code: `
+declare function makeDate(m: number, d: number, y: number): Date;
+			`,
+			Options: []interface{}{map[string]interface{}{"max": 3}},
+		},
+		{
+			Code: `
+type sum = (a: number, b: number) => number;
+			`,
+			Options: []interface{}{map[string]interface{}{"max": 2}},
+		},
+		{
+			Code: `
+interface Foo {
+  method(a: number, b: number, c: number, d: number): void;
+}
+			`,
+		},
+		{
+			Code: `
+type CallSig = {
+  (a: number, b: number, c: number, d: number): void;
+};
+			`,
+		},
+		{
+			Code: `
+type Ctor = new (a: number, b: number, c: number, d: number) => Foo;
+			`,
+		},
+	}, []rule_tester.InvalidTestCase{
+		{
+			Code: `function foo(a, b, c, d) {}`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "exceed", Line: 1, Column: 1, EndLine: 1, EndColumn: 28},
+			},
+		},
+		{
+			Code: `const foo = function (a, b, c, d) {};`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "exceed", Line: 1, Column: 13, EndLine: 1, EndColumn: 37},
+			},
+		},
+		{
+			Code: `const foo = (a, b, c, d) => {};`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "exceed", Line: 1, Column: 13, EndLine: 1, EndColumn: 31},
+			},
+		},
+		{
+			Code:    `const foo = a => {};`,
+			Options: []interface{}{map[string]interface{}{"max": 0}},
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "exceed", Line: 1, Column: 13, EndLine: 1, EndColumn: 20},
+			},
+		},
+		{
+			Code: `
+class Foo {
+  method(this: void, a, b, c, d) {}
+}
+			`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "exceed", Line: 3, Column: 3, EndLine: 3, EndColumn: 36},
+			},
+		},
+		{
+			Code: `
+class Foo {
+  method(this: void, a) {}
+}
+			`,
+			Options: []interface{}{map[string]interface{}{"countVoidThis": true, "max": 1}},
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "exceed", Line: 3, Column: 3, EndLine: 3, EndColumn: 27},
+			},
+		},
+		{
+			Code: `
+class Foo {
+  method(this: Foo, a, b, c) {}
+}
+			`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "exceed", Line: 3, Column: 3, EndLine: 3, EndColumn: 32},
+			},
+		},
+		{
+			Code: `
+declare function makeDate(m: number, d: number, y: number): Date;
+			`,
+			Options: []interface{}{map[string]interface{}{"max": 1}},
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "exceed", Line: 2, Column: 1, EndLine: 2, EndColumn: 66},
+			},
+		},
+		{
+			Code: `
+type sum = (a: number, b: number) => number;
+			`,
+			Options: []interface{}{map[string]interface{}{"max": 1}},
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "exceed", Line: 2, Column: 12, EndLine: 2, EndColumn: 44},
+			},
+		},
+	})
+}

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

@@ -36,7 +36,7 @@ export default defineConfig({
     // './tests/typescript-eslint/rules/explicit-member-accessibility.test.ts',
     // './tests/typescript-eslint/rules/explicit-module-boundary-types.test.ts',
     // './tests/typescript-eslint/rules/init-declarations.test.ts',
-    // './tests/typescript-eslint/rules/max-params.test.ts',
+    './tests/typescript-eslint/rules/max-params.test.ts',
     // './tests/typescript-eslint/rules/member-ordering.test.ts',
     // './tests/typescript-eslint/rules/member-ordering/member-ordering-alphabetically-case-insensitive-order.test.ts',
     // './tests/typescript-eslint/rules/member-ordering/member-ordering-alphabetically-order.test.ts',