@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/rules_unicorn_require_module_specifiers.go

@@ -0,0 +1,55 @@
+// unicorn/require-module-specifiers: an `import "x"` with no bindings
+// or an `export {} from "x"` declares the module dependency without
+// pulling anything from it; both shapes are almost always either dead
+// imports left over from a refactor or accidental side-effect imports
+// that the author meant to bind. The rule asks for an explicit specifier
+// list so the dependency makes its purpose visible in the source.
+//
+// AST-only: visit every `ImportDeclaration` and `ExportDeclaration`.
+// Import side fires when the declaration has no `ImportClause` at all
+// (the side-effect form). Export side fires when the declaration has an
+// empty NamedExports `{}` (with or without a `from`).
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/require-module-specifiers.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornRequireModuleSpecifiers struct{}
+
+func (unicornRequireModuleSpecifiers) Name() string {
+  return "unicorn/require-module-specifiers"
+}
+func (unicornRequireModuleSpecifiers) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindImportDeclaration, shimast.KindExportDeclaration}
+}
+func (unicornRequireModuleSpecifiers) Check(ctx *Context, node *shimast.Node) {
+  switch node.Kind {
+  case shimast.KindImportDeclaration:
+    decl := node.AsImportDeclaration()
+    if decl == nil {
+      return
+    }
+    // `import "x"` parses with a nil ImportClause; any binding shape
+    // (`import x`, `import {a}`, `import * as ns`) installs a clause.
+    if decl.ImportClause == nil {
+      ctx.Report(node, "Empty import/export specifier list is not allowed.")
+    }
+  case shimast.KindExportDeclaration:
+    decl := node.AsExportDeclaration()
+    if decl == nil || decl.ExportClause == nil {
+      return
+    }
+    if decl.ExportClause.Kind != shimast.KindNamedExports {
+      return
+    }
+    named := decl.ExportClause.AsNamedExports()
+    if named == nil || named.Elements == nil || len(named.Elements.Nodes) > 0 {
+      return
+    }
+    ctx.Report(node, "Empty import/export specifier list is not allowed.")
+  }
+}
+
+func init() {
+  Register(unicornRequireModuleSpecifiers{})
+}

package/linthost/rules_unicorn_require_number_to_fixed_digits_argument.go

@@ -0,0 +1,43 @@
+// unicorn/require-number-to-fixed-digits-argument: `Number#toFixed()`
+// with no argument is equivalent to `.toFixed(0)`, which rounds away
+// every fractional digit. Authors almost always mean a non-zero digit
+// count, and the no-arg form is one of the more common silent
+// truncation bugs. The rule asks every call site to spell out the digit
+// count.
+//
+// AST-only: visit each `CallExpression`, accept only the property-access
+// `x.toFixed` shape, and report when the call carries zero arguments.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/require-number-to-fixed-digits-argument.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornRequireNumberToFixedDigitsArgument struct{}
+
+func (unicornRequireNumberToFixedDigitsArgument) Name() string {
+  return "unicorn/require-number-to-fixed-digits-argument"
+}
+func (unicornRequireNumberToFixedDigitsArgument) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornRequireNumberToFixedDigitsArgument) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Name()) != "toFixed" {
+    return
+  }
+  if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+    return
+  }
+  ctx.Report(node, "Pass an explicit digits argument to `Number#toFixed()`.")
+}
+
+func init() {
+  Register(unicornRequireNumberToFixedDigitsArgument{})
+}

package/linthost/rules_unicorn_require_post_message_target_origin.go

@@ -0,0 +1,44 @@
+// unicorn/require-post-message-target-origin: `Window#postMessage` and
+// `Worker#postMessage` take a `targetOrigin` (or `transfer`) argument
+// that scopes which document/worker may receive the message. Omitting
+// it defaults to the receiver's own origin, which is a quiet security
+// footgun — cross-origin frames silently lose the message. The rule
+// asks every call site to pass an explicit second argument.
+//
+// AST-only: visit each `CallExpression`, accept only the property-access
+// `x.postMessage` shape, and report when the call carries exactly one
+// argument (the message payload, with no targetOrigin to follow).
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/require-post-message-target-origin.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornRequirePostMessageTargetOrigin struct{}
+
+func (unicornRequirePostMessageTargetOrigin) Name() string {
+  return "unicorn/require-post-message-target-origin"
+}
+func (unicornRequirePostMessageTargetOrigin) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornRequirePostMessageTargetOrigin) Check(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Name()) != "postMessage" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  ctx.Report(node, "Pass an explicit `targetOrigin` argument to `postMessage`.")
+}
+
+func init() {
+  Register(unicornRequirePostMessageTargetOrigin{})
+}

