@ttsc/lint 0.13.1 → 0.14.0-dev.20250530.1

package/linthost/rules_ts_extra.go

@@ -11,10 +11,10 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
-// no-confusing-non-null-assertion: `a! == b` reads ambiguously.
+// noConfusingNonNullAssertion: `a! == b` reads ambiguously.
 type noConfusingNonNullAssertion struct{}
 
-func (noConfusingNonNullAssertion) Name() string { return "no-confusing-non-null-assertion" }
+func (noConfusingNonNullAssertion) Name() string { return "typescript/no-confusing-non-null-assertion" }
 func (noConfusingNonNullAssertion) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindBinaryExpression}
 }
@@ -37,11 +37,11 @@ func (noConfusingNonNullAssertion) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-duplicate-enum-values: `enum E { A = 1, B = 1 }` — duplicate values
+// noDuplicateEnumValues: `enum E { A = 1, B = 1 }` — duplicate values
 // silently collapse.
 type noDuplicateEnumValues struct{}
 
-func (noDuplicateEnumValues) Name() string { return "no-duplicate-enum-values" }
+func (noDuplicateEnumValues) Name() string { return "typescript/no-duplicate-enum-values" }
 func (noDuplicateEnumValues) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindEnumDeclaration}
 }
@@ -77,13 +77,13 @@ func (noDuplicateEnumValues) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-mixed-enums: forbid enums that mix numeric and string member shapes.
+// noMixedEnums: forbid enums that mix numeric and string member shapes.
 // A single enum with `{ A, B = "two" }` produces broken reverse mappings
 // and surprising assignability. typescript-eslint recommended:
 // https://typescript-eslint.io/rules/no-mixed-enums/
 type noMixedEnums struct{}
 
-func (noMixedEnums) Name() string { return "no-mixed-enums" }
+func (noMixedEnums) Name() string { return "typescript/no-mixed-enums" }
 func (noMixedEnums) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindEnumDeclaration}
 }
@@ -137,10 +137,10 @@ func (noMixedEnums) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-extra-non-null-assertion: `a!!` / `a!?.b` collapses two assertions.
+// noExtraNonNullAssertion: `a!!` / `a!?.b` collapses two assertions.
 type noExtraNonNullAssertion struct{}
 
-func (noExtraNonNullAssertion) Name() string { return "no-extra-non-null-assertion" }
+func (noExtraNonNullAssertion) Name() string { return "typescript/no-extra-non-null-assertion" }
 func (noExtraNonNullAssertion) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindNonNullExpression}
 }
@@ -169,11 +169,13 @@ func (noExtraNonNullAssertion) Check(ctx *Context, node *shimast.Node) {
   )
 }
 
-// no-non-null-asserted-optional-chain: `foo?.bar!` — the chain produces
+// noNonNullAssertedOptionalChain: `foo?.bar!` — the chain produces
 // undefined; asserting non-null on the whole chain defeats the chain.
 type noNonNullAssertedOptionalChain struct{}
 
-func (noNonNullAssertedOptionalChain) Name() string { return "no-non-null-asserted-optional-chain" }
+func (noNonNullAssertedOptionalChain) Name() string {
+  return "typescript/no-non-null-asserted-optional-chain"
+}
 func (noNonNullAssertedOptionalChain) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindNonNullExpression}
 }
@@ -224,12 +226,12 @@ func containsOptionalChain(node *shimast.Node) bool {
   return false
 }
 
-// no-misused-new: declaring a `new` signature on a non-class interface
+// noMisusedNew: declaring a `new` signature on a non-class interface
 // or a `constructor` method on an interface — these don't do what
 // authors expect.
 type noMisusedNew struct{}
 
-func (noMisusedNew) Name() string { return "no-misused-new" }
+func (noMisusedNew) Name() string { return "typescript/no-misused-new" }
 func (noMisusedNew) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindInterfaceDeclaration, shimast.KindTypeAliasDeclaration}
 }
