@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

package/linthost/rules_no_else_return.go

@@ -0,0 +1,75 @@
+// noElseReturn: when an `if` block ends in a `return` / `throw` /
+// `break` / `continue` statement, the matching `else` block is
+// redundant — control already left the function (or loop), so flatten
+// the `else` body into the surrounding scope to keep one less level of
+// nesting and one less branch to read.
+// https://eslint.org/docs/latest/rules/no-else-return
+//
+// AST-only: each visited `IfStatement` whose `ThenStatement` provably
+// terminates control flow on every branch reports on the `else`
+// keyword. A `then` branch terminates when:
+//
+//   - it is itself a terminating statement (`return`, `throw`, etc.), or
+//   - it is a `Block` whose final statement terminates AND every
+//     `if/else if/else` chain inside it terminates on every leaf, or
+//   - it is an `IfStatement` whose `then` AND `else` both terminate
+//     (chained early returns).
+//
+// The analysis is conservative; ambiguous shapes (e.g. an `if` with no
+// `else`, or a loop with `break` only) are left alone.
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type noElseReturn struct{}
+
+func (noElseReturn) Name() string { return "no-else-return" }
+func (noElseReturn) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindIfStatement}
+}
+func (noElseReturn) Check(ctx *Context, node *shimast.Node) {
+	ifStmt := node.AsIfStatement()
+	if ifStmt == nil || ifStmt.ElseStatement == nil {
+		return
+	}
+	if !noElseReturnTerminates(ifStmt.ThenStatement) {
+		return
+	}
+	ctx.Report(ifStmt.ElseStatement, "Remove the `else` — the preceding branch already terminates.")
+}
+
+func noElseReturnTerminates(stmt *shimast.Node) bool {
+	if stmt == nil {
+		return false
+	}
+	switch stmt.Kind {
+	case shimast.KindReturnStatement,
+		shimast.KindThrowStatement,
+		shimast.KindBreakStatement,
+		shimast.KindContinueStatement:
+		return true
+	case shimast.KindBlock:
+		block := stmt.AsBlock()
+		if block == nil || block.Statements == nil {
+			return false
+		}
+		stmts := block.Statements.Nodes
+		if len(stmts) == 0 {
+			return false
+		}
+		return noElseReturnTerminates(stmts[len(stmts)-1])
+	case shimast.KindIfStatement:
+		inner := stmt.AsIfStatement()
+		if inner == nil || inner.ElseStatement == nil {
+			return false
+		}
+		return noElseReturnTerminates(inner.ThenStatement) && noElseReturnTerminates(inner.ElseStatement)
+	}
+	return false
+}
+
+func init() {
+	Register(noElseReturn{})
+}

package/linthost/rules_no_empty_named_blocks.go

@@ -0,0 +1,91 @@
+// no-empty-named-blocks: empty `{}` clauses on import or export
+// declarations bind nothing and almost always indicate a mid-edit
+// mistake or a leftover marker. ESLint suggestions / extra-rules:
+// https://eslint.org/docs/latest/rules/no-empty-named-blocks
+//
+// Three shapes fire the rule:
+//
+//   - `import {} from "x"` — only the side-effect load remains; write
+//     `import "x"` instead if that is the intent.
+//   - `import name, {} from "x"` — once a default binding is present the
+//     `{}` adds nothing; drop the empty clause.
+//   - `export {}` — restates module-ness redundantly, or marks an
+//     otherwise non-module file in a way that has cleaner alternatives
+//     (`no-useless-empty-export` is the stricter sibling that fires
+//     only when another module-syntax statement is already present).
+//
+// AST-only; the rule never consults the Checker.
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type noEmptyNamedBlocks struct{}
+
+func (noEmptyNamedBlocks) Name() string { return "no-empty-named-blocks" }
+func (noEmptyNamedBlocks) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindImportDeclaration, shimast.KindExportDeclaration}
+}
+func (noEmptyNamedBlocks) Check(ctx *Context, node *shimast.Node) {
+	switch node.Kind {
+	case shimast.KindImportDeclaration:
+		noEmptyNamedBlocksCheckImport(ctx, node)
+	case shimast.KindExportDeclaration:
+		noEmptyNamedBlocksCheckExport(ctx, node)
+	}
+}
+
+// noEmptyNamedBlocksCheckImport flags `import {} from "x"` and
+// `import name, {} from "x"`. The empty-clause-only form should become
+// a bare `import "x"`; the default-plus-empty form should drop the
+// empty clause and keep the default binding.
+func noEmptyNamedBlocksCheckImport(ctx *Context, node *shimast.Node) {
+	decl := node.AsImportDeclaration()
+	if decl == nil || decl.ImportClause == nil {
+		return
+	}
+	clause := decl.ImportClause.AsImportClause()
+	if clause == nil {
+		return
+	}
+	if clause.NamedBindings == nil {
+		return
+	}
+	if clause.NamedBindings.Kind != shimast.KindNamedImports {
+		return
+	}
+	named := clause.NamedBindings.AsNamedImports()
+	if named == nil || named.Elements == nil || len(named.Elements.Nodes) > 0 {
+		return
+	}
+	// Two shapes both reach here:
+	//   `import {} from "x"`           — clause.Name() == nil
+	//   `import name, {} from "x"`     — clause.Name() != nil
+	// Either way the empty `{}` is what the rule blames; the report
+	// target is the empty named-imports node so the highlight points at
+	// the `{}` token, not the whole declaration.
+	ctx.Report(clause.NamedBindings, "Unexpected empty named import block.")
+}
+
+// noEmptyNamedBlocksCheckExport flags `export {}` (with or without a
+// `from "x"` source). The form is always rewritable to either nothing
+// or a bare side-effect `import "x"`; the rule's role is to surface it
+// uniformly across both module and non-module sources, leaving
+// `no-useless-empty-export` to gate the narrower redundant-marker case.
+func noEmptyNamedBlocksCheckExport(ctx *Context, node *shimast.Node) {
+	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, "Unexpected empty named export block.")
+}
+
+func init() {
+	Register(noEmptyNamedBlocks{})
+}