package/linthost/rules_unicorn_string_content.go

@@ -0,0 +1,27 @@
+// unicorn/string-content: rewrites configured substrings inside string
+// literals (e.g. straight quotes -> curly quotes, `...` -> `…`). The
+// rule has NO defaults; behavior depends entirely on the user-supplied
+// `patterns: { match: replacement }` configuration. Without that
+// per-pattern configuration plumbing in the host's rule-options
+// pipeline, the rule has nothing to enforce.
+//
+// Registered as a no-op stub to keep
+// `TestTypedKeysMatchRegisteredRules` aligned with the typed
+// `ITtscLintUnicornRules` surface. The matching fixture under
+// `tests/test-lint/src/cases/unicorn-string-content.ts` keeps its
+// `@ttsc-corpus-skip` directive.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/string-content.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornStringContent struct{}
+
+func (unicornStringContent) Name() string           { return "unicorn/string-content" }
+func (unicornStringContent) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+func (unicornStringContent) Check(_ *Context, _ *shimast.Node) {
+}
+
+func init() {
+  Register(unicornStringContent{})
+}

package/linthost/rules_unicorn_switch_case_braces.go

@@ -0,0 +1,42 @@
+// unicorn/switch-case-braces: `case` and `default` clauses share their
+// parent switch's scope, so an unbraced `case x: let y = …;` leaks `y`
+// into every subsequent case. The default-on "always" mode of this rule
+// requires every clause body to be a single `{ … }` block, which both
+// scopes declarations and visually delimits clause bodies.
+//
+// AST-only: visit each `CaseClause` and `DefaultClause` and report when
+// the clause's statements list is anything other than exactly one
+// `Block`. Empty fall-through clauses (`case "a":` with no statements)
+// also fire — the rule's "always" mode wants the brace pair even when
+// the body is empty.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/switch-case-braces.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornSwitchCaseBraces struct{}
+
+func (unicornSwitchCaseBraces) Name() string { return "unicorn/switch-case-braces" }
+func (unicornSwitchCaseBraces) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindCaseClause, shimast.KindDefaultClause}
+}
+func (unicornSwitchCaseBraces) Check(ctx *Context, node *shimast.Node) {
+  clause := node.AsCaseOrDefaultClause()
+  if clause == nil || clause.Statements == nil {
+    return
+  }
+  stmts := clause.Statements.Nodes
+  if len(stmts) == 0 {
+    // Empty fall-through (`case "a":` followed immediately by another
+    // clause) is not the "missing braces" shape the rule targets.
+    return
+  }
+  if len(stmts) == 1 && stmts[0] != nil && stmts[0].Kind == shimast.KindBlock {
+    return
+  }
+  ctx.Report(node, "Wrap `case` clause body in a block (`case x: { ... }`).")
+}
+
+func init() {
+  Register(unicornSwitchCaseBraces{})
+}

package/linthost/rules_unicorn_switch_case_break_position.go

@@ -0,0 +1,31 @@
+// unicorn/switch-case-break-position: the upstream rule rejects a
+// `break` / `return` / `throw` that is followed by further statements
+// inside the same `case` / `default` clause, because the trailing
+// statements are dead code.
+//
+// In a well-formed TypeScript program the TypeScript-Go checker already
+// emits an `unreachable code` diagnostic for statements following a
+// terminator, so this AST-only port would either duplicate that
+// diagnostic (when reused as an MVP) or need scope/CFG analysis to
+// reproduce the exact upstream surface. The rule is registered as a
+// no-op until a follow-up exposes the unreachable-statement metadata
+// the checker computes for switch clauses.
+//
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/switch-case-break-position.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornSwitchCaseBreakPosition struct{}
+
+func (unicornSwitchCaseBreakPosition) Name() string {
+  return "unicorn/switch-case-break-position"
+}
+func (unicornSwitchCaseBreakPosition) Visits() []shimast.Kind { return nil }
+func (unicornSwitchCaseBreakPosition) Check(*Context, *shimast.Node) {
+  // Intentionally empty; see file-level comment.
+}
+
+func init() {
+  Register(unicornSwitchCaseBreakPosition{})
+}