@@ -257,11 +259,109 @@ func (noMisusedNew) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// prefer-enum-initializers: every enum member should have an explicit
+// noUnnecessaryParameterPropertyAssignment: parameter properties already
+// assign the constructor argument to `this.<name>` before the body runs.
+// A body-level `this.x = x` immediately repeats that initialization.
+type noUnnecessaryParameterPropertyAssignment struct{}
+
+func (noUnnecessaryParameterPropertyAssignment) Name() string {
+  return "typescript/no-unnecessary-parameter-property-assignment"
+}
+func (noUnnecessaryParameterPropertyAssignment) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindConstructor}
+}
+func (noUnnecessaryParameterPropertyAssignment) Check(ctx *Context, node *shimast.Node) {
+  parameterProperties := map[string]bool{}
+  for _, param := range node.Parameters() {
+    name, ok := parameterPropertyName(param)
+    if ok {
+      parameterProperties[name] = true
+    }
+  }
+  if len(parameterProperties) == 0 {
+    return
+  }
+  body := node.Body()
+  if body == nil || body.Kind != shimast.KindBlock {
+    return
+  }
+  block := body.AsBlock()
+  if block == nil || block.Statements == nil {
+    return
+  }
+  assigned := map[string]bool{}
+  for _, stmt := range block.Statements.Nodes {
+    property, value, ok := thisPropertyAssignment(stmt)
+    if !ok {
+      continue
+    }
+    if parameterProperties[property] && !assigned[property] && value == property {
+      ctx.Report(stmt, "This assignment repeats the constructor parameter property initialization.")
+    }
+    assigned[property] = true
+  }
+}
+
+func parameterPropertyName(param *shimast.Node) (string, bool) {
+  if param == nil || param.Kind != shimast.KindParameter {
+    return "", false
+  }
+  if !isParameterProperty(param) {
+    return "", false
+  }
+  decl := param.AsParameterDeclaration()
+  if decl == nil {
+    return "", false
+  }
+  name := identifierText(decl.Name())
+  return name, name != ""
+}
+
+func isParameterProperty(param *shimast.Node) bool {
+  return hasModifier(param, shimast.KindPublicKeyword) ||
+    hasModifier(param, shimast.KindPrivateKeyword) ||
+    hasModifier(param, shimast.KindProtectedKeyword) ||
+    hasModifier(param, shimast.KindReadonlyKeyword) ||
+    hasModifier(param, shimast.KindOverrideKeyword)
+}
+
+func thisPropertyAssignment(stmt *shimast.Node) (property string, value string, ok bool) {
+  if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
+    return "", "", false
+  }
+  exprStmt := stmt.AsExpressionStatement()
+  if exprStmt == nil || exprStmt.Expression == nil {
+    return "", "", false
+  }
+  expr := stripParens(exprStmt.Expression)
+  if expr == nil || expr.Kind != shimast.KindBinaryExpression {
+    return "", "", false
+  }
+  binary := expr.AsBinaryExpression()
+  if binary == nil || binary.OperatorToken == nil || binary.OperatorToken.Kind != shimast.KindEqualsToken {
+    return "", "", false
+  }
+  left := stripParens(binary.Left)
+  if left == nil || left.Kind != shimast.KindPropertyAccessExpression {
+    return "", "", false
+  }
+  access := left.AsPropertyAccessExpression()
+  if access == nil || access.Expression == nil || access.Expression.Kind != shimast.KindThisKeyword {
+    return "", "", false
+  }
+  property = identifierText(access.Name())
+  value = identifierText(stripParens(binary.Right))
+  if property == "" {
+    return "", "", false
+  }
+  return property, value, true
+}
+
+// preferEnumInitializers: every enum member should have an explicit
 // initializer (avoids order-dependent values).
 type preferEnumInitializers struct{}
 
