feat: Port TypeScript-ESLint rule default-param-last (#85)

## Summary
This PR ports the TypeScript-ESLint rule `default-param-last` to rslint,
which enforces default parameters to be last in function parameter
lists.

Follow-up task of PR #84.

## Implementation Details
- ✅ Created new rule in
`internal/plugins/typescript/rules/default_param_last/`
- ✅ Enforces that parameters with defaults appear after those without
defaults
- ✅ Supports optional parameters (marked with `?`)
- ✅ Handles rest parameters correctly
- ✅ Supports parameter properties in constructors
- ✅ Registered in TypeScript plugin registry

## Rule Behavior
The rule ensures that function parameters with default values or
optional modifiers appear after required parameters.

### Invalid Patterns
```typescript
// Default before required
function f(a = 0, b: number) {}

// Optional before required
function f(a?: number, b: number) {}

// Default in the middle
function f(a: number, b = 0, c: number) {}
```

### Valid Patterns
```typescript
// Default parameters at the end
function f(a: number, b = 0) {}

// Optional parameters at the end
function f(a: number, b?: number) {}

// Rest parameters can come after defaults
function f(a: number, b = 0, ...c: number[]) {}
```

## Test Coverage
- ✅ Comprehensive test suite ported from TypeScript-ESLint repository
- ✅ 27 valid test cases covering various scenarios
- ✅ 16 invalid test cases with expected error detection
- ✅ All tests passing
- Tests include:
  - Function declarations, expressions, and arrow functions
  - Methods and constructors
  - Parameter properties
  - Destructuring patterns
  - Rest parameters
  - Mixed optional and default parameters

## Test Plan
- [x] All unit tests pass
- [ ] CI tests pass
- [ ] Manual testing with example code

## Notes
This implementation follows the TypeScript-ESLint rule specification
exactly:
- Detects default parameters (`= value`) and optional parameters (`?`)
that precede required parameters
- Rest parameters (`...args`) are correctly handled and can appear after
defaults
- Parameter properties in constructors are properly supported

## References
- Rule documentation:
https://typescript-eslint.io/rules/default-param-last/
- TypeScript-ESLint source:
https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/src/rules/default-param-last.ts
- TypeScript-ESLint tests:
https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/tests/rules/default-param-last.test.ts
- Related PR #84: #84

## Files Changed
- `internal/config/config.go` - Added import and rule registration (2
lines)
-
`internal/plugins/typescript/rules/default_param_last/default_param_last.go`
- Complete rule implementation (~177 lines)
-
`internal/plugins/typescript/rules/default_param_last/default_param_last_test.go`
- Comprehensive test suite (~192 lines)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Co-authored-by: claude[bot] <41898282+claude[bot]@users.noreply.github.com>
Co-authored-by: Claude <noreply@anthropic.com>

Author: 3 people

internal/config/config.go

@@ -23,6 +23,7 @@ import (
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/consistent_type_definitions"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/consistent_type_exports"
 	"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/no_array_delete"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/no_base_to_string"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/no_confusing_void_expression"
@@ -373,6 +374,7 @@ func registerAllTypeScriptEslintPluginRules() {
 	GlobalRuleRegistry.Register("@typescript-eslint/consistent-type-definitions", consistent_type_definitions.ConsistentTypeDefinitionsRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/consistent-type-exports", consistent_type_exports.ConsistentTypeExportsRule)
 	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/no-array-delete", no_array_delete.NoArrayDeleteRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/no-base-to-string", no_base_to_string.NoBaseToStringRule)

internal/plugins/typescript/rules/default_param_last/default_param_last.go

@@ -0,0 +1,175 @@
+package default_param_last
+
+import (
+	"github.com/microsoft/typescript-go/shim/ast"
+	"github.com/web-infra-dev/rslint/internal/rule"
+)
+
+// DefaultParamLastRule enforces default parameters to be last
+var DefaultParamLastRule = rule.CreateRule(rule.Rule{
+	Name: "default-param-last",
+	Run:  run,
+})
+
+func run(ctx rule.RuleContext, options any) rule.RuleListeners {
+	// Helper function to check if a parameter is optional
+	isOptionalParam := func(node *ast.Node) bool {
+		if node == nil {
+			return false
+		}
+
+		// Check if parameter has optional modifier
+		if node.Kind == ast.KindParameter {
+			param := node.AsParameterDeclaration()
+			if param != nil && param.QuestionToken != nil {
+				return true
+			}
+		}
+
+		return false
+	}
+
+	// Helper function to check if a parameter is a rest parameter
+	isRestParam := func(node *ast.Node) bool {
+		if node == nil {
+			return false
+		}
+
+		// Check for rest parameter (...)
+		if node.Kind == ast.KindParameter {
+			param := node.AsParameterDeclaration()
+			if param != nil && param.DotDotDotToken != nil {
+				return true
+			}
+		}
+
+		return false
+	}
+
+	// Helper function to check if a parameter is plain (no default, not rest, not optional)
+	isPlainParam := func(node *ast.Node) bool {
+		if node == nil {
+			return false
+		}
+
+		// Rest parameter is not plain
+		if isRestParam(node) {
+			return false
+		}
+
+		// Parameter with default value is not plain
+		if node.Kind == ast.KindParameter {
+			param := node.AsParameterDeclaration()
+			if param != nil {
+				// Has initializer (default value)
+				if param.Initializer != nil {
+					return false
+				}
+				// Is optional
+				if param.QuestionToken != nil {
+					return false
+				}
+			}
+		}
+
+		return true
+	}
+
+	// Check function for default parameter positioning
+	checkDefaultParamLast := func(node *ast.Node) {
+		var params []*ast.Node
+
+		// Get parameters based on node type
+		switch node.Kind {
+		case ast.KindFunctionDeclaration:
+			funcDecl := node.AsFunctionDeclaration()
+			if funcDecl != nil && funcDecl.Parameters != nil {
+				params = funcDecl.Parameters.Nodes
+			}
+		case ast.KindFunctionExpression:
+			funcExpr := node.AsFunctionExpression()
+			if funcExpr != nil && funcExpr.Parameters != nil {
+				params = funcExpr.Parameters.Nodes
+			}
+		case ast.KindArrowFunction:
+			arrowFunc := node.AsArrowFunction()
+			if arrowFunc != nil && arrowFunc.Parameters != nil {
+				params = arrowFunc.Parameters.Nodes
+			}
+		case ast.KindMethodDeclaration:
+			methodDecl := node.AsMethodDeclaration()
+			if methodDecl != nil && methodDecl.Parameters != nil {
+				params = methodDecl.Parameters.Nodes
+			}
+		case ast.KindConstructor:
+			constructor := node.AsConstructorDeclaration()
+			if constructor != nil && constructor.Parameters != nil {
+				params = constructor.Parameters.Nodes
+			}
+		default:
+			return
+		}
+
+		if len(params) == 0 {
+			return
+		}
+
+		// Iterate backward through parameters
+		hasSeenPlainParam := false
+		for i := len(params) - 1; i >= 0; i-- {
+			current := params[i]
+			if current == nil {
+				continue
+			}
+
+			// Get the actual parameter (unwrap if it's a parameter property)
+			param := current
+			if current.Kind == ast.KindParameter {
+				p := current.AsParameterDeclaration()
+				if p != nil && p.Name() != nil {
+					// Check if parameter has modifiers (public/private/protected/readonly)
+					// which would make it a parameter property
+					hasModifiers := ast.GetCombinedModifierFlags(current)&(ast.ModifierFlagsPublic|ast.ModifierFlagsPrivate|ast.ModifierFlagsProtected|ast.ModifierFlagsReadonly) != 0
+					if hasModifiers {
+						// For parameter properties, check the parameter itself
+						param = current
+					}
+				}
+			}
+
+			// Skip rest parameters - they can come after defaults
+			if isRestParam(param) {
+				continue
+			}
+
+			if isPlainParam(param) {
+				hasSeenPlainParam = true
+				continue
+			}
+
+			// Check if this is a default or optional parameter that comes before a plain parameter
+			if hasSeenPlainParam {
+				if param.Kind == ast.KindParameter {
+					paramDecl := param.AsParameterDeclaration()
+					isDefaultParam := paramDecl != nil && paramDecl.Initializer != nil
+					isOptional := isOptionalParam(param)
+
+					if isDefaultParam || isOptional {
+						ctx.ReportNode(current, rule.RuleMessage{
+							Id:          "shouldBeLast",
+							Description: "Default parameters should be last.",
+						})
+					}
+				}
+			}
+		}
+	}
+
+	return rule.RuleListeners{
+		ast.KindFunctionDeclaration: checkDefaultParamLast,
+		ast.KindFunctionExpression:  checkDefaultParamLast,
+		ast.KindArrowFunction:       checkDefaultParamLast,
+		ast.KindMethodDeclaration:   checkDefaultParamLast,
+		ast.KindConstructor:         checkDefaultParamLast,
+	}
+}

internal/plugins/typescript/rules/default_param_last/default_param_last_test.go

@@ -0,0 +1,200 @@
+package default_param_last
+
+import (
+	"testing"
+
+	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/fixtures"
+	"github.com/web-infra-dev/rslint/internal/rule_tester"
+)
+
+func TestDefaultParamLastRule(t *testing.T) {
+	rule_tester.RunRuleTester(fixtures.GetRootDir(), "tsconfig.json", t, &DefaultParamLastRule, []rule_tester.ValidTestCase{
+		// Valid: no parameters
+		{Code: `function f() {}`},
+
+		// Valid: only required parameters
+		{Code: `function f(a: number) {}`},
+		{Code: `function f(a: number, b: number) {}`},
+
+		// Valid: default parameters at the end
+		{Code: `function f(a = 0) {}`},
+		{Code: `function f(a: number, b = 0) {}`},
+		{Code: `function f(a: number, b: number, c = 0) {}`},
+
+		// Valid: optional parameters at the end
+		{Code: `function f(a: number, b?: number) {}`},
+		{Code: `function f(a: number, b?: number, c?: number) {}`},
+
+		// Valid: both optional and default at the end
+		{Code: `function f(a: number, b?: number, c = 0) {}`},
+		{Code: `function f(a: number, b = 0, c?: number) {}`},
+
+		// Valid: rest parameter after defaults
+		{Code: `function f(a: number, b = 0, ...c: number[]) {}`},
+
+		// Valid: arrow functions
+		{Code: `const f = (a: number, b = 0) => {}`},
+		{Code: `const f = (a: number, b?: number) => {}`},
+
+		// Valid: function expressions
+		{Code: `const f = function(a: number, b = 0) {}`},
+		{Code: `const f = function(a: number, b?: number) {}`},
+
+		// Valid: methods
+		{Code: `class A { method(a: number, b = 0) {} }`},
+		{Code: `class A { method(a: number, b?: number) {} }`},
+
+		// Valid: constructors
+		{Code: `class A { constructor(a: number, b = 0) {} }`},
+		{Code: `class A { constructor(a: number, b?: number) {} }`},
+
+		// Valid: parameter properties
+		{Code: `class A { constructor(public a: number, public b = 0) {} }`},
+		{Code: `class A { constructor(private a: number, public b?: number) {} }`},
+
+		// Valid: destructuring with defaults at the end
+		{Code: `function f(a: number, { b } = { b: 0 }) {}`},
+		{Code: `function f(a: number, [b] = [0]) {}`},
+
+		// Valid: multiple defaults at the end
+		{Code: `function f(a: number, b = 0, c = 1) {}`},
+		{Code: `function f(a: number, b = 0, c = 1, d = 2) {}`},
+
+		// Valid: all parameters have defaults
+		{Code: `function f(a = 0, b = 1, c = 2) {}`},
+
+		// Valid: all parameters are optional
+		{Code: `function f(a?: number, b?: number, c?: number) {}`},
+	}, []rule_tester.InvalidTestCase{
+		// Invalid: default before required
+		{
+			Code: `function f(a = 0, b: number) {}`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "shouldBeLast"},
+			},
+		},
+
+		// Invalid: optional before required
+		{
+			Code: `function f(a?: number, b: number) {}`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "shouldBeLast"},
+			},
+		},
+
+		// Invalid: default in the middle
+		{
+			Code: `function f(a: number, b = 0, c: number) {}`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "shouldBeLast"},
+			},
+		},
+
+		// Invalid: optional in the middle
+		{
+			Code: `function f(a: number, b?: number, c: number) {}`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "shouldBeLast"},
+			},
+		},
+
+		// Invalid: multiple violations
+		{
+			Code: `function f(a = 0, b: number, c = 1, d: number) {}`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "shouldBeLast"},
+				{MessageId: "shouldBeLast"},
+			},
+		},
+
+		// Invalid: arrow function
+		{
+			Code: `const f = (a = 0, b: number) => {}`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "shouldBeLast"},
+			},
+		},
+
+		// Invalid: function expression
+		{
+			Code: `const f = function(a = 0, b: number) {}`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "shouldBeLast"},
+			},
+		},
+
+		// Invalid: method
+		{
+			Code: `class A { method(a = 0, b: number) {} }`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "shouldBeLast"},
+			},
+		},
+
+		// Invalid: constructor
+		{
+			Code: `class A { constructor(a = 0, b: number) {} }`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "shouldBeLast"},
+			},
+		},
+
+		// Invalid: parameter properties
+		{
+			Code: `class A { constructor(public a = 0, private b: number) {} }`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "shouldBeLast"},
+			},
+		},
+
+		// Invalid: optional parameter property before required
+		{
+			Code: `class A { constructor(public a?: number, private b: number) {} }`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "shouldBeLast"},
+			},
+		},
+
+		// Invalid: destructuring with default before required
+		{
+			Code: `function f({ a } = { a: 0 }, b: number) {}`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "shouldBeLast"},
+			},
+		},
+
+		// Invalid: array destructuring with default before required
+		{
+			Code: `function f([a] = [0], b: number) {}`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "shouldBeLast"},
+			},
+		},
+
+		// Invalid: mixed defaults and optionals before required
+		{
+			Code: `function f(a = 0, b?: number, c: number) {}`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "shouldBeLast"},
+				{MessageId: "shouldBeLast"},
+			},
+		},
+
+		// Invalid: optional before required in arrow function
+		{
+			Code: `const f = (a?: number, b: number) => {}`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "shouldBeLast"},
+			},
+		},
+
+		// Invalid: default after optional before required
+		{
+			Code: `function f(a?: number, b = 0, c: number) {}`,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "shouldBeLast"},
+				{MessageId: "shouldBeLast"},
+			},
+		},
+	})
+}