@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

package/linthost/rules_unicorn_no_invalid_remove_event_listener.go

@@ -0,0 +1,51 @@
+// unicorn/no-invalid-remove-event-listener: passing a fresh function
+// literal to `removeEventListener` is a no-op because event-target
+// internals match listeners by reference identity. The handler that was
+// originally registered still fires; the call silently does nothing.
+//
+// AST-only: visit each `CallExpression`, match when the callee is a
+// `PropertyAccessExpression(_, removeEventListener)` and the second
+// argument (after stripping parens) is a fresh arrow function or
+// function expression. Fire on the call so the diagnostic lands at the
+// no-op site.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-invalid-remove-event-listener.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoInvalidRemoveEventListener struct{}
+
+func (unicornNoInvalidRemoveEventListener) Name() string {
+	return "unicorn/no-invalid-remove-event-listener"
+}
+func (unicornNoInvalidRemoveEventListener) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoInvalidRemoveEventListener) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil {
+		return
+	}
+	if call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil || identifierText(access.Name()) != "removeEventListener" {
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) < 2 {
+		return
+	}
+	handler := stripParens(call.Arguments.Nodes[1])
+	if handler == nil {
+		return
+	}
+	switch handler.Kind {
+	case shimast.KindArrowFunction, shimast.KindFunctionExpression:
+		ctx.Report(node, "Calling `removeEventListener` with a fresh function reference removes nothing — store and reuse the handler.")
+	}
+}
+
+func init() {
+	Register(unicornNoInvalidRemoveEventListener{})
+}

package/linthost/rules_unicorn_no_keyword_prefix.go

@@ -0,0 +1,101 @@
+// unicorn/no-keyword-prefix: identifiers like `newFoo` or `classBar`
+// embed a reserved word at the prefix position so the reader has to
+// re-parse the identifier each time. The rule discourages the prefix in
+// declarations so the codebase converges on names whose first segment
+// is not a JavaScript keyword.
+//
+// AST-only: visit every `Identifier` and fire only on declaration
+// positions (parameter, variable, function, class, method, accessor,
+// property, binding-element names). Reads of an already-named binding
+// are NOT flagged — the diagnostic is anchored on the declaration so
+// the rename happens once. Uses the same value-position-gate logic as
+// `prefer-global-this`, inverted: this rule needs the identifier to be
+// in a *name* slot, not a value-expression slot.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-keyword-prefix.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoKeywordPrefix struct{}
+
+func (unicornNoKeywordPrefix) Name() string { return "unicorn/no-keyword-prefix" }
+func (unicornNoKeywordPrefix) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindIdentifier}
+}
+func (unicornNoKeywordPrefix) Check(ctx *Context, node *shimast.Node) {
+	name := identifierText(node)
+	if !hasKeywordPrefix(name) {
+		return
+	}
+	if !isUnicornDeclarationPositionIdentifier(node) {
+		return
+	}
+	ctx.Report(node, "Don't prefix identifiers with a reserved word (`new` / `class`).")
+}
+
+// hasKeywordPrefix reports whether `name` starts with `new` or `class`
+// followed by an uppercase ASCII letter. The case-sensitive prefix +
+// the uppercase next letter together pin the camelCase pattern the rule
+// targets (`newFoo`, `classBar`); plain words like `news` or `classic`
+// share the prefix bytes but not the camelCase break and are out of
+// scope.
+func hasKeywordPrefix(name string) bool {
+	for _, prefix := range []string{"new", "class"} {
+		if len(name) <= len(prefix) {
+			continue
+		}
+		if name[:len(prefix)] != prefix {
+			continue
+		}
+		next := name[len(prefix)]
+		if next >= 'A' && next <= 'Z' {
+			return true
+		}
+	}
+	return false
+}
+
+// isUnicornDeclarationPositionIdentifier reports whether `node` (a bare
+// Identifier) appears as a *name* slot of a declaration, i.e. the slot
+// reserved by the language for introducing a new binding. Reads,
+// property keys on accesses, type references, and labels are filtered
+// out so the rule only fires on declarations.
+func isUnicornDeclarationPositionIdentifier(node *shimast.Node) bool {
+	if node == nil || node.Kind != shimast.KindIdentifier || node.Parent == nil {
+		return false
+	}
+	parent := node.Parent
+	switch parent.Kind {
+	case shimast.KindVariableDeclaration:
+		decl := parent.AsVariableDeclaration()
+		return decl != nil && decl.Name() == node
+	case shimast.KindBindingElement:
+		elem := parent.AsBindingElement()
+		return elem != nil && elem.Name() == node
+	case shimast.KindParameter:
+		param := parent.AsParameterDeclaration()
+		return param != nil && param.Name() == node
+	case shimast.KindFunctionDeclaration:
+		fn := parent.AsFunctionDeclaration()
+		return fn != nil && fn.Name() == node
+	case shimast.KindFunctionExpression:
+		fn := parent.AsFunctionExpression()
+		return fn != nil && fn.Name() == node
+	case shimast.KindClassDeclaration:
+		cls := parent.AsClassDeclaration()
+		return cls != nil && cls.Name() == node
+	case shimast.KindClassExpression:
+		cls := parent.AsClassExpression()
+		return cls != nil && cls.Name() == node
+	case shimast.KindMethodDeclaration,
+		shimast.KindGetAccessor,
+		shimast.KindSetAccessor,
+		shimast.KindPropertyDeclaration:
+		return true
+	}
+	return false
+}
+
+func init() {
+	Register(unicornNoKeywordPrefix{})
+}

