@ttsc/lint 0.5.0-dev.20260429

package/go-plugin/lint/rules_dupes.go

@@ -0,0 +1,179 @@
+package lint
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// no-duplicate-case: duplicated `case` labels in a single switch.
+// https://eslint.org/docs/latest/rules/no-duplicate-case
+type noDuplicateCase struct{}
+
+func (noDuplicateCase) Name() string             { return "no-duplicate-case" }
+func (noDuplicateCase) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindSwitchStatement} }
+func (noDuplicateCase) Check(ctx *Context, node *shimast.Node) {
+	sw := node.AsSwitchStatement()
+	if sw == nil || sw.CaseBlock == nil {
+		return
+	}
+	block := sw.CaseBlock.AsCaseBlock()
+	if block == nil || block.Clauses == nil {
+		return
+	}
+	seen := make(map[string]bool, len(block.Clauses.Nodes))
+	for _, clause := range block.Clauses.Nodes {
+		if clause == nil || clause.Kind != shimast.KindCaseClause {
+			continue
+		}
+		caseClause := clause.AsCaseOrDefaultClause()
+		if caseClause == nil || caseClause.Expression == nil {
+			continue
+		}
+		key := nodeText(ctx.File, caseClause.Expression)
+		if key == "" {
+			continue
+		}
+		if seen[key] {
+			ctx.Report(clause, "Duplicate case label.")
+			continue
+		}
+		seen[key] = true
+	}
+}
+
+// no-dupe-keys: duplicated property names in a single object literal.
+// https://eslint.org/docs/latest/rules/no-dupe-keys
+type noDupeKeys struct{}
+
+func (noDupeKeys) Name() string             { return "no-dupe-keys" }
+func (noDupeKeys) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindObjectLiteralExpression} }
+func (noDupeKeys) Check(ctx *Context, node *shimast.Node) {
+	obj := node.AsObjectLiteralExpression()
+	if obj == nil || obj.Properties == nil {
+		return
+	}
+	seen := make(map[string]*shimast.Node, len(obj.Properties.Nodes))
+	for _, prop := range obj.Properties.Nodes {
+		key := propertyKey(ctx.File, prop)
+		if key == "" {
+			continue
+		}
+		if first, ok := seen[key]; ok {
+			ctx.Report(prop, "Duplicate key '"+key+"'.")
+			_ = first
+			continue
+		}
+		seen[key] = prop
+	}
+}
+
+// no-dupe-args: duplicated parameter names in a single function head.
+// https://eslint.org/docs/latest/rules/no-dupe-args
+type noDupeArgs struct{}
+
+func (noDupeArgs) Name() string { return "no-dupe-args" }
+func (noDupeArgs) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindFunctionDeclaration,
+		shimast.KindFunctionExpression,
+		shimast.KindArrowFunction,
+		shimast.KindMethodDeclaration,
+		shimast.KindConstructor,
+		shimast.KindGetAccessor,
+		shimast.KindSetAccessor,
+	}
+}
+func (noDupeArgs) Check(ctx *Context, node *shimast.Node) {
+	params := node.Parameters()
+	seen := make(map[string]bool, len(params))
+	for _, param := range params {
+		paramDecl := param.AsParameterDeclaration()
+		if paramDecl == nil {
+			continue
+		}
+		name := identifierText(paramDecl.Name())
+		if name == "" {
+			continue
+		}
+		if seen[name] {
+			ctx.Report(param, "Duplicate parameter name '"+name+"'.")
+			continue
+		}
+		seen[name] = true
+	}
+}
+
+// propertyKey returns a stable key for a property in an object literal.
+// Computed names without a literal payload return "" so the dedupe pass
+// can skip them safely (a typed field is fine — duplicate identical
+// expressions still won't cause false positives because the same expr
+// produces the same source text).
+func propertyKey(file *shimast.SourceFile, prop *shimast.Node) string {
+	if prop == nil {
+		return ""
+	}
+	switch prop.Kind {
+	case shimast.KindPropertyAssignment:
+		assignment := prop.AsPropertyAssignment()
+		if assignment == nil {
+			return ""
+		}
+		return staticPropertyKey(file, assignment.Name())
+	case shimast.KindShorthandPropertyAssignment:
+		short := prop.AsShorthandPropertyAssignment()
+		if short == nil {
+			return ""
+		}
+		return staticPropertyKey(file, short.Name())
+	case shimast.KindMethodDeclaration:
+		method := prop.AsMethodDeclaration()
+		if method == nil {
+			return ""
+		}
+		return staticPropertyKey(file, method.Name())
+	case shimast.KindGetAccessor, shimast.KindSetAccessor:
+		// Getter and setter pairs share a name but are not duplicates.
+		// Add a kind suffix so the dedupe key separates them.
+		switch prop.Kind {
+		case shimast.KindGetAccessor:
+			get := prop.AsGetAccessorDeclaration()
+			if get == nil {
+				return ""
+			}
+			if k := staticPropertyKey(file, get.Name()); k != "" {
+				return "get:" + k
+			}
+		case shimast.KindSetAccessor:
+			set := prop.AsSetAccessorDeclaration()
+			if set == nil {
+				return ""
+			}
+			if k := staticPropertyKey(file, set.Name()); k != "" {
+				return "set:" + k
+			}
+		}
+	}
+	return ""
+}
+
+func staticPropertyKey(file *shimast.SourceFile, name *shimast.Node) string {
+	if name == nil {
+		return ""
+	}
+	switch name.Kind {
+	case shimast.KindIdentifier:
+		return identifierText(name)
+	case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+		return stringLiteralText(name)
+	case shimast.KindNumericLiteral, shimast.KindBigIntLiteral:
+		return numericLiteralText(name)
+	case shimast.KindComputedPropertyName:
+		// fall back to source text so a computed `[`foo`]` still compares
+		// against the literal `foo` form when both appear together.
+		return nodeText(file, name)
+	}
+	return ""
+}
+
+func init() {
+	Register(noDuplicateCase{})
+	Register(noDupeKeys{})
+	Register(noDupeArgs{})
+}