-func (preferEnumInitializers) Name() string { return "prefer-enum-initializers" }
+func (preferEnumInitializers) Name() string { return "typescript/prefer-enum-initializers" }
 func (preferEnumInitializers) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindEnumDeclaration}
 }
@@ -281,7 +381,7 @@ func (preferEnumInitializers) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// prefer-for-of: `for (let i = 0; i < arr.length; i++) { use(arr[i]) }`
+// preferForOf: `for (let i = 0; i < arr.length; i++) { use(arr[i]) }`
 // can usually be replaced with `for (const x of arr) { use(x); }`.
 type preferForOf struct{}
 
@@ -351,13 +451,13 @@ func isCounterIncrement(node *shimast.Node, counter string) bool {
   return false
 }
 
-// prefer-function-type: a single-call-signature interface or type alias
+// preferFunctionType: a single-call-signature interface or type alias
 // is more readably written as a function type.
 //
 //  interface F { (x: number): string }   -> type F = (x: number) => string
 type preferFunctionType struct{}
 
-func (preferFunctionType) Name() string { return "prefer-function-type" }
+func (preferFunctionType) Name() string { return "typescript/prefer-function-type" }
 func (preferFunctionType) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindInterfaceDeclaration}
 }
@@ -376,11 +476,30 @@ func (preferFunctionType) Check(ctx *Context, node *shimast.Node) {
   ctx.Report(node, "Interface only has a call signature; use 'type' alias and function type instead.")
 }
 
-// prefer-namespace-keyword: `module Foo {}` (TS namespace via `module`
+// methodSignatureStyle: prefer function-property signatures over method
+// shorthand in interfaces and type literals. This implements the default
+// @typescript-eslint mode (`property`) as a diagnostic-only rule.
+type methodSignatureStyle struct{}
+
+func (methodSignatureStyle) Name() string { return "typescript/method-signature-style" }
+func (methodSignatureStyle) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindMethodSignature}
+}
+func (methodSignatureStyle) Check(ctx *Context, node *shimast.Node) {
+  if node.Parent == nil {
+    return
+  }
+  switch node.Parent.Kind {
+  case shimast.KindInterfaceDeclaration, shimast.KindTypeLiteral:
+    ctx.Report(node, "Use a function-property signature instead of a method signature.")
+  }
+}
+
+// preferNamespaceKeyword: `module Foo {}` (TS namespace via `module`
 // keyword) → `namespace Foo {}`.
 type preferNamespaceKeyword struct{}
 
-func (preferNamespaceKeyword) Name() string { return "prefer-namespace-keyword" }
+func (preferNamespaceKeyword) Name() string { return "typescript/prefer-namespace-keyword" }
 func (preferNamespaceKeyword) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindModuleDeclaration}
 }
@@ -408,11 +527,11 @@ func (preferNamespaceKeyword) Check(ctx *Context, node *shimast.Node) {
   )
 }
 
-// triple-slash-reference: `/// <reference path="..." />` directives.
+// tripleSlashReference: `/// <reference path="..." />` directives.
 // Discouraged in modern code in favor of `import`.
 type tripleSlashReference struct{}
 