package/linthost/rules_unicorn_no_lonely_if.go

@@ -0,0 +1,44 @@
+// unicorn/no-lonely-if: `else { if (cond) { … } }` collapses to
+// `else if (cond) { … }`. Wrapping a single `if` in an `else` block
+// adds an extra brace pair and an extra indentation level without
+// changing semantics, so the rule flags it as redundant punctuation.
+//
+// AST-only and parent-walking: visit every `IfStatement`, then check
+// whether its parent is a `Block` containing exactly this one
+// statement AND that block is the `ElseStatement` of an outer
+// `IfStatement`. Mirrors the core `no-lonely-if` rule shape.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-lonely-if.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoLonelyIf struct{}
+
+func (unicornNoLonelyIf) Name() string           { return "unicorn/no-lonely-if" }
+func (unicornNoLonelyIf) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindIfStatement} }
+func (unicornNoLonelyIf) Check(ctx *Context, node *shimast.Node) {
+	parent := node.Parent
+	if parent == nil || parent.Kind != shimast.KindBlock {
+		return
+	}
+	block := parent.AsBlock()
+	if block == nil || block.Statements == nil {
+		return
+	}
+	if len(block.Statements.Nodes) != 1 {
+		return
+	}
+	grand := parent.Parent
+	if grand == nil || grand.Kind != shimast.KindIfStatement {
+		return
+	}
+	gif := grand.AsIfStatement()
+	if gif == nil || gif.ElseStatement != parent {
+		return
+	}
+	ctx.Report(node, "Use `else if` instead of an `if` as the only statement inside an `else` block.")
+}
+
+func init() {
+	Register(unicornNoLonelyIf{})
+}

package/linthost/rules_unicorn_no_magic_array_flat_depth.go

@@ -0,0 +1,51 @@
+// unicorn/no-magic-array-flat-depth: `Array#flat(depth)` accepts a numeric
+// argument that controls how many nested levels are flattened. Magic
+// numbers like `.flat(2)` or `.flat(3)` make the call hard to scan —
+// readers must mentally model the input shape to decide whether the
+// depth is correct. The rule allows `1` (the default depth, common
+// enough to read at a glance) and `Infinity` (an explicit named value)
+// but flags every other numeric literal so authors switch to either
+// `Infinity` or a named constant.
+//
+// AST-only: dispatch on `KindCallExpression`, require a property-access
+// callee whose method identifier is `flat`, exactly one argument, and
+// that argument to be `KindNumericLiteral` with text other than "1".
+// `Infinity` is parsed as an Identifier, not a NumericLiteral, so the
+// kind check alone exempts it without a separate value branch.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-magic-array-flat-depth.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoMagicArrayFlatDepth struct{}
+
+func (unicornNoMagicArrayFlatDepth) Name() string { return "unicorn/no-magic-array-flat-depth" }
+func (unicornNoMagicArrayFlatDepth) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoMagicArrayFlatDepth) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil ||
+		call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil || identifierText(access.Name()) != "flat" {
+		return
+	}
+	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+		return
+	}
+	arg := stripParens(call.Arguments.Nodes[0])
+	if arg == nil || arg.Kind != shimast.KindNumericLiteral {
+		return
+	}
+	if numericLiteralText(arg) == "1" {
+		return
+	}
+	ctx.Report(node, "Don't use a magic-number depth in `Array#flat()` — use `Infinity` or a named constant.")
+}
+
+func init() {
+	Register(unicornNoMagicArrayFlatDepth{})
+}

