@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

package/linthost/rules_regexp.go

@@ -0,0 +1,410 @@
+package linthost
+
+import (
+	"sort"
+	"strconv"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// regexpSourceRule implements the high-confidence, source-text subset of
+// eslint-plugin-regexp. The first wave intentionally targets regex literals
+// only: TypeScript-Go has already parsed those successfully, so these checks can
+// stay AST-only and avoid pretending to evaluate arbitrary `RegExp(...)`
+// constructor strings.
+type regexpSourceRule struct {
+	name  string
+	check func(regexpLiteralParts) bool
+}
+
+type regexpLiteralParts struct {
+	raw     string
+	pattern string
+	flags   string
+}
+
+func (r regexpSourceRule) Name() string { return r.name }
+func (regexpSourceRule) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindRegularExpressionLiteral}
+}
+func (r regexpSourceRule) Check(ctx *Context, node *shimast.Node) {
+	parts, ok := parseRegexpLiteralParts(ctx, node)
+	if !ok || r.check == nil || !r.check(parts) {
+		return
+	}
+	ctx.Report(node, regexpRuleMessage(r.name))
+}
+
+type regexpNoUselessEscapeAlias struct{}
+
+func (regexpNoUselessEscapeAlias) Name() string { return "regexp/no-useless-escape" }
+func (regexpNoUselessEscapeAlias) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindRegularExpressionLiteral}
+}
+func (regexpNoUselessEscapeAlias) Check(ctx *Context, node *shimast.Node) {
+	pos, end := tokenRange(ctx.File, node)
+	if pos < 0 {
+		return
+	}
+	reportRegexEscapes(ctx, ctx.File.Text()[pos:end], pos)
+}
+
+func parseRegexpLiteralParts(ctx *Context, node *shimast.Node) (regexpLiteralParts, bool) {
+	raw := nodeText(ctx.File, node)
+	if len(raw) < 2 || raw[0] != '/' {
+		return regexpLiteralParts{}, false
+	}
+	closing := strings.LastIndexByte(raw, '/')
+	if closing <= 0 {
+		return regexpLiteralParts{}, false
+	}
+	return regexpLiteralParts{
+		raw:     raw,
+		pattern: raw[1:closing],
+		flags:   raw[closing+1:],
+	}, true
+}
+
+func regexpRuleMessage(name string) string {
+	switch name {
+	case "regexp/no-control-character":
+		return "Unexpected control character in regular expression."
+	case "regexp/no-dupe-characters-character-class":
+		return "Unexpected duplicate character in character class."
+	case "regexp/no-empty-alternative":
+		return "Unexpected empty alternative."
+	case "regexp/no-empty-capturing-group":
+		return "Unexpected empty capturing group."
+	case "regexp/no-empty-character-class":
+		return "Unexpected empty character class."
+	case "regexp/no-empty-group":
+		return "Unexpected empty group."
+	case "regexp/no-empty-lookarounds-assertion":
+		return "Unexpected empty lookaround assertion."
+	case "regexp/no-misleading-unicode-character":
+		return "Unexpected misleading Unicode character in character class."
+	case "regexp/no-useless-character-class":
+		return "Unexpected character class with one character."
+	case "regexp/no-useless-flag":
+		return "Unexpected useless regular expression flag."
+	case "regexp/no-useless-quantifier":
+		return "Unexpected useless quantifier."
+	case "regexp/no-useless-two-nums-quantifier":
+		return "Unexpected quantifier with equal minimum and maximum."
+	case "regexp/no-zero-quantifier":
+		return "Unexpected quantifier that repeats zero times."
+	case "regexp/prefer-d":
+		return "Prefer \\d over [0-9]."
+	case "regexp/prefer-plus-quantifier":
+		return "Prefer + over {1,}."
+	case "regexp/prefer-question-quantifier":
+		return "Prefer ? over {0,1}."
+	case "regexp/prefer-star-quantifier":
+		return "Prefer * over {0,}."
+	case "regexp/prefer-w":
+		return "Prefer \\w over [A-Za-z0-9_]."
+	case "regexp/require-unicode-regexp":
+		return "Regular expression should use the u or v flag."
+	case "regexp/require-unicode-sets-regexp":
+		return "Regular expression should use the v flag."
+	case "regexp/sort-flags":
+		return "Regular expression flags should be sorted."
+	default:
+		return "Unexpected regular expression pattern."
+	}
+}
+
+func regexpHasEmptyAlternative(parts regexpLiteralParts) bool {
+	return scanRegexpPattern(parts.pattern, func(pattern string, i int) bool {
+		if pattern[i] != '|' {
+			return false
+		}
+		return i == 0 || i == len(pattern)-1 || pattern[i-1] == '|' || pattern[i-1] == '(' || pattern[i+1] == '|' || pattern[i+1] == ')'
+	})
+}
+
+func regexpHasEmptyCapturingGroup(parts regexpLiteralParts) bool {
+	return scanRegexpPattern(parts.pattern, func(pattern string, i int) bool {
+		return pattern[i] == '(' && i+1 < len(pattern) && pattern[i+1] == ')'
+	})
+}
+
+func regexpHasEmptyGroup(parts regexpLiteralParts) bool {
+	return scanRegexpPattern(parts.pattern, func(pattern string, i int) bool {
+		return strings.HasPrefix(pattern[i:], "(?:)")
+	})
+}
+
+func regexpHasEmptyLookaround(parts regexpLiteralParts) bool {
+	return scanRegexpPattern(parts.pattern, func(pattern string, i int) bool {
+		return strings.HasPrefix(pattern[i:], "(?=)") ||
+			strings.HasPrefix(pattern[i:], "(?!)") ||
+			strings.HasPrefix(pattern[i:], "(?<=)") ||
+			strings.HasPrefix(pattern[i:], "(?<!)")
+	})
+}
+
+func regexpHasZeroQuantifier(parts regexpLiteralParts) bool {
+	return scanRegexpQuantifiers(parts.pattern, func(min, max int, hasComma bool) bool {
+		return min == 0 && (!hasComma || max == 0)
+	})
+}
+
+func regexpHasUselessTwoNumsQuantifier(parts regexpLiteralParts) bool {
+	return scanRegexpQuantifiers(parts.pattern, func(min, max int, hasComma bool) bool {
+		return hasComma && min == max && min >= 0
+	})
+}
+
+func regexpHasUselessQuantifier(parts regexpLiteralParts) bool {
+	return scanRegexpQuantifiers(parts.pattern, func(min, max int, hasComma bool) bool {
+		return !hasComma && min == 1 && max == -1
+	})
+}
+
+func regexpHasPlusQuantifierCandidate(parts regexpLiteralParts) bool {
+	return scanRegexpQuantifiers(parts.pattern, func(min, max int, hasComma bool) bool {
+		return hasComma && min == 1 && max == -1
+	})
+}
+
+func regexpHasStarQuantifierCandidate(parts regexpLiteralParts) bool {
+	return scanRegexpQuantifiers(parts.pattern, func(min, max int, hasComma bool) bool {
+		return hasComma && min == 0 && max == -1
+	})
+}
+
+func regexpHasQuestionQuantifierCandidate(parts regexpLiteralParts) bool {
+	return scanRegexpQuantifiers(parts.pattern, func(min, max int, hasComma bool) bool {
+		return hasComma && min == 0 && max == 1
+	})
+}
+
+func regexpNeedsUnicodeFlag(parts regexpLiteralParts) bool {
+	return !strings.ContainsAny(parts.flags, "uv")
+}
+
+func regexpNeedsUnicodeSetsFlag(parts regexpLiteralParts) bool {
+	return !strings.Contains(parts.flags, "v")
+}
+
+func regexpFlagsUnsorted(parts regexpLiteralParts) bool {
+	sorted := []byte(parts.flags)
+	sort.SliceStable(sorted, func(i, j int) bool {
+		return regexpFlagOrder(sorted[i]) < regexpFlagOrder(sorted[j])
+	})
+	return string(sorted) != parts.flags
+}
+
+func regexpFlagOrder(flag byte) int {
+	const order = "dgimsuvy"
+	if i := strings.IndexByte(order, flag); i >= 0 {
+		return i
+	}
+	return len(order) + int(flag)
+}
+
+func regexpHasUselessFlag(parts regexpLiteralParts) bool {
+	if strings.Contains(parts.flags, "i") && !regexpPatternHasAsciiLetter(parts.pattern) {
+		return true
+	}
+	if strings.Contains(parts.flags, "m") && !regexpPatternHasLineAnchor(parts.pattern) {
+		return true
+	}
+	return false
+}
+
+func regexpHasPreferD(parts regexpLiteralParts) bool {
+	return strings.Contains(parts.pattern, "[0-9]")
+}
+
+func regexpHasPreferW(parts regexpLiteralParts) bool {
+	return strings.Contains(parts.pattern, "[A-Za-z0-9_]") || strings.Contains(parts.pattern, "[a-zA-Z0-9_]")
+}
+
+func regexpHasDuplicateClassCharacter(parts regexpLiteralParts) bool {
+	return walkRegexpCharacterClasses(parts.pattern, func(content string) bool {
+		if classHasRange(content) {
+			return false
+		}
+		seen := map[byte]struct{}{}
+		for i := 0; i < len(content); i++ {
+			ch := content[i]
+			if ch == '\\' {
+				i++
+				continue
+			}
+			if ch == '^' && i == 0 {
+				continue
+			}
+			if ch == '-' {
+				continue
+			}
+			if _, ok := seen[ch]; ok {
+				return true
+			}
+			seen[ch] = struct{}{}
+		}
+		return false
+	})
+}
+
+func regexpHasUselessCharacterClass(parts regexpLiteralParts) bool {
+	return walkRegexpCharacterClasses(parts.pattern, func(content string) bool {
+		if len(content) != 1 {
+			return false
+		}
+		ch := content[0]
+		return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9')
+	})
+}
+
+func scanRegexpPattern(pattern string, visit func(pattern string, i int) bool) bool {
+	inClass := false
+	for i := 0; i < len(pattern); i++ {
+		switch pattern[i] {
+		case '\\':
+			i++
+		case '[':
+			if !inClass {
+				inClass = true
+			}
+		case ']':
+			inClass = false
+		default:
+			if !inClass && visit(pattern, i) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func scanRegexpQuantifiers(pattern string, visit func(min, max int, hasComma bool) bool) bool {
+	return scanRegexpPattern(pattern, func(pattern string, i int) bool {
+		if pattern[i] != '{' {
+			return false
+		}
+		end := i + 1
+		for end < len(pattern) && pattern[end] != '}' {
+			end++
+		}
+		if end >= len(pattern) {
+			return false
+		}
+		body := pattern[i+1 : end]
+		hasComma := strings.Contains(body, ",")
+		min, max := -1, -1
+		if hasComma {
+			pair := strings.SplitN(body, ",", 2)
+			min = parseRegexpQuantifierNumber(pair[0])
+			if pair[1] != "" {
+				max = parseRegexpQuantifierNumber(pair[1])
+			}
+		} else {
+			min = parseRegexpQuantifierNumber(body)
+		}
+		return min >= 0 && visit(min, max, hasComma)
+	})
+}
+
+func parseRegexpQuantifierNumber(text string) int {
+	if text == "" {
+		return -1
+	}
+	for i := 0; i < len(text); i++ {
+		if text[i] < '0' || text[i] > '9' {
+			return -1
+		}
+	}
+	value, err := strconv.Atoi(text)
+	if err != nil {
+		return -1
+	}
+	return value
+}
+
+func walkRegexpCharacterClasses(pattern string, visit func(content string) bool) bool {
+	for i := 0; i < len(pattern); i++ {
+		if pattern[i] == '\\' {
+			i++
+			continue
+		}
+		if pattern[i] != '[' {
+			continue
+		}
+		start := i + 1
+		for j := start; j < len(pattern); j++ {
+			if pattern[j] == '\\' {
+				j++
+				continue
+			}
+			if pattern[j] == ']' {
+				if visit(pattern[start:j]) {
+					return true
+				}
+				i = j
+				break
+			}
+		}
+	}
+	return false
+}
+
+func classHasRange(content string) bool {
+	for i := 1; i+1 < len(content); i++ {
+		if content[i] == '\\' {
+			i++
+			continue
+		}
+		if content[i] == '-' {
+			return true
+		}
+	}
+	return false
+}
+
+func regexpPatternHasAsciiLetter(pattern string) bool {
+	return scanRegexpPattern(pattern, func(pattern string, i int) bool {
+		ch := pattern[i]
+		return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')
+	})
+}
+
+func regexpPatternHasLineAnchor(pattern string) bool {
+	return scanRegexpPattern(pattern, func(pattern string, i int) bool {
+		return pattern[i] == '^' || pattern[i] == '$'
+	})
+}
+
+func init() {
+	Register(regexpSourceRule{name: "regexp/no-control-character", check: func(parts regexpLiteralParts) bool {
+		return regexContainsControl(parts.raw)
+	}})
+	Register(regexpSourceRule{name: "regexp/no-dupe-characters-character-class", check: regexpHasDuplicateClassCharacter})
+	Register(regexpSourceRule{name: "regexp/no-empty-alternative", check: regexpHasEmptyAlternative})
+	Register(regexpSourceRule{name: "regexp/no-empty-capturing-group", check: regexpHasEmptyCapturingGroup})
+	Register(regexpSourceRule{name: "regexp/no-empty-character-class", check: func(parts regexpLiteralParts) bool {
+		return hasEmptyCharClass(parts.raw)
+	}})
+	Register(regexpSourceRule{name: "regexp/no-empty-group", check: regexpHasEmptyGroup})
+	Register(regexpSourceRule{name: "regexp/no-empty-lookarounds-assertion", check: regexpHasEmptyLookaround})
+	Register(regexpSourceRule{name: "regexp/no-misleading-unicode-character", check: func(parts regexpLiteralParts) bool {
+		return regexHasSurrogatePair(parts.raw)
+	}})
+	Register(regexpSourceRule{name: "regexp/no-useless-character-class", check: regexpHasUselessCharacterClass})
+	Register(regexpNoUselessEscapeAlias{})
+	Register(regexpSourceRule{name: "regexp/no-useless-flag", check: regexpHasUselessFlag})
+	Register(regexpSourceRule{name: "regexp/no-useless-quantifier", check: regexpHasUselessQuantifier})
+	Register(regexpSourceRule{name: "regexp/no-useless-two-nums-quantifier", check: regexpHasUselessTwoNumsQuantifier})
+	Register(regexpSourceRule{name: "regexp/no-zero-quantifier", check: regexpHasZeroQuantifier})
+	Register(regexpSourceRule{name: "regexp/prefer-d", check: regexpHasPreferD})
+	Register(regexpSourceRule{name: "regexp/prefer-plus-quantifier", check: regexpHasPlusQuantifierCandidate})
+	Register(regexpSourceRule{name: "regexp/prefer-question-quantifier", check: regexpHasQuestionQuantifierCandidate})
+	Register(regexpSourceRule{name: "regexp/prefer-star-quantifier", check: regexpHasStarQuantifierCandidate})
+	Register(regexpSourceRule{name: "regexp/prefer-w", check: regexpHasPreferW})
+	Register(regexpSourceRule{name: "regexp/require-unicode-regexp", check: regexpNeedsUnicodeFlag})
+	Register(regexpSourceRule{name: "regexp/require-unicode-sets-regexp", check: regexpNeedsUnicodeSetsFlag})
+	Register(regexpSourceRule{name: "regexp/sort-flags", check: regexpFlagsUnsorted})
+}