package/linthost/rules_unicorn_template_indent.go

@@ -0,0 +1,28 @@
+// unicorn/template-indent: re-indents the contents of tagged template
+// literals (`outdent`, `dedent`, `stripIndent`, etc.) so the inner text
+// is column-aligned with the surrounding code. The autofix has to
+// detect the common leading-whitespace prefix of every line in the
+// template body, decide what the desired indent level is from the
+// template's own column, then rewrite every interior line — substantial
+// whitespace analysis well beyond a pattern match.
+//
+// Registered as a no-op stub to keep
+// `TestTypedKeysMatchRegisteredRules` aligned with the typed
+// `ITtscLintUnicornRules` surface. The matching fixture under
+// `tests/test-lint/src/cases/unicorn-template-indent.ts` keeps its
+// `@ttsc-corpus-skip` directive.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/template-indent.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornTemplateIndent struct{}
+
+func (unicornTemplateIndent) Name() string           { return "unicorn/template-indent" }
+func (unicornTemplateIndent) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+func (unicornTemplateIndent) Check(_ *Context, _ *shimast.Node) {
+}
+
+func init() {
+  Register(unicornTemplateIndent{})
+}

package/linthost/rules_unicorn_text_encoding_identifier_case.go

@@ -0,0 +1,72 @@
+// unicorn/text-encoding-identifier-case: the IANA text-encoding labels
+// `UTF-8`, `utf8`, `ASCII`, etc. all resolve to the same encoding in
+// browsers and Node, but the surrounding ecosystem (HTTP headers,
+// `TextDecoder`, file APIs) varies on which spelling it echoes back.
+// Picking one canonical form per encoding makes string-equality checks
+// against those echoes stable. The rule asks every encoding-shaped
+// literal to use the canonical lowercase, hyphenated form.
+//
+// AST-only: visit `StringLiteral` and `NoSubstitutionTemplateLiteral`
+// nodes. The literal's lowercased text is matched against the well-known
+// encoding identifiers; a mismatch with the canonical form (the same
+// identifier already in canonical case) fires the rule.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/text-encoding-identifier-case.md
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type unicornTextEncodingIdentifierCase struct{}
+
+// unicornCanonicalTextEncodings maps the lowercased label to its canonical
+// spelling. Authors who already wrote the canonical form pass; anything
+// else with the same lowercased label fires.
+var unicornCanonicalTextEncodings = map[string]string{
+  "utf-8":        "utf-8",
+  "utf-16le":     "utf-16le",
+  "utf-16be":     "utf-16be",
+  "ascii":        "ascii",
+  "latin1":       "latin1",
+  "iso-8859-1":   "iso-8859-1",
+  "windows-1252": "windows-1252",
+}
+
+func (unicornTextEncodingIdentifierCase) Name() string {
+  return "unicorn/text-encoding-identifier-case"
+}
+func (unicornTextEncodingIdentifierCase) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
+}
+func (unicornTextEncodingIdentifierCase) Check(ctx *Context, node *shimast.Node) {
+  text := stringLiteralText(node)
+  if text == "" {
+    return
+  }
+  lower := strings.ToLower(text)
+  canonical, ok := unicornCanonicalTextEncodings[lower]
+  if !ok {
+    // `utf8`/`UTF8` share a canonical form with `utf-8` but lowercase
+    // differently — handle the hyphen-stripped aliases explicitly.
+    switch lower {
+    case "utf8":
+      canonical = "utf-8"
+    case "utf16le":
+      canonical = "utf-16le"
+    case "utf16be":
+      canonical = "utf-16be"
+    default:
+      return
+    }
+  }
+  if text == canonical {
+    return
+  }
+  ctx.Report(node, "Use the canonical lowercase form for text-encoding identifiers (e.g. `utf-8`).")
+}
+
+func init() {
+  Register(unicornTextEncodingIdentifierCase{})
+}

package/linthost/rules_unicorn_throw_new_error.go