package/linthost/rules_unicorn_no_named_default.go

@@ -0,0 +1,54 @@
+// unicorn/no-named-default: a named-import specifier that re-aliases the
+// module's default export (`import { default as Foo } from "mod"`) does
+// the same job as the dedicated default-import form `import Foo from "mod"`
+// but obscures the intent — reviewers reading the named-import list have
+// to notice the `default as` prefix to realize the binding is the
+// module's default, not a named export named "default". The rule flags
+// every such specifier so authors use the default-import syntax instead.
+//
+// AST-only: dispatch on `KindImportDeclaration`, descend through the
+// import clause's NamedImports list, and fire on each specifier whose
+// `PropertyName` is an identifier named "default". The default-import
+// case (`clause.Name()`) and namespace imports (`* as`) are not
+// affected; the property-name check matches both `import { default as X }`
+// and the deprecated string form `import { "default" as X }`.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-named-default.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoNamedDefault struct{}
+
+func (unicornNoNamedDefault) Name() string { return "unicorn/no-named-default" }
+func (unicornNoNamedDefault) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindImportDeclaration}
+}
+func (unicornNoNamedDefault) Check(ctx *Context, node *shimast.Node) {
+	decl := node.AsImportDeclaration()
+	if decl == nil || decl.ImportClause == nil {
+		return
+	}
+	clause := decl.ImportClause.AsImportClause()
+	if clause == nil || clause.NamedBindings == nil ||
+		clause.NamedBindings.Kind != shimast.KindNamedImports {
+		return
+	}
+	named := clause.NamedBindings.AsNamedImports()
+	if named == nil || named.Elements == nil {
+		return
+	}
+	for _, spec := range named.Elements.Nodes {
+		s := spec.AsImportSpecifier()
+		if s == nil || s.PropertyName == nil {
+			continue
+		}
+		if moduleExportNameText(s.PropertyName) != "default" {
+			continue
+		}
+		ctx.Report(spec, "Don't import a default export under a named alias — use `import X from \"...\"` instead.")
+	}
+}
+
+func init() {
+	Register(unicornNoNamedDefault{})
+}

package/linthost/rules_unicorn_no_negated_condition.go

