@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

package/linthost/rules_default_case.go

@@ -0,0 +1,39 @@
+// defaultCase: a `switch` statement that omits the `default` clause
+// silently drops every discriminant value not matched by an explicit
+// `case` label. The rule wants the catch-all path written out so an
+// unhandled discriminant becomes an intentional branch — even if that
+// branch is a `// no default` comment marker.
+//
+// AST-only: each visited `SwitchStatement` checks its `CaseBlock`
+// clauses for any node of kind `DefaultClause`. The rule reports on the
+// switch keyword itself rather than the case block so the diagnostic
+// lands at the head of the statement.
+// https://eslint.org/docs/latest/rules/default-case
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type defaultCase struct{}
+
+func (defaultCase) Name() string           { return "default-case" }
+func (defaultCase) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSwitchStatement} }
+func (defaultCase) Check(ctx *Context, node *shimast.Node) {
+	sw := node.AsSwitchStatement()
+	if sw == nil || sw.CaseBlock == nil {
+		return
+	}
+	block := sw.CaseBlock.AsCaseBlock()
+	if block == nil || block.Clauses == nil {
+		return
+	}
+	for _, clause := range block.Clauses.Nodes {
+		if clause != nil && clause.Kind == shimast.KindDefaultClause {
+			return
+		}
+	}
+	ctx.Report(node, "Expected a default case.")
+}
+
+func init() {
+	Register(defaultCase{})
+}

package/linthost/rules_default_case_last.go

@@ -0,0 +1,46 @@
+// defaultCaseLast: a `switch` statement whose `default` clause is not
+// the final clause changes fall-through semantics in a way that almost
+// never matches the author's intent — running `default` then falling
+// into `case "b"` is rarely what a misordered switch wants. The rule
+// requires `default` to appear after every `case` label.
+//
+// AST-only: each visited `SwitchStatement` walks its `CaseBlock`
+// clauses, and any `DefaultClause` that is not the last element is
+// reported on the clause itself.
+// https://eslint.org/docs/latest/rules/default-case-last
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type defaultCaseLast struct{}
+
+func (defaultCaseLast) Name() string { return "default-case-last" }
+func (defaultCaseLast) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindSwitchStatement}
+}
+func (defaultCaseLast) Check(ctx *Context, node *shimast.Node) {
+	sw := node.AsSwitchStatement()
+	if sw == nil || sw.CaseBlock == nil {
+		return
+	}
+	block := sw.CaseBlock.AsCaseBlock()
+	if block == nil || block.Clauses == nil {
+		return
+	}
+	clauses := block.Clauses.Nodes
+	if len(clauses) == 0 {
+		return
+	}
+	last := clauses[len(clauses)-1]
+	for i := 0; i < len(clauses)-1; i++ {
+		clause := clauses[i]
+		if clause != nil && clause.Kind == shimast.KindDefaultClause {
+			_ = last
+			ctx.Report(clause, "Default clause should be the last clause.")
+		}
+	}
+}
+
+func init() {
+	Register(defaultCaseLast{})
+}

package/linthost/rules_dupes.go

@@ -2,7 +2,7 @@ package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// no-duplicate-case: duplicated `case` labels in a single switch.
+// noDuplicateCase: duplicated `case` labels in a single switch.
 // https://eslint.org/docs/latest/rules/no-duplicate-case
 type noDuplicateCase struct{}
 
@@ -38,7 +38,7 @@ func (noDuplicateCase) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-dupe-keys: duplicated property names in a single object literal.
+// noDupeKeys: duplicated property names in a single object literal.
 // https://eslint.org/docs/latest/rules/no-dupe-keys
 type noDupeKeys struct{}
 
@@ -63,7 +63,7 @@ func (noDupeKeys) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-dupe-args: duplicated parameter names in a single function head.
+// noDupeArgs: duplicated parameter names in a single function head.
 // https://eslint.org/docs/latest/rules/no-dupe-args
 type noDupeArgs struct{}
 

package/linthost/rules_empty.go

@@ -2,7 +2,7 @@ package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// no-empty: empty block statements (`{}`), but allow empty catch
+// noEmpty: empty block statements (`{}`), but allow empty catch
 // clauses since they're idiomatic for "ignore the error".
 // https://eslint.org/docs/latest/rules/no-empty
 type noEmpty struct{}
@@ -27,7 +27,7 @@ func (noEmpty) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "Empty block statement.")
 }
 
-// no-empty-function: empty function / method / arrow / accessor bodies.
+// noEmptyFunction: empty function / method / arrow / accessor bodies.
 // https://eslint.org/docs/latest/rules/no-empty-function
 type noEmptyFunction struct{}
 
