feat: port rule no-empty-character-class

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_empty_character_class"
 )
 
 // 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-empty-character-class", no_empty_character_class.NoEmptyCharacterClassRule)
 }
 
 // getAllTypeScriptEslintPluginRules returns all rules from the global registry.

internal/rules/no_empty_character_class/no_empty_character_class.go

@@ -0,0 +1,101 @@
+package no_empty_character_class
+
+import (
+	"strings"
+
+	"github.com/microsoft/typescript-go/shim/ast"
+	"github.com/web-infra-dev/rslint/internal/rule"
+)
+
+// https://eslint.org/docs/latest/rules/no-empty-character-class
+var NoEmptyCharacterClassRule = rule.Rule{
+	Name: "no-empty-character-class",
+	Run: func(ctx rule.RuleContext, options any) rule.RuleListeners {
+		return rule.RuleListeners{
+			ast.KindRegularExpressionLiteral: func(node *ast.Node) {
+				text := node.Text()
+				pattern := extractPattern(text)
+				if hasEmptyCharacterClass(pattern) {
+					ctx.ReportNode(node, rule.RuleMessage{
+						Id:          "unexpected",
+						Description: "Empty class.",
+					})
+				}
+			},
+		}
+	},
+}
+
+// extractPattern extracts the regex pattern from a RegularExpressionLiteral text.
+// The text is in the form /pattern/flags, so we strip the leading / and trailing /flags.
+func extractPattern(text string) string {
+	if len(text) < 2 || text[0] != '/' {
+		return ""
+	}
+	// Find the last '/' which separates the pattern from flags
+	lastSlash := strings.LastIndex(text[1:], "/")
+	if lastSlash == -1 {
+		return text[1:]
+	}
+	return text[1 : lastSlash+1]
+}
+
+// hasEmptyCharacterClass scans the regex pattern for empty character classes [].
+// It uses a simple state machine:
+//   - outside: normal scanning
+//   - insideStart: just entered a character class with [
+//   - insideAfterCaret: inside a negated class [^, next char decides
+//   - inside: inside a character class, waiting for ]
+func hasEmptyCharacterClass(pattern string) bool {
+	const (
+		outside          = 0
+		insideStart      = 1
+		insideAfterCaret = 2
+		inside           = 3
+	)
+
+	state := outside
+	i := 0
+	for i < len(pattern) {
+		ch := pattern[i]
+		switch state {
+		case outside:
+			if ch == '\\' {
+				// Skip escaped character
+				i += 2
+				continue
+			}
+			if ch == '[' {
+				state = insideStart
+			}
+		case insideStart:
+			if ch == ']' {
+				// Found empty character class []
+				return true
+			}
+			if ch == '^' {
+				state = insideAfterCaret
+			} else {
+				state = inside
+			}
+		case insideAfterCaret:
+			if ch == ']' {
+				// This is [^], which is allowed (matches any character)
+				state = outside
+			} else {
+				state = inside
+			}
+		case inside:
+			if ch == '\\' {
+				// Skip escaped character inside class
+				i += 2
+				continue
+			}
+			if ch == ']' {
+				state = outside
+			}
+		}
+		i++
+	}
+	return false
+}

internal/rules/no_empty_character_class/no_empty_character_class.md