@@ -0,0 +1,85 @@
+// unicorn/no-negated-condition: a negated condition with an `else`
+// branch forces the reader to mentally invert the test before they can
+// pair branches with outcomes. Swapping the two branches and dropping
+// the negation reads in source order. The rule fires on `if` / `else`
+// pairs and on ternaries where both branches are present.
+//
+// AST-only: visit `KindIfStatement` and `KindConditionalExpression`.
+// Match when the condition (after `stripParens`) is either a `!`
+// prefix-unary expression or a `!=` / `!==` binary expression AND the
+// other branch is also present. Fire on the if / ternary node.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-negated-condition.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoNegatedCondition struct{}
+
+func (unicornNoNegatedCondition) Name() string { return "unicorn/no-negated-condition" }
+func (unicornNoNegatedCondition) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindIfStatement, shimast.KindConditionalExpression}
+}
+func (unicornNoNegatedCondition) Check(ctx *Context, node *shimast.Node) {
+	var condition *shimast.Node
+	switch node.Kind {
+	case shimast.KindIfStatement:
+		stmt := node.AsIfStatement()
+		if stmt == nil || stmt.ElseStatement == nil {
+			return
+		}
+		// An `else if` chain (else is itself an IfStatement) reads
+		// fine after inversion only when the else has its own else;
+		// otherwise inverting reshapes the chain. Keep the rule
+		// conservative and only fire when else is a Block.
+		if stmt.ElseStatement.Kind == shimast.KindIfStatement {
+			return
+		}
+		condition = stmt.Expression
+	case shimast.KindConditionalExpression:
+		cond := node.AsConditionalExpression()
+		if cond == nil || cond.WhenTrue == nil || cond.WhenFalse == nil {
+			return
+		}
+		condition = cond.Condition
+	}
+	if condition == nil {
+		return
+	}
+	condition = stripParens(condition)
+	if condition == nil {
+		return
+	}
+	if !unicornNoNegatedConditionIsNegated(condition) {
+		return
+	}
+	ctx.Report(node, "Avoid negated conditions in `if` / `else` and ternaries when the positive form is shorter.")
+}
+
+// unicornNoNegatedConditionIsNegated reports whether `node` is a `!`
+// prefix-unary expression or a `!=` / `!==` binary expression — the
+// two shapes the rule treats as "negated".
+func unicornNoNegatedConditionIsNegated(node *shimast.Node) bool {
+	if node == nil {
+		return false
+	}
+	switch node.Kind {
+	case shimast.KindPrefixUnaryExpression:
+		prefix := node.AsPrefixUnaryExpression()
+		return prefix != nil && prefix.Operator == shimast.KindExclamationToken
+	case shimast.KindBinaryExpression:
+		bin := node.AsBinaryExpression()
+		if bin == nil || bin.OperatorToken == nil {
+			return false
+		}
+		switch bin.OperatorToken.Kind {
+		case shimast.KindExclamationEqualsToken,
+			shimast.KindExclamationEqualsEqualsToken:
+			return true
+		}
+	}
+	return false
+}
+
+func init() {
+	Register(unicornNoNegatedCondition{})
+}

package/linthost/rules_unicorn_no_negation_in_equality_check.go

@@ -0,0 +1,50 @@
+// unicorn/no-negation-in-equality-check: `!a === b` parses as
+// `(!a) === b`, comparing the *boolean* `!a` against `b`. Readers
+// almost always expect `!(a === b)` instead, so the rule rejects the
+// `!a === b` / `!a !== b` shape and asks the author to either switch
+// the comparison operator (`a !== b`) or wrap the negation in parens.
+//
+// AST-only: visit each `BinaryExpression`, match the operator against
+// the four equality tokens, and check whether the LEFT operand is a
+// `!` prefix-unary expression. Parens are the documented escape hatch
+// (`(!a) === b`), so the check does NOT strip them. Fire on the binary
+// expression so the report covers the full ambiguous shape.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-negation-in-equality-check.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoNegationInEqualityCheck struct{}
+
+func (unicornNoNegationInEqualityCheck) Name() string {
+	return "unicorn/no-negation-in-equality-check"
+}
+func (unicornNoNegationInEqualityCheck) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindBinaryExpression}
+}
+func (unicornNoNegationInEqualityCheck) Check(ctx *Context, node *shimast.Node) {
+	bin := node.AsBinaryExpression()
+	if bin == nil || bin.OperatorToken == nil || bin.Left == nil {
+		return
+	}
+	switch bin.OperatorToken.Kind {
+	case shimast.KindEqualsEqualsEqualsToken,
+		shimast.KindEqualsEqualsToken,
+		shimast.KindExclamationEqualsEqualsToken,
+		shimast.KindExclamationEqualsToken:
+	default:
+		return
+	}
+	if bin.Left.Kind != shimast.KindPrefixUnaryExpression {
+		return
+	}
+	prefix := bin.Left.AsPrefixUnaryExpression()
+	if prefix == nil || prefix.Operator != shimast.KindExclamationToken {
+		return
+	}
+	ctx.Report(node, "Don't negate the left operand of an equality check — use `!==` directly, or wrap in parens.")
+}
+
+func init() {
+	Register(unicornNoNegationInEqualityCheck{})
+}

package/linthost/rules_unicorn_no_nested_ternary.go