package/linthost/rules_no_extend_native.go

@@ -0,0 +1,51 @@
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// noExtendNative: forbid assignments to `<Builtin>.prototype.<key>`,
+// which mutate a shared global and leak across the entire realm.
+// https://eslint.org/docs/latest/rules/no-extend-native
+type noExtendNative struct{}
+
+func (noExtendNative) Name() string           { return "no-extend-native" }
+func (noExtendNative) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (noExtendNative) Check(ctx *Context, node *shimast.Node) {
+  expr := node.AsBinaryExpression()
+  if expr == nil || expr.OperatorToken == nil {
+    return
+  }
+  if expr.OperatorToken.Kind != shimast.KindEqualsToken {
+    return
+  }
+  outer := stripParens(expr.Left)
+  if outer == nil || outer.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  receiver := stripParens(outer.AsPropertyAccessExpression().Expression)
+  if receiver == nil || receiver.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  inner := receiver.AsPropertyAccessExpression()
+  if identifierText(inner.Name()) != "prototype" {
+    return
+  }
+  builtin := identifierText(stripParens(inner.Expression))
+  if !isExtendNativeBuiltin(builtin) {
+    return
+  }
+  ctx.Report(node, builtin+" prototype is read only, properties should not be added.")
+}
+
+func isExtendNativeBuiltin(name string) bool {
+  switch name {
+  case "Object", "Array", "String", "Number", "Boolean", "Function",
+    "Date", "RegExp", "Error", "Map", "Set", "WeakMap", "WeakSet",
+    "Promise", "Symbol":
+    return true
+  }
+  return false
+}
+
+func init() {
+  Register(noExtendNative{})
+}

package/linthost/rules_no_import_assign.go