package/go-plugin/lint/rules_empty.go

@@ -0,0 +1,110 @@
+package lint
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// no-empty: empty block statements (`{}`), but allow empty catch
+// clauses since they're idiomatic for "ignore the error".
+// https://eslint.org/docs/latest/rules/no-empty
+type noEmpty struct{}
+
+func (noEmpty) Name() string             { return "no-empty" }
+func (noEmpty) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindBlock} }
+func (noEmpty) Check(ctx *Context, node *shimast.Node) {
+	block := node.AsBlock()
+	if block == nil || block.Statements == nil {
+		return
+	}
+	if len(block.Statements.Nodes) > 0 {
+		return
+	}
+	parent := node.Parent
+	if parent != nil && parent.Kind == shimast.KindCatchClause {
+		return // tolerated — see ESLint default options
+	}
+	if isFunctionLikeKind(parent) {
+		return // empty function body is `no-empty-function`'s job
+	}
+	ctx.Report(node, "Empty block statement.")
+}
+
+// no-empty-function: empty function / method / arrow / accessor bodies.
+// https://eslint.org/docs/latest/rules/no-empty-function
+type noEmptyFunction struct{}
+
+func (noEmptyFunction) Name() string             { return "no-empty-function" }
+func (noEmptyFunction) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindFunctionDeclaration,
+		shimast.KindFunctionExpression,
+		shimast.KindArrowFunction,
+		shimast.KindMethodDeclaration,
+		shimast.KindGetAccessor,
+		shimast.KindSetAccessor,
+		shimast.KindConstructor,
+	}
+}
+func (noEmptyFunction) Check(ctx *Context, node *shimast.Node) {
+	body := node.Body()
+	if body == nil {
+		return
+	}
+	if body.Kind != shimast.KindBlock {
+		return
+	}
+	block := body.AsBlock()
+	if block == nil || block.Statements == nil {
+		return
+	}
+	if len(block.Statements.Nodes) == 0 {
+		ctx.Report(node, "Unexpected empty function.")
+	}
+}
+
+// no-empty-pattern: `({}) => x` or `function ({}) {}` — destructuring
+// patterns with no bindings are usually a bug.
+// https://eslint.org/docs/latest/rules/no-empty-pattern
+type noEmptyPattern struct{}
+
+func (noEmptyPattern) Name() string { return "no-empty-pattern" }
+func (noEmptyPattern) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindObjectBindingPattern, shimast.KindArrayBindingPattern}
+}
+func (noEmptyPattern) Check(ctx *Context, node *shimast.Node) {
+	pattern := node.AsBindingPattern()
+	if pattern == nil || pattern.Elements == nil {
+		return
+	}
+	if len(pattern.Elements.Nodes) == 0 {
+		shape := "object"
+		if node.Kind == shimast.KindArrayBindingPattern {
+			shape = "array"
+		}
+		ctx.Report(node, "Unexpected empty "+shape+" pattern.")
+	}
+}
+
+// isFunctionLikeKind reports whether the node represents a function-like
+// host whose body is the relevant scope for the empty check.
+func isFunctionLikeKind(n *shimast.Node) bool {
+	if n == nil {
+		return false
+	}
+	switch n.Kind {
+	case
+		shimast.KindFunctionDeclaration,
+		shimast.KindFunctionExpression,
+		shimast.KindArrowFunction,
+		shimast.KindMethodDeclaration,
+		shimast.KindGetAccessor,
+		shimast.KindSetAccessor,
+		shimast.KindConstructor:
+		return true
+	}
+	return false
+}
+
+func init() {
+	Register(noEmpty{})
+	Register(noEmptyFunction{})
+	Register(noEmptyPattern{})
+}