@@ -0,0 +1,43 @@
+// unicorn/no-nested-ternary: `a ? b : c ? d : e` packs two decision
+// points into one expression and forces the reader to track operator
+// precedence to know which branch each value belongs to. Unlike the
+// core ESLint rule of the same name, the unicorn variant fires on every
+// nested level rather than only the outermost — each inner conditional
+// is its own offense and is reported in place.
+//
+// AST-only: visit every `ConditionalExpression` and report on it when
+// its parent is also a `ConditionalExpression`. `stripParens` makes the
+// match insensitive to grouping parens.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-nested-ternary.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoNestedTernary struct{}
+
+func (unicornNoNestedTernary) Name() string { return "unicorn/no-nested-ternary" }
+func (unicornNoNestedTernary) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindConditionalExpression}
+}
+func (unicornNoNestedTernary) Check(ctx *Context, node *shimast.Node) {
+	cond := node.AsConditionalExpression()
+	if cond == nil {
+		return
+	}
+	if hasUnicornNestedConditional(cond.WhenTrue) {
+		ctx.Report(stripParens(cond.WhenTrue), "Do not nest ternary expressions.")
+		return
+	}
+	if hasUnicornNestedConditional(cond.WhenFalse) {
+		ctx.Report(stripParens(cond.WhenFalse), "Do not nest ternary expressions.")
+	}
+}
+
+func hasUnicornNestedConditional(node *shimast.Node) bool {
+	expr := stripParens(node)
+	return expr != nil && expr.Kind == shimast.KindConditionalExpression
+}
+
+func init() {
+	Register(unicornNoNestedTernary{})
+}

package/linthost/rules_unicorn_no_new_array.go

@@ -0,0 +1,30 @@
+// unicorn/no-new-array: `new Array(n)` is a sharp edge — with a single
+// numeric argument it allocates a sparse array of length `n`, with
+// anything else it constructs from the arguments. The two readings
+// share one syntax, so the same expression silently switches meaning
+// when its input shape changes. The replacement is an array literal,
+// `Array.from`, or `Array.of`.
+//
+// AST-only and identifier-text-driven: any `NewExpression` whose callee
+// is an `Identifier` named `Array` fires. Shadowed `Array` bindings,
+// argument count, and argument types are not part of the match,
+// mirroring `unicorn/no-new-buffer`.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-new-array.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoNewArray struct{}
+
+func (unicornNoNewArray) Name() string           { return "unicorn/no-new-array" }
+func (unicornNoNewArray) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindNewExpression} }
+func (unicornNoNewArray) Check(ctx *Context, node *shimast.Node) {
+	ne := node.AsNewExpression()
+	if ne != nil && identifierText(ne.Expression) == "Array" {
+		ctx.Report(node, "Don't use `new Array(...)` — use an array literal or `Array.from`/`Array.of` instead.")
+	}
+}
+
+func init() {
+	Register(unicornNoNewArray{})
+}

package/linthost/rules_unicorn_no_new_buffer.go

@@ -0,0 +1,31 @@
+// unicorn/no-new-buffer: the `new Buffer(...)` constructor was deprecated
+// in Node because its overloads route on argument type at runtime — an
+// integer allocates uninitialized memory, a string decodes bytes, an array
+// copies them — so the same call site silently changes meaning when its
+// input shape changes. The replacement is the explicit `Buffer.from()` /
+// `Buffer.alloc()` pair.
+//
+// AST-only and identifier-text-driven: the rule fires on any `NewExpression`
+// whose callee is an `Identifier` named `Buffer`. Shadowed `Buffer`
+// bindings and import sources are out of scope; argument count and shape
+// are not part of the match, so `new Buffer(10)`, `new Buffer("ascii")`,
+// and `new Buffer([])` all report.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-new-buffer.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoNewBuffer struct{}
+
+func (unicornNoNewBuffer) Name() string           { return "unicorn/no-new-buffer" }
+func (unicornNoNewBuffer) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindNewExpression} }
+func (unicornNoNewBuffer) Check(ctx *Context, node *shimast.Node) {
+	ne := node.AsNewExpression()
+	if ne != nil && identifierText(ne.Expression) == "Buffer" {
+		ctx.Report(node, "`new Buffer()` is deprecated, use `Buffer.from()` or `Buffer.alloc()` instead.")
+	}
+}
+
+func init() {
+	Register(unicornNoNewBuffer{})
+}

package/linthost/rules_unicorn_no_null.go