@@ -0,0 +1,140 @@
+// noImportAssign: writes to a binding introduced by an `import`
+// declaration. Imported bindings are read-only at runtime; mutating
+// them either throws under strict mode or silently desynchronises the
+// module's view of its own exports.
+//
+// Conservative scope tracking: collect the local names introduced by
+// every `import` declaration in the file (default specifier, named
+// specifier, namespace alias), then walk descendants once and flag
+// `name = …` / `name op= …` / `++name` / `name--` assignments whose
+// left-hand side is one of those names. Namespace imports are also
+// flagged on `ns.foo = …` / `++ns.foo` because the namespace object
+// is itself frozen — mutating any property throws in strict mode.
+//
+// Like `no-param-reassign`, this is an AST-only baseline: a later
+// `const name = …` inside an inner scope that shadows an imported
+// name will produce a false positive. Proper resolution needs the
+// real binder, which the AST-only baseline avoids.
+// https://eslint.org/docs/latest/rules/no-import-assign
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type noImportAssign struct{}
+
+func (noImportAssign) Name() string           { return "no-import-assign" }
+func (noImportAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+func (noImportAssign) Check(ctx *Context, node *shimast.Node) {
+	if node == nil {
+		return
+	}
+	imported := map[string]bool{}
+	namespaces := map[string]bool{}
+	collectImportedBindings(node, imported, namespaces)
+	if len(imported) == 0 {
+		return
+	}
+	walkDescendants(node, func(n *shimast.Node) {
+		switch n.Kind {
+		case shimast.KindBinaryExpression:
+			expr := n.AsBinaryExpression()
+			if expr == nil || expr.OperatorToken == nil || !isAssignmentOperator(expr.OperatorToken.Kind) {
+				return
+			}
+			reportImportTarget(ctx, expr.Left, imported, namespaces)
+		case shimast.KindPrefixUnaryExpression:
+			pre := n.AsPrefixUnaryExpression()
+			if pre == nil || (pre.Operator != shimast.KindPlusPlusToken && pre.Operator != shimast.KindMinusMinusToken) {
+				return
+			}
+			reportImportTarget(ctx, pre.Operand, imported, namespaces)
+		case shimast.KindPostfixUnaryExpression:
+			post := n.AsPostfixUnaryExpression()
+			if post == nil || (post.Operator != shimast.KindPlusPlusToken && post.Operator != shimast.KindMinusMinusToken) {
+				return
+			}
+			reportImportTarget(ctx, post.Operand, imported, namespaces)
+		}
+	})
+}
+
+// collectImportedBindings walks every `import` declaration in `file` and
+// records the local names introduced. Namespace bindings (`* as ns`) are
+// additionally remembered so callers can flag property mutations like
+// `ns.foo = …`.
+func collectImportedBindings(file *shimast.Node, imported, namespaces map[string]bool) {
+	walkDescendants(file, func(n *shimast.Node) {
+		if n == nil || n.Kind != shimast.KindImportDeclaration {
+			return
+		}
+		decl := n.AsImportDeclaration()
+		if decl == nil || decl.ImportClause == nil {
+			return
+		}
+		clause := decl.ImportClause.AsImportClause()
+		if clause == nil {
+			return
+		}
+		// `import Default from "x"` — default specifier.
+		if name := identifierText(clause.Name()); name != "" {
+			imported[name] = true
+		}
+		if clause.NamedBindings == nil {
+			return
+		}
+		switch clause.NamedBindings.Kind {
+		case shimast.KindNamedImports:
+			named := clause.NamedBindings.AsNamedImports()
+			if named == nil || named.Elements == nil {
+				return
+			}
+			for _, specNode := range named.Elements.Nodes {
+				spec := specNode.AsImportSpecifier()
+				if spec == nil {
+					continue
+				}
+				if name := identifierText(spec.Name()); name != "" {
+					imported[name] = true
+				}
+			}
+		case shimast.KindNamespaceImport:
+			ns := clause.NamedBindings.AsNamespaceImport()
+			if ns == nil {
+				return
+			}
+			if name := identifierText(ns.Name()); name != "" {
+				imported[name] = true
+				namespaces[name] = true
+			}
+		}
+	})
+}
+
+// reportImportTarget flags `target` when it writes to an imported name.
+// A bare identifier matching an imported binding is always flagged; a
+// `ns.<key>` property access is flagged when `ns` is a namespace import.
+func reportImportTarget(ctx *Context, target *shimast.Node, imported, namespaces map[string]bool) {
+	stripped := stripParens(target)
+	if stripped == nil {
+		return
+	}
+	if name := identifierText(stripped); name != "" {
+		if imported[name] {
+			ctx.Report(target, "'"+name+"' is read-only.")
+		}
+		return
+	}
+	if stripped.Kind == shimast.KindPropertyAccessExpression {
+		access := stripped.AsPropertyAccessExpression()
+		if access == nil || access.Expression == nil {
+			return
+		}
+		if ns := identifierText(stripParens(access.Expression)); ns != "" && namespaces[ns] {
+			ctx.Report(target, "The members of '"+ns+"' are read-only.")
+		}
+	}
+}
+
+func init() {
+	Register(noImportAssign{})
+}

package/linthost/rules_no_invalid_this.go

@@ -0,0 +1,52 @@
+// noInvalidThis: reject `this` references that have no meaningful
+// binding — that is, `this` used outside any function-like context or
+// class static block. At the top level of a module (and in strict-mode
+// scripts) `this` is `undefined`, so reading from it usually signals a
+// copy-paste from a class method.
+//
+// Arrow functions inherit `this` from their enclosing lexical scope, so
+// the rule walks past arrow boundaries when searching for a binding
+// site. Plain function declarations, function expressions, methods,
+// accessors, constructors, and class static blocks each create their
+// own `this` and stop the walk.
+// https://eslint.org/docs/latest/rules/no-invalid-this
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type noInvalidThis struct{}
+
+func (noInvalidThis) Name() string           { return "no-invalid-this" }
+func (noInvalidThis) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindThisKeyword} }
+func (noInvalidThis) Check(ctx *Context, node *shimast.Node) {
+	if hasThisBindingAncestor(node) {
+		return
+	}
+	ctx.Report(node, "Unexpected 'this'.")
+}
+
+// hasThisBindingAncestor reports whether `node` is lexically enclosed by
+// a construct that defines its own `this`. Arrow functions are skipped
+// because they capture `this` from the surrounding scope; the walk only
+// stops on a real binding site or at the SourceFile root.
+func hasThisBindingAncestor(node *shimast.Node) bool {
+	for cur := node.Parent; cur != nil; cur = cur.Parent {
+		switch cur.Kind {
+		case shimast.KindFunctionDeclaration,
+			shimast.KindFunctionExpression,
+			shimast.KindMethodDeclaration,
+			shimast.KindGetAccessor,
+			shimast.KindSetAccessor,
+			shimast.KindConstructor,
+			shimast.KindClassStaticBlockDeclaration:
+			return true
+		}
+	}
+	return false
+}
+
+func init() {
+	Register(noInvalidThis{})
+}

