@ttsc/lint 0.18.3 → 0.19.0

package/linthost/rules_testing_library.go

@@ -13,6 +13,15 @@ type testingLibraryRule struct {
   name string
 }
 
+// testingLibraryOptionsRule marks the one rule in the shared SourceFile
+// dispatcher whose public contract includes an options object. Embedding the
+// base rule keeps dispatch shared while leaving every sibling genuinely
+// optionless in the registry.
+type testingLibraryOptionsRule struct {
+  testingLibraryRule
+  optionsRule
+}
+
 func (r testingLibraryRule) Name() string { return "testing-library/" + r.name }
 func (r testingLibraryRule) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindSourceFile}
@@ -1168,11 +1177,13 @@ func testingLibraryFileName(fileName string) string {
 }
 
 func init() {
+  Register(testingLibraryOptionsRule{
+    testingLibraryRule: testingLibraryRule{name: "consistent-data-testid"},
+  })
   for _, name := range []string{
     "await-async-events",
     "await-async-queries",
     "await-async-utils",
-    "consistent-data-testid",
     "no-await-sync-events",
     "no-await-sync-queries",
     "no-container",

package/linthost/rules_ts.go

@@ -4,7 +4,12 @@
 // Each rule is registered in the package init function at the bottom.
 package linthost
 
-import shimast "github.com/microsoft/typescript-go/shim/ast"
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
 
 // noExplicitAny: ban `: any` annotations. Loud equivalent of
 // `@typescript-eslint/no-explicit-any`.
@@ -161,68 +166,257 @@ func (noThisAlias) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// preferAsConst: `as 'foo'` / `as 1` should be `as const`.
+// preferAsConst: `as 'foo'` / `<'foo'>` assertions and `let x: 'foo' = 'foo'`
+// variable / class-property annotations should use `as const`. Port of
+// `@typescript-eslint/prefer-as-const`, which visits the same four AST
+// families and compares the literals' raw source spelling.
 type preferAsConst struct{}
 
 func (preferAsConst) Name() string { return "typescript/prefer-as-const" }
 func (preferAsConst) Visits() []shimast.Kind {
-  return []shimast.Kind{shimast.KindAsExpression, shimast.KindTypeAssertionExpression}
+  return []shimast.Kind{
+    shimast.KindAsExpression,
+    shimast.KindTypeAssertionExpression,
+    shimast.KindVariableDeclaration,
+    shimast.KindPropertyDeclaration,
+  }
 }
 func (preferAsConst) Check(ctx *Context, node *shimast.Node) {
-  var expr, typeNode *shimast.Node
   switch node.Kind {
   case shimast.KindAsExpression:
-    as := node.AsAsExpression()
-    if as == nil {
-      return
+    if as := node.AsAsExpression(); as != nil {
+      preferAsConstCheckAssertion(ctx, as.Expression, as.Type)
     }
-    expr = as.Expression
-    typeNode = as.Type
   case shimast.KindTypeAssertionExpression:
-    ta := node.AsTypeAssertion()
-    if ta == nil {
+    if ta := node.AsTypeAssertion(); ta != nil {
+      preferAsConstCheckAssertion(ctx, ta.Expression, ta.Type)
+    }
+  case shimast.KindVariableDeclaration:
+    if decl := node.AsVariableDeclaration(); decl != nil {
+      preferAsConstCheckAnnotation(ctx, node, decl.Initializer, decl.Type)
+    }
+  case shimast.KindPropertyDeclaration:
+    decl := node.AsPropertyDeclaration()
+    if decl == nil {
       return
     }
-    expr = ta.Expression
-    typeNode = ta.Type
+    // `accessor` fields surface upstream as AccessorProperty nodes, which
+    // the rule's PropertyDefinition visitor never receives; get/set
+    // accessors and methods are separate AST kinds already.
+    if node.ModifierFlags()&shimast.ModifierFlagsAccessor != 0 {
+      return
+    }
+    preferAsConstCheckAnnotation(ctx, node, decl.Initializer, decl.Type)
   }
-  if expr == nil || typeNode == nil {
+}
+
+// preferAsConstCheckAssertion handles the `expr as T` / `<T>expr` assertion
+// forms. These are directly autofixable: the literal type becomes `const`, and
+// any type-only parentheses are removed without disturbing their comments.
+func preferAsConstCheckAssertion(ctx *Context, expr, typeNode *shimast.Node) {
+  if !preferAsConstLiteralsMatch(ctx.File, expr, typeNode) {
     return
   }
-  if typeNode.Kind != shimast.KindLiteralType {
+  message := "Expected `as const` instead of `as` literal type."
+  edits := preferAsConstAssertionEdits(ctx.File, typeNode)
+  if len(edits) == 0 {
+    ctx.Report(typeNode, message)
     return
   }
-  literalType := typeNode.AsLiteralTypeNode()
-  if literalType == nil || literalType.Literal == nil {
-    return
+  ctx.ReportFix(typeNode, message, edits...)
+}
+
+// preferAsConstAssertionEdits replaces the innermost literal type and removes
+// only the syntactic parentheses around it. Keeping the trivia between those
+// tokens preserves comments while producing valid `as const` / `<const>`
+// syntax instead of the invalid `as (const)` shape.
+func preferAsConstAssertionEdits(file *shimast.SourceFile, typeNode *shimast.Node) []TextEdit {
+  if file == nil || typeNode == nil {
+    return nil
   }
-  if !literalsMatchSourceText(ctx.File, expr, literalType.Literal) {
-    return
+  edits := []TextEdit{}
+  for typeNode.Kind == shimast.KindParenthesizedType {
+    parenthesized := typeNode.AsParenthesizedTypeNode()
+    if parenthesized == nil || parenthesized.Type == nil {
+      return nil
+    }
+    openScanner := shimscanner.GetScannerForSourceFile(file, typeNode.Pos())
+    if openScanner.Token() != shimast.KindOpenParenToken {
+      return nil
+    }
+    closeScanner := shimscanner.GetScannerForSourceFile(file, parenthesized.Type.End())
+    if closeScanner.Token() != shimast.KindCloseParenToken || closeScanner.TokenEnd() > typeNode.End() {
+      return nil
+    }
+    edits = append(edits,
+      TextEdit{Pos: openScanner.TokenStart(), End: openScanner.TokenEnd()},
+      TextEdit{Pos: closeScanner.TokenStart(), End: closeScanner.TokenEnd()},
+    )
+    typeNode = parenthesized.Type
   }
-  message := "Expected `as const` instead of `as` literal type."
-  pos, end := tokenRange(ctx.File, typeNode)
+  pos, end := tokenRange(file, typeNode)
   if pos < 0 {
-    ctx.Report(node, message)
+    return nil
+  }
+  return append(edits, TextEdit{Pos: pos, End: end, Text: "const"})
+}
+
+// preferAsConstCheckAnnotation handles variable declarators and class
+// property declarations whose literal type annotation repeats the
+// initializer literal. The upstream rule pairs this report with a manual
+// suggestion, not an autofix: it removes the annotation and appends `as const`
+// after the initializer while `eslint --fix` leaves the declaration alone.
+func preferAsConstCheckAnnotation(ctx *Context, declaration, init, typeNode *shimast.Node) {
+  if init == nil || !preferAsConstLiteralsMatch(ctx.File, init, typeNode) {
+    return
+  }
+  annotationStart := preferAsConstAnnotationStart(ctx.File, declaration, typeNode)
+  _, annotationEnd := tokenRange(ctx.File, typeNode)
+  message := "Expected a `const` assertion instead of a literal type annotation."
+  if annotationStart < 0 || annotationEnd < annotationStart || init.End() < annotationEnd {
+    ctx.Report(typeNode, message)
     return
   }
-  ctx.ReportFix(
-    node,
+  ctx.ReportSuggestion(
+    typeNode,
     message,
-    TextEdit{Pos: pos, End: end, Text: "const"},
+    "Replace the literal type annotation with `as const`.",
+    TextEdit{
+      Pos:  annotationStart,
+      End:  annotationEnd,
+      Text: preferAsConstPreservedAnnotationComments(ctx.File, annotationStart, annotationEnd),
+    },
+    TextEdit{
+      Pos:  init.End(),
+      End:  init.End(),
+      Text: " as const",
+    },
   )
 }
 
-// literalsMatchSourceText reports whether lhs and rhs are both literal
-// expressions whose source text is identical. Used by preferAsConst to
-// detect `x as "foo"` where "foo" matches x's literal value.
-func literalsMatchSourceText(file *shimast.SourceFile, lhs, rhs *shimast.Node) bool {
-  if lhs == nil || rhs == nil {
+// preferAsConstPreservedAnnotationComments keeps comments embedded in the
+// removed annotation. Multiline comments remain space-separated; line comments
+// retain their line ending so the following initializer cannot be commented
+// out. Syntax tokens and whitespace are intentionally discarded.
+func preferAsConstPreservedAnnotationComments(file *shimast.SourceFile, start, end int) string {
+  if file == nil || start < 0 || end <= start || end > len(file.Text()) {
+    return ""
+  }
+  src := file.Text()
+  scanner := shimscanner.GetScannerForSourceFile(file, start)
+  scanner.SetSkipTrivia(false)
+  var preserved strings.Builder
+  lineEnded := false
+  for scanner.TokenStart() < end && scanner.Token() != shimast.KindEndOfFile {
+    kind := scanner.Token()
+    if kind == shimast.KindSingleLineCommentTrivia || kind == shimast.KindMultiLineCommentTrivia {
+      if preserved.Len() == 0 || !lineEnded {
+        preserved.WriteByte(' ')
+      }
+      preserved.WriteString(scanner.TokenText())
+      lineEnded = false
+      if kind == shimast.KindSingleLineCommentTrivia {
+        switch tokenEnd := scanner.TokenEnd(); {
+        case tokenEnd+1 < len(src) && src[tokenEnd:tokenEnd+2] == "\r\n":
+          preserved.WriteString("\r\n")
+        case tokenEnd < len(src) && (src[tokenEnd] == '\r' || src[tokenEnd] == '\n'):
+          preserved.WriteByte(src[tokenEnd])
+        default:
+          preserved.WriteByte('\n')
+        }
+        lineEnded = true
+      }
+    }
+    scanner.Scan()
+  }
+  return preserved.String()
+}
+
+// preferAsConstAnnotationStart locates the annotation's colon by tokenizing
+// only the declaration segment between its name and type. This preserves
+// modifiers, computed names, and postfix `?` / `!` markers without relying on
+// source-text regular expressions.
+func preferAsConstAnnotationStart(file *shimast.SourceFile, declaration, typeNode *shimast.Node) int {
+  if file == nil || declaration == nil || typeNode == nil || declaration.Name() == nil {
+    return -1
+  }
+  scanner := shimscanner.GetScannerForSourceFile(file, declaration.Name().End())
+  for {
+    kind := scanner.Token()
+    if kind == shimast.KindColonToken {
+      return scanner.TokenStart()
+    }
+    if kind == shimast.KindEndOfFile || scanner.TokenStart() >= typeNode.End() {
+      return -1
+    }
+    scanner.Scan()
+  }
+}
+
+// preferAsConstLiteralsMatch reports whether typeNode is a literal type
+// whose literal token repeats expr's exact source spelling. Mirrors the
+// upstream check `valueNode.raw === typeNode.literal.raw` between ESTree
+// `Literal` nodes: string, numeric, bigint, and boolean literals qualify on
+// both sides. Template literals (ESTree `TemplateLiteral`) and `null`
+// (whose type position surfaces upstream as `TSNullKeyword`, not
+// `TSLiteralType`) are excluded, so a template literal asserted to its
+// identically spelled template literal type and `null as null` stay clean
+// exactly like the upstream fixtures.
+func preferAsConstLiteralsMatch(file *shimast.SourceFile, expr, typeNode *shimast.Node) bool {
+  if expr == nil || typeNode == nil {
     return false
   }
-  if !isLiteralExpression(lhs) {
+  // typescript-estree erases both expression and type parentheses, so tsgo's
+  // ParenthesizedType wrappers must not affect the upstream raw-literal check.
+  typeNode = preferAsConstUnwrapType(typeNode)
+  if typeNode == nil || typeNode.Kind != shimast.KindLiteralType {
     return false
   }
-  return nodeText(file, lhs) == nodeText(file, rhs)
+  literalType := typeNode.AsLiteralTypeNode()
+  if literalType == nil || literalType.Literal == nil {
+    return false
+  }
+  // ESTree does not represent expression parentheses, so upstream sees the
+  // bare literal in `('a') as 'a'` and reports it; descend to the same
+  // canonical node.
+  expr = stripParens(expr)
+  if !isPreferAsConstLiteral(expr) || !isPreferAsConstLiteral(literalType.Literal) {
+    return false
+  }
+  return nodeText(file, expr) == nodeText(file, literalType.Literal)
+}
+
+func preferAsConstUnwrapType(typeNode *shimast.Node) *shimast.Node {
+  for typeNode != nil && typeNode.Kind == shimast.KindParenthesizedType {
+    parenthesized := typeNode.AsParenthesizedTypeNode()
+    if parenthesized == nil || parenthesized.Type == nil {
+      return nil
+    }
+    typeNode = parenthesized.Type
+  }
+  return typeNode
+}
+
+// isPreferAsConstLiteral reports whether node is one of the literal token
+// kinds ts-estree maps to an ESTree `Literal` in both the expression and
+// the literal-type position. `null` and regular-expression literals map to
+// `Literal` in expression position only; neither can raw-match a literal
+// type (a `null` annotation is `TSNullKeyword` upstream and regexes cannot
+// appear in type position), so excluding them here is equivalent to the
+// upstream shape check.
+func isPreferAsConstLiteral(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindStringLiteral,
+    shimast.KindNumericLiteral,
+    shimast.KindBigIntLiteral,
+    shimast.KindTrueKeyword,
+    shimast.KindFalseKeyword:
+    return true
+  }
+  return false
 }
 
 // noRequireImports: ban `require(...)` calls in TS source. Use
@@ -250,26 +444,6 @@ func (noRequireImports) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// banTsComment: `// @ts-ignore` / `// @ts-expect-error` silence the type
-// checker. The rule flags `@ts-ignore` and `@ts-expect-error`.
-type banTsComment struct{}
-
-func (banTsComment) Name() string           { return "typescript/ban-ts-comment" }
-func (banTsComment) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
-func (banTsComment) Check(ctx *Context, node *shimast.Node) {
-  if ctx.File == nil {
-    return
-  }
-  for _, directive := range ctx.File.CommentDirectives {
-    switch directive.Kind {
-    case shimast.CommentDirectiveKindIgnore:
-      ctx.ReportRange(directive.Loc.Pos(), directive.Loc.End(), "Do not use `@ts-ignore` because it alters compilation errors.")
-    case shimast.CommentDirectiveKindExpectError:
-      ctx.ReportRange(directive.Loc.Pos(), directive.Loc.End(), "Do not use `@ts-expect-error` because it alters compilation errors.")
-    }
-  }
-}
-
 func init() {
   Register(noExplicitAny{})
   Register(noNonNullAssertion{})
@@ -279,5 +453,4 @@ func init() {
   Register(noThisAlias{})
   Register(preferAsConst{})
   Register(noRequireImports{})
-  Register(banTsComment{})
 }

package/linthost/rules_ts_async.go

@@ -7,8 +7,6 @@
 // Implemented here:
 //   - typescript/require-await
 //     (AST-only; async function with no `await` in its body)
-//   - typescript/no-misused-promises
-//     (type-aware; Promise in conditional / logical / forEach position)
 //   - typescript/use-unknown-in-catch-callback-variable
 //     (type-aware; `.catch(err)` / `.then(_, err)` must annotate `unknown`)
 //   - typescript/only-throw-error
@@ -110,134 +108,6 @@ func requireAwaitBodyHasAwait(body *shimast.Node) bool {
   return found
 }
 
-// noMisusedPromises reports Promises supplied where a boolean or a
-// `void`-returning callback is expected. The Promise is truthy as a
-// value, so the conditional silently passes; the discarded Promise then
-// leaks any rejection. typescript-eslint:
-// https://typescript-eslint.io/rules/no-misused-promises/
-//
-// Type-aware. Covers the three highest-signal positions:
-//   - conditional positions: `if (p)`, `while (p)`, `do … while (p)`,
-//     `for (; p; …)`, `p ? a : b`, `!p`;
-//   - short-circuit / nullish operators: `p && x`, `p || x`, `p ?? x`;
-//   - array iteration: `.forEach(async fn)` where the callback returns
-//     a Promise the iteration never observes.
-//
-// JSX event-handler positions and arbitrary user-defined
-// void-callback contracts are deferred — they need a richer expected-
-// type inspection than this baseline.
-type noMisusedPromises struct{}
-
-func (noMisusedPromises) Name() string { return "typescript/no-misused-promises" }
-func (noMisusedPromises) NeedsTypeChecker() bool {
-  return true
-}
-func (noMisusedPromises) Visits() []shimast.Kind {
-  return []shimast.Kind{
-    shimast.KindIfStatement,
-    shimast.KindWhileStatement,
-    shimast.KindDoStatement,
-    shimast.KindForStatement,
-    shimast.KindConditionalExpression,
-    shimast.KindPrefixUnaryExpression,
-    shimast.KindBinaryExpression,
-    shimast.KindCallExpression,
-  }
-}
-func (noMisusedPromises) Check(ctx *Context, node *shimast.Node) {
-  if ctx.Checker == nil {
-    return
-  }
-  switch node.Kind {
-  case shimast.KindIfStatement:
-    if stmt := node.AsIfStatement(); stmt != nil {
-      noMisusedPromisesReportConditional(ctx, stmt.Expression)
-    }
-  case shimast.KindWhileStatement:
-    if stmt := node.AsWhileStatement(); stmt != nil {
-      noMisusedPromisesReportConditional(ctx, stmt.Expression)
-    }
-  case shimast.KindDoStatement:
-    if stmt := node.AsDoStatement(); stmt != nil {
-      noMisusedPromisesReportConditional(ctx, stmt.Expression)
-    }
-  case shimast.KindForStatement:
-    if stmt := node.AsForStatement(); stmt != nil {
-      noMisusedPromisesReportConditional(ctx, stmt.Condition)
-    }
-  case shimast.KindConditionalExpression:
-    if expr := node.AsConditionalExpression(); expr != nil {
-      noMisusedPromisesReportConditional(ctx, expr.Condition)
-    }
-  case shimast.KindPrefixUnaryExpression:
-    expr := node.AsPrefixUnaryExpression()
-    if expr != nil && expr.Operator == shimast.KindExclamationToken {
-      noMisusedPromisesReportConditional(ctx, expr.Operand)
-    }
-  case shimast.KindBinaryExpression:
-    bin := node.AsBinaryExpression()
-    if bin == nil || bin.OperatorToken == nil {
-      return
-    }
-    switch bin.OperatorToken.Kind {
-    case shimast.KindAmpersandAmpersandToken,
-      shimast.KindBarBarToken,
-      shimast.KindQuestionQuestionToken:
-      noMisusedPromisesReportConditional(ctx, bin.Left)
-    }
-  case shimast.KindCallExpression:
-    if call := node.AsCallExpression(); call != nil {
-      noMisusedPromisesCheckVoidCallback(ctx, call)
-    }
-  }
-}
-
-// noMisusedPromisesReportConditional reports expr if it carries a
-// Promise type. `await x` and `void x` are author-acknowledged opt-outs
-// and pass through. `any` / `unknown` / `never` are intentionally NOT
-// flagged because they propagate from generic helpers and would
-// produce overwhelming false-positive volume in real codebases.
-func noMisusedPromisesReportConditional(ctx *Context, expr *shimast.Node) {
-  target := stripParens(expr)
-  if target == nil {
-    return
-  }
-  switch target.Kind {
-  case shimast.KindAwaitExpression, shimast.KindVoidExpression:
-    return
-  }
-  t := ctx.Checker.GetTypeAtLocation(target)
-  if t == nil || !isPromiseTypedExpression(ctx.Checker, t) {
-    return
-  }
-  ctx.Report(target, "Expected non-Promise value in a boolean conditional position; did you forget `await`?")
-}
-
-// noMisusedPromisesCheckVoidCallback fires when an async callback is
-// passed to a method that expects a void-returning callback. The
-// baseline targets the most common offender — `Array.prototype.forEach`
-// — by name rather than by signature inspection. Restricting to
-// `forEach` keeps the false-positive rate low; richer void-callback
-// detection (e.g., JSX event handlers, user methods with `void` in
-// their signature) is deferred.
-func noMisusedPromisesCheckVoidCallback(ctx *Context, call *shimast.CallExpression) {
-  if call == nil || call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
-    return
-  }
-  _, method, ok := promisePropertyAccessParts(call.Expression)
-  if !ok || method != "forEach" {
-    return
-  }
-  callback := stripParens(call.Arguments.Nodes[0])
-  if callback == nil || !isFunctionLikeKind(callback) {
-    return
-  }
-  if !hasAsyncModifier(callback) {
-    return
-  }
-  ctx.Report(callback, "Async callback passed to forEach — the returned Promise will be discarded; use `for ... of` instead.")
-}
-
 // useUnknownInCatchCallbackVariable requires the parameter of `.catch`
 // and the second parameter of `.then` to be explicitly typed `unknown`.
 // TypeScript 4.4+ types `try { } catch (e)` as `unknown` by default;
@@ -393,7 +263,6 @@ func onlyThrowErrorIsPrimitive(checker *shimchecker.Checker, t *shimchecker.Type
 
 func init() {
   Register(requireAwait{})
-  Register(noMisusedPromises{})
   Register(useUnknownInCatchCallbackVariable{})
   Register(onlyThrowError{})
 }

package/linthost/rules_ts_no_base_to_string.go

@@ -130,10 +130,9 @@ func isStringLikeType(t *shimchecker.Type) bool {
 
 // isSafeToStringType reports whether `t` can be implicitly coerced to a
 // string without producing the default `Object.prototype.toString`
-// output. The shape mirrors `isAwaitable` in rules_promise.go: union
-// constituents must all be safe; intersection constituents are safe
-// when any one of them is. The `any` / `unknown` / `never` cases pass
-// because flagging them would explode at generic-helper boundaries —
+// output. Union constituents must all be safe; intersection constituents
+// are safe when any one of them is. The `any` / `unknown` / `never` cases
+// pass because flagging them would explode at generic-helper boundaries —
 // the same conservatism `no-floating-promises` adopts.
 func isSafeToStringType(checker *shimchecker.Checker, t *shimchecker.Type) bool {
   if checker == nil || t == nil {