@ttsc/lint 0.18.4 → 0.19.0

package/linthost/rules_unicorn_text_encoding_identifier_case.go

@@ -1,15 +1,24 @@
-// 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.
+// unicorn/text-encoding-identifier-case: the IANA/WHATWG text-encoding labels
+// `utf8`, `UTF-8`, `ascii`, etc. all resolve to the same encoding in browsers
+// and Node, but the ecosystem varies on which spelling it echoes back. Picking
+// one canonical form keeps string-equality checks against those echoes stable.
 //
-// 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.
+// Upstream parity (verified against `rules/text-encoding-identifier-case.js`):
+// only `utf-8`/`utf8` and `ascii` are handled — every other label passes
+// through untouched. The canonical form defaults to the dash-less `utf8`; the
+// dashed WHATWG spelling `utf-8` is enforced only when the `withDash` option is
+// set or the literal sits in a context that demands it: `new TextDecoder(...)`,
+// a JSX `<meta charset>`, or a JSX `<form accept-charset>` attribute. `ascii`
+// is always canonical lowercase.
+//
+// Only `fs.readFile()` / `fs.readFileSync()`'s encoding argument is auto-fixed;
+// every other position offers an editor suggestion instead, matching upstream's
+// fix-vs-suggestion split.
+//
+// AST-only: visit `StringLiteral` and `NoSubstitutionTemplateLiteral`. Matching
+// and rewriting both run on the raw text between the delimiters (upstream's
+// `node.raw.slice(1, -1)` / `replaceStringRaw`), so an escaped spelling such as
+// `"utf-8"` is left alone and a fix never disturbs the quotes.
 // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/text-encoding-identifier-case.md
 package linthost
 
@@ -17,54 +26,205 @@ import (
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
-type unicornTextEncodingIdentifierCase struct{}
+const unicornTextEncodingIdentifierCaseRuleName = "unicorn/text-encoding-identifier-case"
+
+type unicornTextEncodingIdentifierCase struct{ optionsRule }
 
-// 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",
+// unicornTextEncodingIdentifierCaseOptions decodes the single `{withDash}`
+// option slot. `withDash: true` prefers the dashed WHATWG spelling (`utf-8`)
+// everywhere; the default (`false`) prefers `utf8` outside the dash-only
+// contexts.
+type unicornTextEncodingIdentifierCaseOptions struct {
+  WithDash bool `json:"withDash"`
 }
 
 func (unicornTextEncodingIdentifierCase) Name() string {
-  return "unicorn/text-encoding-identifier-case"
+  return unicornTextEncodingIdentifierCaseRuleName
 }
 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 == "" {
+  if ctx == nil || ctx.File == nil || node == nil {
     return
   }
-  lower := strings.ToLower(text)
-  canonical, ok := unicornCanonicalTextEncodings[lower]
+  // Upstream's getStringLiteralValue rejects a template literal whose parent is
+  // a TaggedTemplateExpression (`String.raw`utf8``): the tag owns the raw text.
+  if node.Kind == shimast.KindNoSubstitutionTemplateLiteral &&
+    node.Parent != nil && node.Parent.Kind == shimast.KindTaggedTemplateExpression {
+    return
+  }
+  source := ctx.File.Text()
+  innerStart, innerEnd, ok := unicornTextEncodingInnerRange(source, node)
   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
-    }
+    return
+  }
+  value := source[innerStart:innerEnd]
+  if value == "" {
+    return
+  }
+  // Bail before decoding options or walking the parent chain unless the label
+  // is one the rule handles: `withDash` never turns an unknown label into a
+  // match, so an early reject here is behavior-preserving.
+  if unicornTextEncodingReplacement(value, false) == "" {
+    return
+  }
+
+  var options unicornTextEncodingIdentifierCaseOptions
+  _ = ctx.DecodeOptions(&options)
+  withDash := options.WithDash || unicornTextEncodingShouldEnforceDash(node)
+
+  replacement := unicornTextEncodingReplacement(value, withDash)
+  if replacement == "" || replacement == value {
+    return
   }
