feat: port rule no-var

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_var"
 )
 
 // 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-var", no_var.NoVarRule)
 }
 
 // getAllTypeScriptEslintPluginRules returns all rules from the global registry.

internal/rules/no_var/no_var.go

@@ -0,0 +1,59 @@
+package no_var
+
+import (
+	"github.com/microsoft/typescript-go/shim/ast"
+	"github.com/web-infra-dev/rslint/internal/rule"
+)
+
+// https://eslint.org/docs/latest/rules/no-var
+var NoVarRule = rule.Rule{
+	Name: "no-var",
+	Run: func(ctx rule.RuleContext, options any) rule.RuleListeners {
+		return rule.RuleListeners{
+			ast.KindVariableDeclarationList: func(node *ast.Node) {
+				// BlockScoped = Let | Const | Using | AwaitUsing
+				// If none of those flags are set, it's a var declaration.
+				if node.Flags&ast.NodeFlagsBlockScoped != 0 {
+					return
+				}
+
+				// Skip var inside `declare global { var ... }` (TypeScript ambient context)
+				if isInDeclareGlobal(node) {
+					return
+				}
+
+				// Report on the VariableStatement parent if it exists (for standalone var),
+				// otherwise report on the VariableDeclarationList itself (for-loop initializer).
+				reportNode := node
+				if node.Parent != nil && node.Parent.Kind == ast.KindVariableStatement {
+					reportNode = node.Parent
+				}
+
+				ctx.ReportNode(reportNode, rule.RuleMessage{
+					Id:          "unexpectedVar",
+					Description: "Unexpected var, use let or const instead.",
+				})
+			},
+		}
+	},
+}
+
+// isInDeclareGlobal checks if a node is inside a `declare global { }` block.
+func isInDeclareGlobal(node *ast.Node) bool {
+	current := node.Parent
+	for current != nil {
+		if current.Kind == ast.KindModuleBlock {
+			// Check if the parent ModuleDeclaration is `declare global`
+			parent := current.Parent
+			if parent != nil && parent.Kind == ast.KindModuleDeclaration {
+				modDecl := parent.AsModuleDeclaration()
+				if modDecl != nil && modDecl.Name() != nil &&
+					modDecl.Name().Kind == ast.KindGlobalKeyword {
+					return true
+				}
+			}
+		}
+		current = current.Parent
+	}
+	return false
+}

internal/rules/no_var/no_var.md

@@ -0,0 +1,23 @@
+# no-var
+
+## Rule Details
+
+Requires `let` or `const` instead of `var`. ECMAScript 6 introduced `let` and `const` as alternatives to `var` for variable declarations. `let` and `const` provide block scoping, which helps avoid common issues caused by the function scoping of `var`.
+
+Examples of **incorrect** code for this rule:
+
+```javascript
+var x = 'y';
+var CONFIG = {};
+```
+
+Examples of **correct** code for this rule:
+
+```javascript
+let x = 'y';
+const CONFIG = {};
+```
+
+## Original Documentation
+
+- [ESLint no-var](https://eslint.org/docs/latest/rules/no-var)

internal/rules/no_var/no_var_test.go

@@ -0,0 +1,77 @@
+package no_var
+
+import (
+	"testing"
+
+	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/fixtures"
+	"github.com/web-infra-dev/rslint/internal/rule_tester"
+)
+
+func TestNoVarRule(t *testing.T) {
+	rule_tester.RunRuleTester(
+		fixtures.GetRootDir(),
+		"tsconfig.json",
+		t,
+		&NoVarRule,
+		// Valid cases - ported from ESLint
+		[]rule_tester.ValidTestCase{
+			{Code: `const JOE = 'schmoe';`},
+			{Code: `let moo = 'car';`},
+			{Code: `const JOE = 'schmoe'; let moo = 'car';`},
+			{Code: `for (let i = 0; i < 10; i++) {}`},
+			{Code: `for (const x of [1,2]) {}`},
+		},
+		// Invalid cases - ported from ESLint
+		[]rule_tester.InvalidTestCase{
+			{
+				Code: `var foo = bar;`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{MessageId: "unexpectedVar", Line: 1, Column: 1},
+				},
+			},
+			{
+				Code: `var foo = bar, toast = most;`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{MessageId: "unexpectedVar", Line: 1, Column: 1},
+				},
+			},
+			{
+				Code: `var foo = bar; var baz = quux;`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{MessageId: "unexpectedVar", Line: 1, Column: 1},
+					{MessageId: "unexpectedVar", Line: 1, Column: 16},
+				},
+			},
+			{
+				Code: `if (true) { var x = 1; }`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{MessageId: "unexpectedVar", Line: 1, Column: 13},
+				},
+			},
+
+			// for-loop initializer
+			{
+				Code: `for (var i = 0; i < 10; i++) {}`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{MessageId: "unexpectedVar", Line: 1, Column: 6},
+				},
+			},
+
+			// for-in
+			{
+				Code: `for (var x in obj) {}`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{MessageId: "unexpectedVar", Line: 1, Column: 6},
+				},
+			},
+
+			// for-of
+			{
+				Code: `for (var x of [1,2]) {}`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{MessageId: "unexpectedVar", Line: 1, Column: 6},
+				},
+			},
+		},
+	)
+}

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