@@ -60,7 +60,7 @@ func (noEmptyFunction) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-empty-pattern: `({}) => x` or `function ({}) {}` — destructuring
+// noEmptyPattern: `({}) => x` or `function ({}) {}` — destructuring
 // patterns with no bindings are usually a bug.
 // https://eslint.org/docs/latest/rules/no-empty-pattern
 type noEmptyPattern struct{}

package/linthost/rules_escape.go

@@ -6,7 +6,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
-// no-useless-escape: flag backslashes that escape characters which do not
+// noUselessEscape: flag backslashes that escape characters which do not
 // require escaping. Inside string/template literals the meaningful
 // escapes are limited to a fixed set; everywhere else the backslash is
 // noise from a copy/paste accident or a confused author. ESLint
@@ -41,13 +41,16 @@ func (noUselessEscape) Check(ctx *Context, node *shimast.Node) {
   if isInsideTaggedTemplate(node) {
     return
   }
-  src := ctx.File.Text()
-  pos := node.Pos()
-  end := node.End()
-  if pos < 0 || end > len(src) || pos >= end {
+  // tsgo's `node.Pos()` points at the start of leading trivia; the regex
+  // scanner relies on `raw[0] == '/'`, so we have to anchor on the
+  // post-trivia token start. String/template scans tolerate leading
+  // trivia bytes by accident, but using `tokenRange` for every branch
+  // keeps reported offsets aligned with the actual literal.
+  pos, end := tokenRange(ctx.File, node)
+  if pos < 0 || pos >= end {
     return
   }
-  raw := src[pos:end]
+  raw := ctx.File.Text()[pos:end]
   // Determine quote/scan delimiters based on node kind so the
   // single-char escape whitelist matches ESLint per-context.
   switch node.Kind {
@@ -66,12 +69,18 @@ func (noUselessEscape) Check(ctx *Context, node *shimast.Node) {
 const stringValidEscapes = "'\"\\bfnrtv0xuU\n\r"
 const templateValidEscapes = "`'\"\\bfnrtv0xuU$\n\r"
 
-// regexValidEscapes covers characters that are *always* meaningful when
-// preceded by `\` in a regex pattern. Character classes and group syntax
-// inside a regex add more legitimate escapes (`\d`, `\w`, …); we handle
-// those by allowing every ASCII letter (which makes the fix conservative
-// — it never deletes a backslash whose meaning could be context-sensitive).
-const regexValidEscapes = "^$\\.*+?()[]{}|/-\n\r"
+// regexNonClassValidEscapes covers characters that are meaningful when
+// preceded by `\` outside a character class — every regex meta-char plus
+// the line terminators. Inside a `[...]` most of these characters lose
+// their special meaning (`.`, `*`, `+`, `?`, `(`, `)`, `{`, `}`, `|`, `$`,
+// `/` are all literal in a class), so the in-class allowlist is narrower:
+// backslash, the class-delimiting `]`, the range operator `-`, and `^`
+// (which would otherwise turn the class into a negation if the escape
+// were stripped). Standard shorthand escapes (`\d`, `\w`, …) and the
+// Unicode/hex/control escapes are handled separately in
+// `isUselessRegexEscape` and apply in both contexts.
+const regexNonClassValidEscapes = "^$\\.*+?()[]{}|/-\n\r"
+const regexClassValidEscapes = "\\]-^\n\r"
 
 // reportStringEscapes walks the raw source bytes of a string or template
 // literal and reports each backslash whose following character is not in
@@ -212,29 +221,40 @@ func isUselessStringEscape(ch byte, whitelist string) bool {
 
 // isUselessRegexEscape reports whether a backslash before `ch` is redundant
 // in a regex pattern. `inClass` is true when the escape occurs inside a `[…]`
-// character class, which widens the set of meaningful escapes.
+// character class, which narrows the set of meaningful meta-char escapes:
+// most regex meta-chars (`.`, `*`, `+`, `?`, `(`, `)`, `{`, `}`, `|`, `^`,
+// `$`, `/`) are literal inside a class, so escaping them there is noise.
 func isUselessRegexEscape(ch byte, inClass bool) bool {
   if ch < 0x20 {
     return false
   }
-  // Regex meta-chars and their friends.
-  if strings.IndexByte(regexValidEscapes, ch) >= 0 {
-    return false
-  }
-  // Inside a character class `]`, `\`, and `-` are still meaningful
-  // beyond the always-list; everything else stays useless.
   if inClass {
-    switch ch {
-    case ']', '\\', '-', 'b':
+    if strings.IndexByte(regexClassValidEscapes, ch) >= 0 {
       return false
     }
+  } else if strings.IndexByte(regexNonClassValidEscapes, ch) >= 0 {
+    return false
   }
-  // Common regex shorthand: \d \D \w \W \s \S \b \B \f \n \r \t \v \0
+  // Common regex shorthand: \d \D \w \W \s \S \b \f \n \r \t \v \0 \x \u \c \p \P,
+  // plus decimal back-references \1..\9. `\B` (non-word-boundary) and `\k<name>`
+  // (named backref) are only meaningful outside a character class; `\q{...}` is
+  // a v-flag string-disjunction escape that is also class-only-meaningful.
   switch ch {
-  case 'd', 'D', 'w', 'W', 's', 'S', 'b', 'B', 'f', 'n', 'r', 't', 'v', '0',
-    'x', 'u', 'c', 'p', 'P', 'k', 'q':
+  case 'd', 'D', 'w', 'W', 's', 'S', 'b', 'f', 'n', 'r', 't', 'v', '0',
+    'x', 'u', 'c', 'p', 'P',
+    '1', '2', '3', '4', '5', '6', '7', '8', '9':
     return false
   }
+  if !inClass {
+    switch ch {
+    case 'B', 'k':
+      return false
+    }
+  } else {
+    if ch == 'q' {
+      return false
+    }
+  }
   return true
 }
 

package/linthost/rules_eval.go

@@ -2,7 +2,7 @@ package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// no-eval: forbid `eval(...)` calls. Members of nested namespaces (e.g.
+// noEval: forbid `eval(...)` calls. Members of nested namespaces (e.g.
 // `globalThis.eval(...)`) are not flagged here — that's
 // `no-implied-eval`, which we don't ship in v0.
 // https://eslint.org/docs/latest/rules/no-eval
@@ -20,7 +20,7 @@ func (noEval) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-script-url: forbid `"javascript:..."` literals. Often used to inject
+// noScriptUrl: forbid `"javascript:..."` literals. Often used to inject
 // inline JS via DOM `href`/`src`; legacy and dangerous.
 // https://eslint.org/docs/latest/rules/no-script-url
 type noScriptURL struct{}

package/linthost/rules_finally.go

@@ -2,7 +2,7 @@ package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// no-unsafe-finally: `return` / `break` / `continue` / `throw` inside a
+// noUnsafeFinally: `return` / `break` / `continue` / `throw` inside a
 // `finally` clause silently overrides the in-flight exception or value.
 // https://eslint.org/docs/latest/rules/no-unsafe-finally
 type noUnsafeFinally struct{}
@@ -83,7 +83,7 @@ func keywordOfControl(node *shimast.Node) string {
   return "control flow"
 }
 
-// no-useless-catch: `catch (err) { throw err; }` adds no behavior.
+// noUselessCatch: `catch (err) { throw err; }` adds no behavior.
 // https://eslint.org/docs/latest/rules/no-useless-catch
 type noUselessCatch struct{}
 

package/linthost/rules_format_jsdoc.go

@@ -5,7 +5,7 @@ import (
   shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
-// format/jsdoc rewrites JSDoc blocks toward the prettier-plugin-jsdoc
+// formatJsdoc rewrites JSDoc blocks toward the prettier-plugin-jsdoc
 // canonical shape. The MVP implementation handles tag-synonym
 // normalization; future passes will fold in tag sorting, @param column
 // alignment, and description wrapping under the same rule name so

package/linthost/rules_format_print_width.go

@@ -7,7 +7,7 @@ import (
   shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
-// format/print-width reflows expressions and declarations so they fit
+// formatPrintWidth reflows expressions and declarations so they fit
 // within a `printWidth`-column budget, mirroring Prettier's headline
 // formatting feature.
 //
@@ -102,7 +102,7 @@ func (formatPrintWidth) Visits() []shimast.Kind {
 //     reflow surface.
 //
 // Both cases are tracked benchmark cases that forced
-// `format/print-width: 'off'` on the ttsc-lint branch. They are listed
+// `formatPrintWidth: 'off'` on the ttsc-lint branch. They are listed
 // here so a future slice can pick them up without rediscovering the
 // divergence.
 func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
@@ -253,8 +253,8 @@ func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
 }
 
 // trailingLineWidth returns the visual column width of src[end:] up to
-// the next newline, with trailing whitespace trimmed. The format/print-
-// width reflow replaces only the node's own byte range, so whatever
+// the next newline, with trailing whitespace trimmed. The formatPrintWidth
+// reflow replaces only the node's own byte range, so whatever
 // shares the node's last source line — a statement `;`, a `) {` header
 // tail, a `, nextArg)` continuation — stays put. Charging that width
 // against the budget keeps the rule from emitting a line that overflows
@@ -265,7 +265,7 @@ func (formatPrintWidth) Check(ctx *Context, node *shimast.Node) {
 // the reflowed node to make the comment fit cannot help — Prettier 3
 // keeps the node inline and lets the comment trail (see typeorm's
 // `comment.replaceAll(...) // Null bytes' shape that pushed
-// `format/print-width: 'off'` onto the ttsc-lint benchmark branch).
+// `formatPrintWidth: 'off'` onto the ttsc-lint benchmark branch).
 // Excluding the comment from `trailingLineWidth` matches that
 // behavior: the fast path sees just the un-movable punctuation suffix,
 // and the shrunk-budget re-render does not over-shrink and over-break.
@@ -457,7 +457,7 @@ func lineStartOffset(src string, pos int) int {
 
 // ternaryArmIndentBonus returns 2 when the line containing `pos` begins,
 // after its leading whitespace, with a `? ` or `: ` ternary-arm marker,
-// and 0 otherwise. format/print-width adds it to BaseIndent so a node
+// and 0 otherwise. formatPrintWidth adds it to BaseIndent so a node
 // reflowed inside a ternary arm indents its broken continuation under
 // the arm's expression rather than under the `?`/`:` token. In practice
 // only a ternary arm opens a reflow target's line with `? ` / `: `; the
@@ -475,7 +475,7 @@ func ternaryArmIndentBonus(src string, pos int) int {
 }
 
 // hasReflowAncestor reports whether any ancestor of `node` would also
-// match the format/print-width visitor. The rule uses this to suppress
+// match the formatPrintWidth visitor. The rule uses this to suppress
 // nested fires when an enclosing reflow target already covers the
 // child.
 func hasReflowAncestor(node *shimast.Node) bool {
@@ -491,7 +491,7 @@ func hasReflowAncestor(node *shimast.Node) bool {
 }
 
 // hasTemplateSubstitutionAncestor reports whether `node` sits inside a
-// template-literal substitution (`${…}`). format/print-width abstains
+// template-literal substitution (`${…}`). formatPrintWidth abstains
 // on such nodes: Prettier prints template interpolations at infinite
 // printWidth and only keeps a break the source already had, so a reflow
 // of a nested call or literal would split a one-line `${…}` and never
@@ -509,7 +509,7 @@ func hasTemplateSubstitutionAncestor(node *shimast.Node) bool {
 }
 
 // isReflowKind reports whether `k` is one of the node kinds the
-// format/print-width rule visits. Kept in sync with Visits() so
+// formatPrintWidth rule visits. Kept in sync with Visits() so
 // hasReflowAncestor does not need to call Visits() at runtime.
 func isReflowKind(k shimast.Kind) bool {
   switch k {

package/linthost/rules_format_quotes.go

@@ -6,7 +6,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
-// format/quotes normalizes string-literal quote style. Mirrors
+// formatQuotes normalizes string-literal quote style. Mirrors
 // prettier's `singleQuote` option:
 //
 //   - `prefer: "double"` (default) converts single-quoted literals to

package/linthost/rules_format_semi.go

@@ -4,7 +4,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
-// format/semi controls trailing-semicolon style on ASI statements.
+// formatSemi controls trailing-semicolon style on ASI statements.
 // Mirrors prettier's `semi` option:
 //
 //   - `prefer: "always"` (default) inserts a missing terminator.

package/linthost/rules_format_sort_imports.go

@@ -29,7 +29,7 @@ type formatSortImportsOptions struct {
 // landed, so omitting `importOrder` produces the same output.
 var defaultImportOrder = []string{thirdPartyModulesPlaceholder, `^\.`}
 
-// format/sort-imports orders the file's top-level import declarations into
+// formatSortImports orders the file's top-level import declarations into
 // canonical groups and alphabetizes each group. Compatible-by-spirit with
 // `@trivago/prettier-plugin-sort-imports`. Groups are user-configurable via
 // the `importOrder` option; when omitted, the rule falls back to a

package/linthost/rules_format_trailing_comma.go

@@ -4,7 +4,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
-// format/trailing-comma adds trailing commas to multi-line lists. Mirrors
+// formatTrailingComma adds trailing commas to multi-line lists. Mirrors
 // prettier's `trailingComma: "all"` default — *not* a tunable.
 //
 // Scope (intentionally narrower than the closing-brace surface of TS):