package/linthost/rules_no_loop_func.go

@@ -0,0 +1,85 @@
+// noLoopFunc reports a `function` declaration, function expression, or
+// arrow function defined inside the body of a loop. The function value
+// allocated each iteration almost always closes over the loop counter or
+// some other binding that changes between iterations, so a deferred call
+// (timer, microtask, event handler) observes whatever the binding holds
+// at call time — usually the loop's terminal value, never the value the
+// developer reasoned about at the textual position.
+// https://eslint.org/docs/latest/rules/no-loop-func
+//
+// Conservative baseline: every function-like syntactically inside a loop
+// body is flagged. Capture analysis (the rule's full upstream
+// implementation only fires when the function actually closes over a
+// `let` / `var` / `const` declared outside) is deferred; the false-
+// positive rate is acceptable because the fix — hoist the function out
+// of the loop — is almost always the cleaner code in either case.
+//
+// The walk stops at nested loop boundaries — each enclosing loop visits
+// itself once, so an inner loop reports its own nested function-likes
+// and the outer loop only owns the function-likes directly inside it.
+// Inner function-likes are also boundaries: a closure inside an outer
+// function-likes is that inner scope's problem.
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type noLoopFunc struct{}
+
+func (noLoopFunc) Name() string { return "no-loop-func" }
+func (noLoopFunc) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindForStatement,
+		shimast.KindForInStatement,
+		shimast.KindForOfStatement,
+		shimast.KindWhileStatement,
+		shimast.KindDoStatement,
+	}
+}
+func (noLoopFunc) Check(ctx *Context, node *shimast.Node) {
+	var walk func(n *shimast.Node)
+	walk = func(n *shimast.Node) {
+		if n == nil {
+			return
+		}
+		if isFunctionLikeKind(n) {
+			ctx.Report(n, "Function declared in a loop closes over the loop's bindings — hoist it out.")
+			return
+		}
+		if n != node && isLoopKind(n) {
+			// Nested loops report their own contents when visited.
+			return
+		}
+		n.ForEachChild(func(child *shimast.Node) bool {
+			walk(child)
+			return false
+		})
+	}
+	node.ForEachChild(func(child *shimast.Node) bool {
+		walk(child)
+		return false
+	})
+}
+
+// isLoopKind reports whether n is one of the loop statement kinds this
+// rule visits. Used to stop the walk at a nested loop boundary so each
+// loop reports only the function-likes directly inside its own body.
+func isLoopKind(n *shimast.Node) bool {
+	if n == nil {
+		return false
+	}
+	switch n.Kind {
+	case shimast.KindForStatement,
+		shimast.KindForInStatement,
+		shimast.KindForOfStatement,
+		shimast.KindWhileStatement,
+		shimast.KindDoStatement:
+		return true
+	}
+	return false
+}
+
+func init() {
+	Register(noLoopFunc{})
+}

package/linthost/rules_no_magic_numbers.go