@@ -0,0 +1,61 @@
+// unicorn/throw-new-error: `throw Foo(...)` and `throw new Foo(...)` both
+// produce an Error instance because the built-in Error constructors are
+// callable without `new`, but the call-form is a footgun — readers expect
+// `throw` to be paired with `new`, and some tooling (notably custom Error
+// subclasses) stops working when the call-form is mixed in. The rule
+// requires `throw new` whenever the operand is a direct call to one of the
+// eight built-in Error constructor names.
+//
+// AST-only: visit each `ThrowStatement`, peel parentheses off its operand,
+// and fire when the operand is a `CallExpression` (NOT a `NewExpression`)
+// whose callee is an `Identifier` matching the built-in allowlist. Shadowed
+// bindings and type-aware widening are intentionally out of scope — the
+// rule is a syntactic nudge, not a full Error-tracking pass.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/throw-new-error.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+var unicornThrowNewErrorBuiltinNames = map[string]struct{}{
+  "Error":          {},
+  "TypeError":      {},
+  "RangeError":     {},
+  "SyntaxError":    {},
+  "ReferenceError": {},
+  "EvalError":      {},
+  "URIError":       {},
+  "AggregateError": {},
+}
+
+type unicornThrowNewError struct{}
+
+func (unicornThrowNewError) Name() string { return "unicorn/throw-new-error" }
+func (unicornThrowNewError) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindThrowStatement}
+}
+func (unicornThrowNewError) Check(ctx *Context, node *shimast.Node) {
+  throw := node.AsThrowStatement()
+  if throw == nil {
+    return
+  }
+  expr := stripParens(throw.Expression)
+  if expr == nil || expr.Kind != shimast.KindCallExpression {
+    return
+  }
+  call := expr.AsCallExpression()
+  if call == nil {
+    return
+  }
+  name := identifierText(call.Expression)
+  if name == "" {
+    return
+  }
+  if _, ok := unicornThrowNewErrorBuiltinNames[name]; !ok {
+    return
+  }
+  ctx.Report(expr, "Use `new` when throwing an error.")
+}
+
+func init() {
+  Register(unicornThrowNewError{})
+}

package/linthost/rules_var.go

@@ -2,7 +2,7 @@ package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// no-var: ban `var` declarations. ESLint canonical:
+// noVar: ban `var` declarations. ESLint canonical:
 // https://eslint.org/docs/latest/rules/no-var
 type noVar struct{}
 
@@ -13,6 +13,12 @@ func (noVar) Check(ctx *Context, node *shimast.Node) {
   if stmt == nil || stmt.DeclarationList == nil {
     return
   }
+  if ctx.File != nil && ctx.File.IsDeclarationFile {
+    return
+  }
+  if node.ModifierFlags()&shimast.ModifierFlagsAmbient != 0 {
+    return
+  }
   if shimast.IsVar(stmt.DeclarationList) {
     start := keywordStart(ctx.File, stmt.DeclarationList, "var")
     if start >= 0 {
@@ -28,7 +34,7 @@ func (noVar) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// prefer-const: flag `let` declarations whose binding is never reassigned.
+// preferConst: flag `let` declarations whose binding is never reassigned.
 // This follows ESLint's core rule for the common AST-local cases. It is
 // intentionally conservative: destructuring and declaration-only `let`
 // variables (those without an initializer and not in a for-of/for-in
@@ -129,7 +135,7 @@ func isSingleDeclarationList(node *shimast.Node) bool {
 }
 
 // isConstEligibleLetDeclaration reports whether a `let` VariableDeclaration
-// node is eligible for prefer-const analysis. A declaration is eligible when:
+// node is eligible for preferConst analysis. A declaration is eligible when:
 //   - it has an initializer (the value is set immediately), or
 //   - it is the loop variable of a for-in or for-of statement (e.g. `for (let k of m)`).
 //
@@ -148,7 +154,7 @@ func isConstEligibleLetDeclaration(node *shimast.Node, decl *shimast.VariableDec
     (node.Parent.Parent.Kind == shimast.KindForInStatement || node.Parent.Parent.Kind == shimast.KindForOfStatement)
 }
 
-// no-undef-init: forbid `let x = undefined` and `var x = undefined`.
+// noUndefInit: forbid `let x = undefined` and `var x = undefined`.
 // ESLint canonical: https://eslint.org/docs/latest/rules/no-undef-init
 type noUndefInit struct{}