@@ -0,0 +1,24 @@
+// unicorn/no-null: the bare `null` literal is treated as a code smell —
+// the rule's policy is that `undefined` is the single absent-value token
+// in user code. Every occurrence of the keyword anywhere in the source is
+// flagged so the codebase converges on one convention.
+//
+// AST-only: the engine dispatches once per `NullKeyword` node and the
+// rule reports unconditionally on that node. There is no fixer in this
+// pass — the diagnostic alone is the contract.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-null.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoNull struct{}
+
+func (unicornNoNull) Name() string           { return "unicorn/no-null" }
+func (unicornNoNull) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindNullKeyword} }
+func (unicornNoNull) Check(ctx *Context, node *shimast.Node) {
+	ctx.Report(node, "Use `undefined` instead of `null`.")
+}
+
+func init() {
+	Register(unicornNoNull{})
+}

package/linthost/rules_unicorn_no_object_as_default_parameter.go

@@ -0,0 +1,48 @@
+// unicorn/no-object-as-default-parameter: writing
+// `function f(opts = { tag: "x" })` ships a hidden default object that
+// is hard to override granularly — callers either supply the whole
+// object or get every default at once, and the option keys are
+// invisible at the call site. Destructuring with per-key defaults
+// (`function f({ tag = "x" } = {})`) is the canonical replacement.
+//
+// AST-only: dispatch on `ParameterDeclaration`. Fire when the parameter
+// has a non-empty object-literal initializer and the parameter name
+// itself is a bare identifier (already-destructured parameters are
+// covered by the destructuring form the rule recommends). Empty
+// objects `param = {}` are out of scope — that pattern is a different
+// rule.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-object-as-default-parameter.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoObjectAsDefaultParameter struct{}
+
+func (unicornNoObjectAsDefaultParameter) Name() string {
+	return "unicorn/no-object-as-default-parameter"
+}
+func (unicornNoObjectAsDefaultParameter) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindParameter}
+}
+func (unicornNoObjectAsDefaultParameter) Check(ctx *Context, node *shimast.Node) {
+	param := node.AsParameterDeclaration()
+	if param == nil || param.Initializer == nil || param.Name() == nil {
+		return
+	}
+	if param.Name().Kind != shimast.KindIdentifier {
+		return
+	}
+	init := stripParens(param.Initializer)
+	if init == nil || init.Kind != shimast.KindObjectLiteralExpression {
+		return
+	}
+	obj := init.AsObjectLiteralExpression()
+	if obj == nil || obj.Properties == nil || len(obj.Properties.Nodes) == 0 {
+		return
+	}
+	ctx.Report(node, "Don't use an object literal as a default parameter — destructure the option instead.")
+}
+
+func init() {
+	Register(unicornNoObjectAsDefaultParameter{})
+}

package/linthost/rules_unicorn_no_process_exit.go

@@ -0,0 +1,43 @@
+// unicorn/no-process-exit: calling `process.exit(...)` short-circuits the
+// Node runtime before pending I/O, timers, or microtasks drain, which
+// turns ordinary error paths into silent data loss. The rule pushes
+// authors toward throwing or returning a non-zero status so the host
+// process owns the termination decision.
+//
+// AST-only first pass: a `CallExpression` whose callee is a
+// `PropertyAccessExpression` of the literal form `process.exit` fires.
+// Computed access (`process["exit"]`), optional chaining
+// (`process?.exit()`), and shadowed `process` bindings are intentionally
+// out of scope — only the bare callsite is reported.
+// https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-process-exit.md
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type unicornNoProcessExit struct{}
+
+func (unicornNoProcessExit) Name() string { return "unicorn/no-process-exit" }
+func (unicornNoProcessExit) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
+func (unicornNoProcessExit) Check(ctx *Context, node *shimast.Node) {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+		return
+	}
+	access := call.Expression.AsPropertyAccessExpression()
+	if access == nil {
+		return
+	}
+	if identifierText(access.Expression) != "process" {
+		return
+	}
+	if identifierText(access.Name()) != "exit" {
+		return
+	}
+	ctx.Report(node, "Don't use `process.exit()`. Throw an error or return a non-zero status instead.")
+}
+
+func init() {
+	Register(unicornNoProcessExit{})
+}