@@ -0,0 +1,123 @@
+// noMagicNumbers reports a numeric literal that appears in a position
+// other than the initializer of a `const` declaration. Magic numbers
+// scattered through expressions make a reader pause: a literal `60`
+// inside a multiplication says nothing about whether it stands for
+// seconds, frames, or items-per-page, while the same number bound to a
+// `const SECONDS_PER_MINUTE = 60` carries its meaning along with it.
+//
+// Conservative baseline:
+//
+//   - Three numbers are silently ignored — `0`, `1`, and `-1`. The
+//     first two are pervasive in counters and identity-style code; the
+//     third is the canonical "not-found" return from `indexOf` and
+//     similar APIs. Flagging them produces nothing but noise.
+//   - A numeric literal that is the initializer of a `const x = …`
+//     declaration is the named binding the rule is asking for, so it
+//     is not flagged.
+//   - A numeric literal that is the index of a `KindElementAccessExpression`
+//     (`arr[0]`, `tuple[3]`) is treated as an array index and ignored;
+//     ESLint's `ignoreArrayIndexes` option is on by default here.
+//   - A numeric literal that initializes an `enum` member is the
+//     binding's value, not a magic number — enums exist precisely to
+//     give numeric values names, so the value position is the point of
+//     the construct.
+//
+// https://eslint.org/docs/latest/rules/no-magic-numbers
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type noMagicNumbers struct{}
+
+func (noMagicNumbers) Name() string { return "no-magic-numbers" }
+func (noMagicNumbers) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindNumericLiteral}
+}
+func (noMagicNumbers) Check(ctx *Context, node *shimast.Node) {
+	if node == nil {
+		return
+	}
+	text := numericLiteralText(node)
+	if isIgnoredMagicLiteralText(text) {
+		return
+	}
+	parent := node.Parent
+	if parent == nil {
+		return
+	}
+	// `-N` is a PrefixUnaryExpression whose Operand is the literal. The
+	// `-1` ignore list lives on the unary expression's combined text;
+	// recognize the negated form here so the rule does not flag the `1`
+	// inside `-1`.
+	if parent.Kind == shimast.KindPrefixUnaryExpression {
+		pre := parent.AsPrefixUnaryExpression()
+		if pre != nil && pre.Operator == shimast.KindMinusToken && text == "1" {
+			return
+		}
+	}
+	// Initializer of a `const x = N` declaration: the named binding the
+	// rule wants users to introduce.
+	if isConstVariableInitializer(parent, node) {
+		return
+	}
+	// Enum member value: `enum E { A = 0, B = 1 }` — the literal is
+	// the binding's value position, so leave it alone.
+	if parent.Kind == shimast.KindEnumMember {
+		return
+	}
+	// `arr[0]` / `tuple[3]`: numeric index position of an element access.
+	if isArrayIndexArgument(parent, node) {
+		return
+	}
+	ctx.Report(node, "No magic number: "+text+".")
+}
+
+// isIgnoredMagicLiteralText reports whether the literal text falls into
+// the always-ignored set. `-1` is handled by the caller (the leading
+// minus lives on a PrefixUnaryExpression parent), so the table here only
+// needs the two zero / one shapes.
+func isIgnoredMagicLiteralText(text string) bool {
+	switch text {
+	case "0", "1":
+		return true
+	}
+	return false
+}
+
+// isConstVariableInitializer reports whether `literal` sits in the
+// Initializer slot of a `const x = literal` VariableDeclaration. `let`
+// and `var` are deliberately excluded — a `let x = 60` binding can be
+// reassigned, so the number is still magic in the position it was
+// written.
+func isConstVariableInitializer(parent, literal *shimast.Node) bool {
+	if parent == nil || parent.Kind != shimast.KindVariableDeclaration {
+		return false
+	}
+	decl := parent.AsVariableDeclaration()
+	if decl == nil || decl.Initializer != literal {
+		return false
+	}
+	return shimast.IsConst(parent)
+}
+
+// isArrayIndexArgument reports whether `literal` sits in the
+// ArgumentExpression slot of a `target[literal]` ElementAccessExpression.
+// ESLint calls this `ignoreArrayIndexes`; the rule's conservative
+// baseline enables it because mixing numeric subscripts with renamed
+// constants reads worse than the literal.
+func isArrayIndexArgument(parent, literal *shimast.Node) bool {
+	if parent == nil || parent.Kind != shimast.KindElementAccessExpression {
+		return false
+	}
+	access := parent.AsElementAccessExpression()
+	if access == nil {
+		return false
+	}
+	return access.ArgumentExpression == literal
+}
+
+func init() {
+	Register(noMagicNumbers{})
+}