@@ -0,0 +1,26 @@
+# no-empty-character-class
+
+## Rule Details
+
+Disallows empty character classes `[]` in regular expression literals. An empty character class in a regular expression does not match anything and is almost certainly a mistake. Note that `[^]` (a negated empty class) is allowed since it matches any character.
+
+Examples of **incorrect** code for this rule:
+
+```javascript
+var foo = /^abc[]/;
+var foo = /foo[]bar/;
+var foo = /[]]/;
+```
+
+Examples of **correct** code for this rule:
+
+```javascript
+var foo = /^abc[a-zA-Z]/;
+var foo = /[^]/;
+var foo = /[\\[]/;
+var foo = /\\[]/;
+```
+
+## Original Documentation
+
+- [ESLint no-empty-character-class](https://eslint.org/docs/latest/rules/no-empty-character-class)

internal/rules/no_empty_character_class/no_empty_character_class_test.go

@@ -0,0 +1,54 @@
+package no_empty_character_class
+
+import (
+	"testing"
+
+	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/fixtures"
+	"github.com/web-infra-dev/rslint/internal/rule_tester"
+)
+
+func TestNoEmptyCharacterClassRule(t *testing.T) {
+	rule_tester.RunRuleTester(
+		fixtures.GetRootDir(),
+		"tsconfig.json",
+		t,
+		&NoEmptyCharacterClassRule,
+		// Valid cases - ported from ESLint
+		[]rule_tester.ValidTestCase{
+			{Code: `var foo = /^abc[a-zA-Z]/;`},
+			{Code: `var regExp = new RegExp("^abc[]");`},
+			{Code: `var foo = /^abc/;`},
+			{Code: `var foo = /[\[]/;`},
+			{Code: `var foo = /[\]]/;`},
+			{Code: `var foo = /[^]/;`},
+			{Code: `var foo = /\[]/`},
+		},
+		// Invalid cases - ported from ESLint
+		[]rule_tester.InvalidTestCase{
+			{
+				Code: `var foo = /^abc[]/;`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{MessageId: "unexpected", Line: 1, Column: 11},
+				},
+			},
+			{
+				Code: `var foo = /foo[]bar/;`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{MessageId: "unexpected", Line: 1, Column: 11},
+				},
+			},
+			{
+				Code: `var foo = /[]]/;`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{MessageId: "unexpected", Line: 1, Column: 11},
+				},
+			},
+			{
+				Code: `var foo = /\[[]/;`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{MessageId: "unexpected", Line: 1, Column: 11},
+				},
+			},
+		},
+	)
+}

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-empty-character-class.test.ts',
 
     // eslint-plugin-import
     './tests/eslint-plugin-import/rules/no-self-import.test.ts',

packages/rslint-test-tools/tests/eslint/rules/__snapshots__/no-empty-character-class.test.ts.snap

@@ -0,0 +1,53 @@
+// Rstest Snapshot v1
+
+exports[`no-empty-character-class > invalid 1`] = `
+{
+  "code": "var foo = /^abc[]/;",
+  "diagnostics": [
+    {
+      "message": "Empty class.",
+      "messageId": "unexpected",
+      "range": {
+        "end": {
+          "column": 19,
+          "line": 1,
+        },
+        "start": {
+          "column": 11,
+          "line": 1,
+        },
+      },
+      "ruleName": "no-empty-character-class",
+    },
+  ],
+  "errorCount": 1,
+  "fileCount": 1,
+  "ruleCount": 1,
+}
+`;
+
+exports[`no-empty-character-class > invalid 2`] = `
+{
+  "code": "var foo = /foo[]bar/;",
+  "diagnostics": [
+    {
+      "message": "Empty class.",
+      "messageId": "unexpected",
+      "range": {
+        "end": {
+          "column": 21,
+          "line": 1,
+        },
+        "start": {
+          "column": 11,
+          "line": 1,
+        },
+      },
+      "ruleName": "no-empty-character-class",
+    },
+  ],
+  "errorCount": 1,
+  "fileCount": 1,
+  "ruleCount": 1,
+}
+`;

packages/rslint-test-tools/tests/eslint/rules/no-empty-character-class.test.ts

@@ -0,0 +1,17 @@
+import { RuleTester } from '../rule-tester';
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('no-empty-character-class', {
+  valid: ['var foo = /^abc[a-zA-Z]/;', 'var foo = /[^]/;'],
+  invalid: [
+    {
+      code: 'var foo = /^abc[]/;',
+      errors: [{ messageId: 'unexpected' }],
+    },
+    {
+      code: 'var foo = /foo[]bar/;',
+      errors: [{ messageId: 'unexpected' }],
+    },
+  ],
+});