package/go-plugin/lint/rules_eval.go

@@ -0,0 +1,57 @@
+package lint
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// no-eval: forbid `eval(...)` calls. Members of nested namespaces (e.g.
+// `globalThis.eval(...)`) are not flagged here — that's
+// `no-implied-eval`, which we don't ship in v0.
+// https://eslint.org/docs/latest/rules/no-eval
+type noEval struct{}
+
+func (noEval) Name() string             { return "no-eval" }
+func (noEval) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindCallExpression} }
+func (noEval) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil {
+		return
+	}
+	if callCalleeName(call) == "eval" {
+		ctx.Report(node, "eval can be harmful.")
+	}
+}
+
+// no-script-url: forbid `"javascript:..."` literals. Often used to inject
+// inline JS via DOM `href`/`src`; legacy and dangerous.
+// https://eslint.org/docs/latest/rules/no-script-url
+type noScriptURL struct{}
+
+func (noScriptURL) Name() string             { return "no-script-url" }
+func (noScriptURL) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral} }
+func (noScriptURL) Check(ctx *Context, node *shimast.Node) {
+	text := stringLiteralText(node)
+	if isJavaScriptURL(text) {
+		ctx.Report(node, "Script URL is a form of eval.")
+	}
+}
+
+func isJavaScriptURL(text string) bool {
+	const prefix = "javascript:"
+	if len(text) < len(prefix) {
+		return false
+	}
+	for i := 0; i < len(prefix); i++ {
+		c := text[i]
+		if c >= 'A' && c <= 'Z' {
+			c += 'a' - 'A'
+		}
+		if c != prefix[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func init() {
+	Register(noEval{})
+	Register(noScriptURL{})
+}

package/go-plugin/lint/rules_finally.go

@@ -0,0 +1,123 @@
+package lint
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// no-unsafe-finally: `return` / `break` / `continue` / `throw` inside a
+// `finally` clause silently overrides the in-flight exception or value.
+// https://eslint.org/docs/latest/rules/no-unsafe-finally
+type noUnsafeFinally struct{}
+
+func (noUnsafeFinally) Name() string { return "no-unsafe-finally" }
+func (noUnsafeFinally) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindReturnStatement,
+		shimast.KindBreakStatement,
+		shimast.KindContinueStatement,
+		shimast.KindThrowStatement,
+	}
+}
+func (noUnsafeFinally) Check(ctx *Context, node *shimast.Node) {
+	finallyAncestor := walkToFinally(node)
+	if finallyAncestor == nil {
+		return
+	}
+	keyword := keywordOfControl(node)
+	ctx.Report(node, "Unsafe usage of "+keyword+".")
+}
+
+func walkToFinally(node *shimast.Node) *shimast.Node {
+	cur := node.Parent
+	for cur != nil {
+		if isFunctionLikeKind(cur) || cur.Kind == shimast.KindSourceFile {
+			return nil
+		}
+		if cur.Kind == shimast.KindBlock {
+			grand := cur.Parent
+			if grand != nil && grand.Kind == shimast.KindTryStatement {
+				try := grand.AsTryStatement()
+				if try != nil && try.FinallyBlock == cur {
+					return cur
+				}
+			}
+		}
+		// `break` / `continue` inside an inner loop within finally
+		// targets that loop and is therefore safe.
+		switch cur.Kind {
+		case shimast.KindForStatement,
+			shimast.KindForInStatement,
+			shimast.KindForOfStatement,
+			shimast.KindWhileStatement,
+			shimast.KindDoStatement,
+			shimast.KindSwitchStatement:
+			if node.Kind == shimast.KindBreakStatement || node.Kind == shimast.KindContinueStatement {
+				return nil
+			}
+		}
+		cur = cur.Parent
+	}
+	return nil
+}
+
+func keywordOfControl(node *shimast.Node) string {
+	switch node.Kind {
+	case shimast.KindReturnStatement:
+		return "return"
+	case shimast.KindBreakStatement:
+		return "break"
+	case shimast.KindContinueStatement:
+		return "continue"
+	case shimast.KindThrowStatement:
+		return "throw"
+	}
+	return "control flow"
+}
+
+// no-useless-catch: `catch (err) { throw err; }` adds no behavior.
+// https://eslint.org/docs/latest/rules/no-useless-catch
+type noUselessCatch struct{}
+
+func (noUselessCatch) Name() string             { return "no-useless-catch" }
+func (noUselessCatch) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindCatchClause} }
+func (noUselessCatch) Check(ctx *Context, node *shimast.Node) {
+	clause := node.AsCatchClause()
+	if clause == nil || clause.VariableDeclaration == nil || clause.Block == nil {
+		return
+	}
+	binding := clause.VariableDeclaration.AsVariableDeclaration()
+	if binding == nil {
+		return
+	}
+	bindingName := identifierText(binding.Name())
+	if bindingName == "" {
+		return
+	}
+	block := clause.Block.AsBlock()
+	if block == nil || block.Statements == nil || len(block.Statements.Nodes) != 1 {
+		return
+	}
+	stmt := block.Statements.Nodes[0]
+	if stmt == nil || stmt.Kind != shimast.KindThrowStatement {
+		return
+	}
+	throw := stmt.AsThrowStatement()
+	if throw == nil {
+		return
+	}
+	if identifierText(throw.Expression) != bindingName {
+		return
+	}
+	// Ignore when the surrounding try-catch has a `finally` block — the
+	// catch may exist solely to keep the finally semantics intact.
+	if try := node.Parent; try != nil && try.Kind == shimast.KindTryStatement {
+		tryStmt := try.AsTryStatement()
+		if tryStmt != nil && tryStmt.FinallyBlock != nil {
+			return
+		}
+	}
+	ctx.Report(node, "Unnecessary try/catch wrapper.")
+}
+
+func init() {
+	Register(noUnsafeFinally{})
+	Register(noUselessCatch{})
+}