-  if text == canonical {
+
+  edit := TextEdit{Pos: innerStart, End: innerEnd, Text: replacement}
+  message := "Prefer `" + replacement + "` over `" + value + "`."
+  if unicornTextEncodingIsFsReadFileEncoding(node) {
+    // `fs.{readFile,readFileSync}` is the one auto-fixed position upstream.
+    ctx.ReportFix(node, message, edit)
     return
   }
-  ctx.Report(node, "Use the canonical lowercase form for text-encoding identifiers (e.g. `utf-8`).")
+  title := "Replace `" + value + "` with `" + replacement + "`."
+  ctx.ReportSuggestion(node, message, title, edit)
+}
+
+// unicornTextEncodingReplacement ports upstream's `getReplacement`: only
+// `utf-8`/`utf8` (→ `utf-8` when dashed, else `utf8`) and `ascii` are known;
+// any other label yields "" (no replacement). The comparison is
+// case-insensitive so `UTF-8`, `Utf8`, and `ASCII` all normalize.
+func unicornTextEncodingReplacement(encoding string, withDash bool) string {
+  switch strings.ToLower(encoding) {
+  case "utf-8", "utf8":
+    if withDash {
+      return "utf-8"
+    }
+    return "utf8"
+  case "ascii":
+    return "ascii"
+  }
+  return ""
+}
+
+// unicornTextEncodingShouldEnforceDash reports the contexts where the dashed
+// WHATWG spelling is required regardless of the `withDash` option: the first
+// argument of `new TextDecoder(...)`, a JSX `<meta charset>` attribute value,
+// or a JSX `<form accept-charset>` attribute value.
+func unicornTextEncodingShouldEnforceDash(node *shimast.Node) bool {
+  if node == nil || node.Parent == nil {
+    return false
+  }
+  if node.Parent.Kind == shimast.KindNewExpression {
+    if newExpr := node.Parent.AsNewExpression(); newExpr != nil &&
+      identifierText(newExpr.Expression) == "TextDecoder" &&
+      newExpr.Arguments != nil && len(newExpr.Arguments.Nodes) > 0 &&
+      newExpr.Arguments.Nodes[0] == node {
+      return true
+    }
+  }
+  return unicornTextEncodingIsJsxCharsetAttribute(node)
+}
+
+// unicornTextEncodingIsJsxCharsetAttribute matches `<meta charset="...">` and
+// `<form accept-charset="...">` (React's camelCase `acceptCharset` included),
+// where `node` is the attribute's string-literal initializer.
+func unicornTextEncodingIsJsxCharsetAttribute(node *shimast.Node) bool {
+  attr := node.Parent
+  if attr == nil || attr.Kind != shimast.KindJsxAttribute {
+    return false
+  }
+  jsxAttr := attr.AsJsxAttribute()
+  if jsxAttr == nil || jsxAttr.Initializer != node {
+    return false
+  }
+  attrs := attr.Parent
+  if attrs == nil || attrs.Kind != shimast.KindJsxAttributes {
+    return false
+  }
+  var tagName *shimast.Node
+  switch element := attrs.Parent; {
+  case element == nil:
+    return false
+  case element.Kind == shimast.KindJsxOpeningElement:
+    if opening := element.AsJsxOpeningElement(); opening != nil {
+      tagName = opening.TagName
+    }
+  case element.Kind == shimast.KindJsxSelfClosingElement:
+    if selfClosing := element.AsJsxSelfClosingElement(); selfClosing != nil {
+      tagName = selfClosing.TagName
+    }
+  default:
+    return false
+  }
+  attrName := strings.ToLower(jsxAttrName(jsxAttr.Name()))
+  switch strings.ToLower(jsxTagName(tagName)) {
+  case "meta":
+    return attrName == "charset"
+  case "form":
+    return attrName == "acceptcharset" || attrName == "accept-charset"
+  }
+  return false
+}
+
+// unicornTextEncodingIsFsReadFileEncoding matches the encoding argument of a
+// non-optional `obj.readFile(...)` / `obj.readFileSync(...)` call — `node` is
+// the second argument and the first is not a spread. Mirrors upstream's
+// `isMethodCall(..., {optionalCall:false, optionalMember:false})` plus the
+// `arguments[1] === node && arguments[0].type !== 'SpreadElement'` guards.
+func unicornTextEncodingIsFsReadFileEncoding(node *shimast.Node) bool {
+  if node == nil || node.Parent == nil || node.Parent.Kind != shimast.KindCallExpression {
+    return false
+  }
+  call := node.Parent.AsCallExpression()
+  if call == nil || call.QuestionDotToken != nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return false
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || access.QuestionDotToken != nil {
+    return false
+  }
+  if method := identifierText(access.Name()); method != "readFile" && method != "readFileSync" {
+    return false
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) < 2 ||
+    call.Arguments.Nodes[1] != node ||
+    call.Arguments.Nodes[0].Kind == shimast.KindSpreadElement {
+    return false
+  }
+  return true
+}
+
+// unicornTextEncodingInnerRange bounds the raw text between the quote or
+// backtick delimiters of a string / no-substitution-template literal, mirroring
+// upstream's `[range[0]+1, range[1]-1]` arithmetic.
+func unicornTextEncodingInnerRange(source string, node *shimast.Node) (int, int, bool) {
+  start := shimscanner.SkipTrivia(source, node.Pos())
+  end := node.End()
+  if start < 0 || end > len(source) || start+2 > end {
+    return 0, 0, false
+  }
+  open := source[start]
+  switch node.Kind {
+  case shimast.KindStringLiteral:
+    if open != '\'' && open != '"' {
+      return 0, 0, false
+    }
+    if source[end-1] != open {
+      return 0, 0, false
+    }
+  case shimast.KindNoSubstitutionTemplateLiteral:
+    if open != '`' || source[end-1] != '`' {
+      return 0, 0, false
+    }
+  default:
+    return 0, 0, false
+  }
+  return start + 1, end - 1, true
 }
 
 func init() {

package/linthost/rules_unicorn_throw_new_error.go

@@ -1,31 +1,42 @@
 // unicorn/throw-new-error: `throw Foo(...)` and `throw new Foo(...)` both
-// produce an Error instance because the built-in Error constructors are
+// produce an Error instance for the BUILT-IN Error constructors, which stay
 // 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.
+// `throw` to be paired with `new`, and a user-defined `class FooError extends
+// Error` cannot be called without `new` at all: the call throws a TypeError
+// instead of the error the author meant to throw. The rule requires
+// `throw new` whenever the operand is a direct call to an error-like
+// constructor.
+//
+// The callee predicate is upstream's: an `Identifier` callee, or a
+// non-computed member callee whose property is an `Identifier`, whose name
+// matches `^(?:[A-Z][\da-z]*)*Error$`. That covers the built-ins
+// (`TypeError`) AND user-defined classes (`ValidationError`,
+// `ns.HttpError`), which are the rule's most common real-world target.
 //
 // 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.
+// whose callee matches. Computed access (`lib["Error"]()`) is skipped, and
+// so is any optional-chained callee (`Error?.()`, `lib?.Error()`) because
+// `new` cannot be applied to an optional chain. Shadowed bindings and
+// type-aware widening are intentionally out of scope — the rule is a
+// syntactic nudge, not a full Error-tracking pass. Unlike upstream, which
+// flags every error-constructing call site, this port stays scoped to
+// `throw` operands.
 // 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": {},
-}
+import (
+  "regexp"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// unicornThrowNewErrorNamePattern is upstream's `customError` regex: any
+// number of capitalized words (each a capital followed by digits/lowercase)
+// closed by a literal `Error`. It accepts `Error`, `TypeError`, `HTTPError`,
+// and `Abc3Error`, and rejects `fooError` (no leading capital), `ERROR` (the
+// suffix is case-sensitive), `getError`, and `Errors`.
+var unicornThrowNewErrorNamePattern = regexp.MustCompile(`^(?:[A-Z][\da-z]*)*Error$`)
 
 type unicornThrowNewError struct{}
 
@@ -35,7 +46,7 @@ func (unicornThrowNewError) Visits() []shimast.Kind {
 }
 func (unicornThrowNewError) Check(ctx *Context, node *shimast.Node) {
   throw := node.AsThrowStatement()
-  if throw == nil {
+  if throw == nil || throw.Expression == nil {
     return
   }
   expr := stripParens(throw.Expression)
@@ -43,17 +54,198 @@ func (unicornThrowNewError) Check(ctx *Context, node *shimast.Node) {
     return
   }
   call := expr.AsCallExpression()
-  if call == nil {
+  if call == nil || call.Expression == nil {
     return
   }
-  name := identifierText(call.Expression)
-  if name == "" {
+  // `new` cannot be applied to an optional chain (`new lib?.Error()` is a
+  // syntax error), so upstream reports neither an optional call nor an
+  // optional-chained callee.
+  if call.QuestionDotToken != nil || unicornThrowNewErrorHasOptionalChain(call.Expression) {
     return
   }
-  if _, ok := unicornThrowNewErrorBuiltinNames[name]; !ok {
+  callee := stripParens(call.Expression)
+  if !unicornThrowNewErrorIsErrorCallee(callee) {
     return
   }
-  ctx.Report(expr, "Use `new` when throwing an error.")
+  ctx.ReportFix(
+    expr,
+    "Use `new` when throwing an error.",
+    unicornThrowNewErrorFix(ctx.File, throw.Expression, expr, call.Expression)...,
+  )
+}
+
+// unicornThrowNewErrorIsErrorCallee reports whether a callee names an error
+// constructor. A bare identifier matches on its own name; a property access
+// matches on its property name, so `ns.FooError()` counts while the computed
+// `ns["FooError"]()` (an element access) never does — computed keys are opaque
+// to upstream's selector too.
+//
+// `Data.TaggedError(...)` is upstream's Effect-library carve-out: the call
+// builds an error CLASS rather than an error instance, so `new` would be wrong.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/issues/2654
+func unicornThrowNewErrorIsErrorCallee(callee *shimast.Node) bool {
+  if callee == nil {
+    return false
+  }
+  switch callee.Kind {
+  case shimast.KindIdentifier:
+    return unicornThrowNewErrorNamePattern.MatchString(identifierText(callee))
+  case shimast.KindPropertyAccessExpression:
+    access := callee.AsPropertyAccessExpression()
+    if access == nil {
+      return false
+    }
+    name := identifierText(access.Name())
+    if !unicornThrowNewErrorNamePattern.MatchString(name) {
+      return false
+    }
+    return name != "TaggedError" ||
+      identifierText(stripParens(access.Expression)) != "Data"
+  default:
+    return false
+  }
+}
+
+// unicornThrowNewErrorHasOptionalChain reports whether any element on a
+// callee's left-hand chain uses `?.`, mirroring upstream's
+// `hasOptionalChainElement`. It differs from the shared `containsOptionalChain`
+// by seeing through parentheses and TypeScript's type-only wrappers, so
+// `(lib?.foo)!.Error()` is still recognized as an optional chain; `new` on any
+// such callee is a syntax error, and the rule must stay silent rather than
+// offer a fix that breaks the file.
+func unicornThrowNewErrorHasOptionalChain(node *shimast.Node) bool {
+  node = unwrapReferenceExpression(node)
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindPropertyAccessExpression:
+    access := node.AsPropertyAccessExpression()
+    if access == nil {
+      return false
+    }
+    return access.QuestionDotToken != nil ||
+      unicornThrowNewErrorHasOptionalChain(access.Expression)
+  case shimast.KindElementAccessExpression:
+    access := node.AsElementAccessExpression()
+    if access == nil {
+      return false
+    }
+    return access.QuestionDotToken != nil ||
+      unicornThrowNewErrorHasOptionalChain(access.Expression)
+  case shimast.KindCallExpression:
+    call := node.AsCallExpression()
+    if call == nil {
+      return false
+    }
+    return call.QuestionDotToken != nil ||
+      unicornThrowNewErrorHasOptionalChain(call.Expression)
+  default:
+    return false
+  }
+}
+
+// unicornThrowNewErrorFix builds upstream's autofix: insert `new ` in front of
+// the reported call. Two adjustments keep the rewritten source parseable, both
+// owed to upstream's shared `switchCallExpressionToNewExpression` fixer.
+//
+// A `throw` keyword that abuts its operand (`throw(Error())`,
+// `throw[lib][0].Error()`) needs a separating space, or the inserted keyword
+// welds onto it (`thrownew ...`). The space belongs at the operand's own start
+// — outside any parentheses wrapping it — and merges into the `new ` insert
+// when the two offsets coincide, because two zero-width inserts at one offset
+// cannot both survive edit selection.
+//
+// A callee that still exposes a call needs parentheses, because a `new`
+// expression's callee grammar ends at the first argument list; see
+// unicornThrowNewErrorCalleeNeedsParens.
+func unicornThrowNewErrorFix(
+  file *shimast.SourceFile,
+  operand *shimast.Node,
+  call *shimast.Node,
+  rawCallee *shimast.Node,
+) []TextEdit {
+  if file == nil {
+    return nil
+  }
+  callee := stripParens(rawCallee)
+  operandStart, _ := tokenRange(file, operand)
+  // A callee is its call's first token, so the call and its callee share one
+  // start offset; the opening parenthesis therefore rides along with the `new `
+  // insert instead of being a second zero-width edit at that same offset.
+  callStart, _ := tokenRange(file, call)
+  _, calleeEnd := tokenRange(file, callee)
+  if operandStart < 0 || callStart < 0 || calleeEnd < 0 {
+    return nil
+  }
+  src := file.Text()
+  parenthesize := unicornThrowNewErrorCalleeNeedsParens(rawCallee, callee)
+  insert := "new "
+  if parenthesize {
+    insert += "("
+  }
+  edits := make([]TextEdit, 0, 3)
+  if operandStart > 0 && isIdentifierPart(src[operandStart-1]) {
+    if operandStart == callStart {
+      insert = " " + insert
+    } else {
+      edits = append(edits, TextEdit{Pos: operandStart, End: operandStart, Text: " "})
+    }
+  }
+  edits = append(edits, TextEdit{Pos: callStart, End: callStart, Text: insert})
+  if parenthesize {
+    edits = append(edits, TextEdit{Pos: calleeEnd, End: calleeEnd, Text: ")"})
+  }
+  return edits
+}
+
+// unicornThrowNewErrorCalleeNeedsParens reports whether the fix has to wrap the
+// callee in parentheses: only when the source does not already parenthesize the
+// callee itself and an unshielded call sits on its object chain, whose argument
+// list `new` would otherwise consume as its own.
+//
+// The walk stops at a parenthesized object because parentheses already shield
+// everything inside them — `throw (getGlobalThis()).Error()` fixes to
+// `throw new (getGlobalThis()).Error()`, whose callee parse ends at `.Error`.
+// A non-null assertion shields nothing, so it stays transparent: without that
+// step `throw lib.getError()!.FooError()` would fix to
+// `throw new lib.getError()!.FooError()`, which constructs `lib.getError()` and
+// then reads `.FooError()` off the instance.
+func unicornThrowNewErrorCalleeNeedsParens(rawCallee, callee *shimast.Node) bool {
+  if rawCallee == nil || rawCallee.Kind == shimast.KindParenthesizedExpression {
+    return false
+  }
+  if callee == nil || callee.Kind != shimast.KindPropertyAccessExpression {
+    return false
+  }
+  access := callee.AsPropertyAccessExpression()
+  if access == nil {
+    return false
+  }
+  current := access.Expression
+  for current != nil {
+    switch current.Kind {
+    case shimast.KindCallExpression:
+      return true
+    case shimast.KindPropertyAccessExpression:
+      inner := current.AsPropertyAccessExpression()
+      if inner == nil {
+        return false
+      }
+      current = inner.Expression
+    case shimast.KindElementAccessExpression:
+      inner := current.AsElementAccessExpression()
+      if inner == nil {
+        return false
+      }
+      current = inner.Expression
+    case shimast.KindNonNullExpression:
+      current = current.Expression()
+    default:
+      return false
+    }
+  }
+  return false
 }
 
 func init() {