-func (tripleSlashReference) Name() string           { return "triple-slash-reference" }
+func (tripleSlashReference) Name() string           { return "typescript/triple-slash-reference" }
 func (tripleSlashReference) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
 func (tripleSlashReference) Check(ctx *Context, node *shimast.Node) {
   if ctx.File == nil {
@@ -426,10 +545,10 @@ func (tripleSlashReference) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// no-array-delete: `delete arr[0]` leaves a sparse hole. Use `splice`.
+// noArrayDelete: `delete arr[0]` leaves a sparse hole. Use `splice`.
 type noArrayDelete struct{}
 
-func (noArrayDelete) Name() string           { return "no-array-delete" }
+func (noArrayDelete) Name() string           { return "typescript/no-array-delete" }
 func (noArrayDelete) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindDeleteExpression} }
 func (noArrayDelete) Check(ctx *Context, node *shimast.Node) {
   del := node.AsDeleteExpression()
@@ -451,7 +570,7 @@ func (noArrayDelete) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// consistent-type-imports: `import { Foo } from "./types"` where Foo is
+// consistentTypeImports: `import { Foo } from "./types"` where Foo is
 // only used as a type → `import type { Foo } from "./types"`. We
 // approximate by flagging every `import type` candidate where the
 // specifier appears in a type-only context inside the file.
@@ -462,7 +581,7 @@ func (noArrayDelete) Check(ctx *Context, node *shimast.Node) {
 // common case.
 type consistentTypeImports struct{}
 
-func (consistentTypeImports) Name() string { return "consistent-type-imports" }
+func (consistentTypeImports) Name() string { return "typescript/consistent-type-imports" }
 func (consistentTypeImports) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindImportDeclaration}
 }
@@ -549,12 +668,12 @@ func allUsesAreTypeOnly(root *shimast.Node, names []string) bool {
   return allOk
 }
 
-// no-empty-object-type: `interface Foo {}` / `type Foo = {}`. ESLint
+// noEmptyObjectType: `interface Foo {}` / `type Foo = {}`. ESLint
 // flags empty types because they're equivalent to `unknown` (everything
 // satisfies `{}`).
 type noEmptyObjectType struct{}
 
-func (noEmptyObjectType) Name() string           { return "no-empty-object-type" }
+func (noEmptyObjectType) Name() string           { return "typescript/no-empty-object-type" }
 func (noEmptyObjectType) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindTypeLiteral} }
 func (noEmptyObjectType) Check(ctx *Context, node *shimast.Node) {
   lit := node.AsTypeLiteralNode()
@@ -566,10 +685,10 @@ func (noEmptyObjectType) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// array-type: `Array<T>` vs `T[]`. ESLint default mode prefers `T[]`.
+// arrayType: `Array<T>` vs `T[]`. ESLint default mode prefers `T[]`.
 type arrayType struct{}
 
-func (arrayType) Name() string           { return "array-type" }
+func (arrayType) Name() string           { return "typescript/array-type" }
 func (arrayType) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindTypeReference} }
 func (arrayType) Check(ctx *Context, node *shimast.Node) {
   ref := node.AsTypeReferenceNode()
@@ -590,11 +709,13 @@ func (arrayType) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// consistent-indexed-object-style: `{ [key: string]: T }` vs
+// consistentIndexedObjectStyle: `{ [key: string]: T }` vs
 // `Record<string, T>`. ESLint default prefers `Record`.
 type consistentIndexedObjectStyle struct{}
 
-func (consistentIndexedObjectStyle) Name() string { return "consistent-indexed-object-style" }
+func (consistentIndexedObjectStyle) Name() string {
+  return "typescript/consistent-indexed-object-style"
+}
 func (consistentIndexedObjectStyle) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindTypeLiteral}
 }
@@ -611,17 +732,17 @@ func (consistentIndexedObjectStyle) Check(ctx *Context, node *shimast.Node) {
 }
 
 // no-explicit-any-rest-parameter — keeping this distinct from
-// no-explicit-any: rest parameters typed `...args: any[]` are common
+// noExplicitAny: rest parameters typed `...args: any[]` are common
 // enough that users want to allow them; this rule lets them ban that
 // shape specifically.
 //
 // (Skipped: too narrow / overlaps with no-explicit-any.)
 
-// ban-tslint-comment: `// tslint:disable`. tslint is dead; comments
+// banTslintComment: `// tslint:disable`. tslint is dead; comments
 // referencing it should be cleaned up.
 type banTslintComment struct{}
 