@@ -21,6 +21,7 @@ export default defineConfig({
     './tests/eslint/rules/getter-return.test.ts',
     './tests/eslint/rules/no-loss-of-precision.test.ts',
 
+    './tests/eslint/rules/no-var.test.ts',
     // eslint-plugin-import
     './tests/eslint-plugin-import/rules/no-self-import.test.ts',
     './tests/eslint-plugin-import/rules/no-webpack-loader-syntax.test.ts',

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

@@ -0,0 +1,53 @@
+// Rstest Snapshot v1
+
+exports[`no-var > invalid 1`] = `
+{
+  "code": "var foo = bar;",
+  "diagnostics": [
+    {
+      "message": "Unexpected var, use let or const instead.",
+      "messageId": "unexpectedVar",
+      "range": {
+        "end": {
+          "column": 15,
+          "line": 1,
+        },
+        "start": {
+          "column": 1,
+          "line": 1,
+        },
+      },
+      "ruleName": "no-var",
+    },
+  ],
+  "errorCount": 1,
+  "fileCount": 1,
+  "ruleCount": 1,
+}
+`;
+
+exports[`no-var > invalid 2`] = `
+{
+  "code": "var foo = bar, toast = most;",
+  "diagnostics": [
+    {
+      "message": "Unexpected var, use let or const instead.",
+      "messageId": "unexpectedVar",
+      "range": {
+        "end": {
+          "column": 29,
+          "line": 1,
+        },
+        "start": {
+          "column": 1,
+          "line": 1,
+        },
+      },
+      "ruleName": "no-var",
+    },
+  ],
+  "errorCount": 1,
+  "fileCount": 1,
+  "ruleCount": 1,
+}
+`;

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

@@ -0,0 +1,21 @@
+import { RuleTester } from '../rule-tester';
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('no-var', {
+  valid: [
+    "const JOE = 'schmoe';",
+    "let moo = 'car';",
+    'const a = 1; let b = 2;',
+  ],
+  invalid: [
+    {
+      code: 'var foo = bar;',
+      errors: [{ messageId: 'unexpectedVar' }],
+    },
+    {
+      code: 'var foo = bar, toast = most;',
+      errors: [{ messageId: 'unexpectedVar' }],
+    },
+  ],
+});

rslint.json

@@ -57,7 +57,8 @@
       "@typescript-eslint/prefer-includes": "off",
       "@typescript-eslint/prefer-regexp-exec": "off",
       "@typescript-eslint/prefer-ts-expect-error": "off",
-      "no-console": "warn"
+      "no-console": "warn",
+      "no-var": "off"
     },
     "plugins": ["@typescript-eslint"]
   }