-func (banTslintComment) Name() string           { return "ban-tslint-comment" }
+func (banTslintComment) Name() string           { return "typescript/ban-tslint-comment" }
 func (banTslintComment) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
 func (banTslintComment) Check(ctx *Context, node *shimast.Node) {
   if ctx.File == nil {
@@ -644,12 +765,12 @@ func (banTslintComment) Check(ctx *Context, node *shimast.Node) {
   }
 }
 
-// adjacent-overload-signatures: function/method overloads must be
+// adjacentOverloadSignatures: function/method overloads must be
 // declared next to each other. ESLint catches the visual confusion
 // when overloads are interleaved with other members.
 type adjacentOverloadSignatures struct{}
 
-func (adjacentOverloadSignatures) Name() string { return "adjacent-overload-signatures" }
+func (adjacentOverloadSignatures) Name() string { return "typescript/adjacent-overload-signatures" }
 func (adjacentOverloadSignatures) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindInterfaceDeclaration, shimast.KindTypeLiteral, shimast.KindClassDeclaration, shimast.KindClassExpression, shimast.KindModuleBlock, shimast.KindSourceFile}
 }
@@ -764,9 +885,11 @@ func init() {
   Register(noExtraNonNullAssertion{})
   Register(noNonNullAssertedOptionalChain{})
   Register(noMisusedNew{})
+  Register(noUnnecessaryParameterPropertyAssignment{})
   Register(preferEnumInitializers{})
   Register(preferForOf{})
   Register(preferFunctionType{})
+  Register(methodSignatureStyle{})
   Register(preferNamespaceKeyword{})
   Register(tripleSlashReference{})
   Register(noArrayDelete{})

package/linthost/rules_ts_no_base_to_string.go

@@ -0,0 +1,218 @@
+// typescript/no-base-to-string: a string-coercion context that
+// resolves `toString` to the default `Object.prototype.toString`
+// produces the useless `"[object Object]"` placeholder at runtime.
+// typescript-eslint:
+// https://typescript-eslint.io/rules/no-base-to-string/
+//
+// Type-aware. The rule visits the three shapes that implicitly coerce
+// a value through `toString`:
+//
+//   - `${x}` — every interpolated expression in a TemplateExpression;
+//   - `x + y` — when one operand is statically string-typed the other
+//     operand is coerced;
+//   - `String(x)` — explicit one-argument coercion.
+//
+// A type is "safely stringifiable" when it is a primitive-like type
+// (`string`-/`number`-/`bigint`-/`boolean`-like, `null`, `undefined`),
+// when the Checker reports it as `any` / `unknown` / `never` (those
+// escape strict reasoning the same way `await-thenable` lets them
+// pass), or when it overrides `toString` away from the global
+// `Object` interface. Unions are safe only when every constituent is
+// safe; intersections are safe when any constituent is safe.
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+type noBaseToString struct{}
+
+func (noBaseToString) Name() string { return "typescript/no-base-to-string" }
+func (noBaseToString) NeedsTypeChecker() bool {
+  return true
+}
+func (noBaseToString) Visits() []shimast.Kind {
+  return []shimast.Kind{
+    shimast.KindTemplateExpression,
+    shimast.KindBinaryExpression,
+    shimast.KindCallExpression,
+  }
+}
+func (noBaseToString) Check(ctx *Context, node *shimast.Node) {
+  if ctx.Checker == nil {
+    return
+  }
+  switch node.Kind {
+  case shimast.KindTemplateExpression:
+    expr := node.AsTemplateExpression()
+    if expr == nil || expr.TemplateSpans == nil {
+      return
+    }
+    for _, spanNode := range expr.TemplateSpans.Nodes {
+      span := spanNode.AsTemplateSpan()
+      if span == nil || span.Expression == nil {
+        continue
+      }
+      reportIfBaseToString(ctx, span.Expression)
+    }
+  case shimast.KindBinaryExpression:
+    bin := node.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil || bin.OperatorToken.Kind != shimast.KindPlusToken {
+      return
+    }
+    left := stripParens(bin.Left)
+    right := stripParens(bin.Right)
+    if left == nil || right == nil {
+      return
+    }
+    leftType := ctx.Checker.GetTypeAtLocation(left)
+    rightType := ctx.Checker.GetTypeAtLocation(right)
+    if isStringLikeType(leftType) {
+      if !isSafeToStringType(ctx.Checker, rightType) {
+        ctx.Report(right, baseToStringMessage)
+      }
+    } else if isStringLikeType(rightType) {
+      if !isSafeToStringType(ctx.Checker, leftType) {
+        ctx.Report(left, baseToStringMessage)
+      }
+    }
+  case shimast.KindCallExpression:
+    call := node.AsCallExpression()
+    if call == nil || call.Expression == nil || call.Arguments == nil {
+      return
+    }
+    if call.Expression.Kind != shimast.KindIdentifier || identifierText(call.Expression) != "String" {
+      return
+    }
+    if len(call.Arguments.Nodes) != 1 {
+      return
+    }
+    reportIfBaseToString(ctx, call.Arguments.Nodes[0])
+  }
+}
+
+const baseToStringMessage = "Value implicitly coerces to '[object Object]'. Override `toString` or pass an explicit string representation."
+
+func reportIfBaseToString(ctx *Context, expr *shimast.Node) {
+  if expr == nil {
+    return
+  }
+  t := ctx.Checker.GetTypeAtLocation(expr)
+  if isSafeToStringType(ctx.Checker, t) {
+    return
+  }
+  ctx.Report(expr, baseToStringMessage)
+}
+
+// isStringLikeType reports whether t is provably string-typed (a
+// literal, the primitive, a template-literal type, or any combination
+// thereof). Used to decide whether the OTHER operand of a `+`
+// expression is being coerced.
+func isStringLikeType(t *shimchecker.Type) bool {
+  if t == nil {
+    return false
+  }
+  flags := t.Flags()
+  if flags&shimchecker.TypeFlagsStringLike != 0 {
+    return true
+  }
+  if flags&shimchecker.TypeFlagsUnion != 0 {
+    for _, part := range t.Types() {
+      if !isStringLikeType(part) {
+        return false
+      }
+    }
+    return true
+  }
+  return false
+}
+
+// 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 —
+// the same conservatism `no-floating-promises` adopts.
+func isSafeToStringType(checker *shimchecker.Checker, t *shimchecker.Type) bool {
+  if checker == nil || t == nil {
+    return true
+  }
+  flags := t.Flags()
+  if flags&(shimchecker.TypeFlagsAny|shimchecker.TypeFlagsUnknown|shimchecker.TypeFlagsNever) != 0 {
+    return true
+  }
+  if flags&(shimchecker.TypeFlagsStringLike|
+    shimchecker.TypeFlagsNumberLike|
+    shimchecker.TypeFlagsBigIntLike|
+    shimchecker.TypeFlagsBooleanLike|
+    shimchecker.TypeFlagsNull|
+    shimchecker.TypeFlagsUndefined) != 0 {
+    return true
+  }
+  if flags&shimchecker.TypeFlagsUnion != 0 {
+    for _, part := range t.Types() {
+      if !isSafeToStringType(checker, part) {
+        return false
+      }
+    }
+    return true
+  }
+  if flags&shimchecker.TypeFlagsIntersection != 0 {
+    for _, part := range t.Types() {
+      if isSafeToStringType(checker, part) {
+        return true
+      }
+    }
+    return false
+  }
+  return typeOverridesToString(checker, t)
+}
+
+// typeOverridesToString reports whether `t` carries a `toString` method
+// that is NOT the default declaration on the global `Object` interface.
+// The lib.es5.d.ts `Object` interface declares `toString(): string`; a
+// custom override is what makes coercion meaningful at runtime. If no
+// `toString` is reachable at all the type is treated as base — the
+// only way to coerce it is the prototype-chain default.
+func typeOverridesToString(checker *shimchecker.Checker, t *shimchecker.Type) bool {
+  prop := checker.GetPropertyOfType(t, "toString")
+  if prop == nil {
+    return false
+  }
+  for _, decl := range prop.Declarations {
+    if decl == nil {
+      continue
+    }
+    if !isObjectToStringDeclaration(decl) {
+      return true
+    }
+  }
+  return false
+}
+
+// isObjectToStringDeclaration reports whether `decl` is the
+// `toString(): string` member that lives on the global `Object`
+// interface in lib.es5.d.ts. Walking the parent chain stops at the
+// nearest `interface Object {}` / `interface ObjectConstructor {}`
+// declaration; anything else (Array, Date, Error, user classes, etc.)
+// counts as a real override.
+func isObjectToStringDeclaration(decl *shimast.Node) bool {
+  parent := decl.Parent
+  if parent == nil {
+    return false
+  }
+  if parent.Kind != shimast.KindInterfaceDeclaration {
+    return false
+  }
+  iface := parent.AsInterfaceDeclaration()
+  if iface == nil {
+    return false
+  }
+  return identifierText(iface.Name()) == "Object"
+}
+
+func init() {
+  Register(noBaseToString{})
+}

package/linthost/rules_ts_no_confusing_void.go

@@ -0,0 +1,72 @@
+// noConfusingVoidExpression reports `void X` operator uses placed in
+// positions where the surrounding context expects a value. The `void`
+// operator always evaluates to `undefined`, so threading it through a
+// binary expression, ternary, call argument, initializer, or `return`
+// statement is almost always a confusion between the operator and the
+// `void` type.
+//
+// Allowed positions:
+//   - statement: `void x;`
+//   - arrow function concise body: `() => void x`
+//   - operand of an enclosing `void`: `void void x` — only the outer
+//     `void` is checked; the inner one is acceptable as the `void`
+//     operand of another `void`.
+//
+// This rule is AST-only — it does not consult the Checker for the
+// surrounding function's return type, so `return void X` from a
+// `void`-returning function is still reported. This matches the
+// behavior the upstream rule produces with its
+// `ignoreVoidReturningFunctions: false` default.
+//
+// https://typescript-eslint.io/rules/no-confusing-void-expression/
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type noConfusingVoidExpression struct{}
+
+func (noConfusingVoidExpression) Name() string {
+  return "typescript/no-confusing-void-expression"
+}
+func (noConfusingVoidExpression) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindVoidExpression}
+}
+func (noConfusingVoidExpression) Check(ctx *Context, node *shimast.Node) {
+  if isValidVoidExpressionPosition(node) {
+    return
+  }
+  ctx.Report(node, "Placing `void` operator in a value position is confusing — use it only as a statement, an arrow concise body, or inside another `void`.")
+}
+
+// isValidVoidExpressionPosition reports whether the `void X`
+// expression at `node` sits in one of the three permitted positions.
+// Parenthesized expressions are transparent — `(void x)` keeps the
+// same effective context as `void x` for the surrounding code.
+func isValidVoidExpressionPosition(node *shimast.Node) bool {
+  parent := node.Parent
+  for parent != nil && parent.Kind == shimast.KindParenthesizedExpression {
+    node = parent
+    parent = parent.Parent
+  }
+  if parent == nil {
+    return false
+  }
+  switch parent.Kind {
+  case shimast.KindExpressionStatement:
+    return true
+  case shimast.KindVoidExpression:
+    // `void void x` — the inner `void` is the operand of another
+    // `void`, which discards the result anyway.
+    return true
+  case shimast.KindArrowFunction:
+    arrow := parent.AsArrowFunction()
+    return arrow != nil && arrow.Body == node
+  }
+  return false
+}
+
+func init() {
+  Register(noConfusingVoidExpression{})
+}