@ttsc/lint 0.5.0-dev.20260429 → 0.5.0-dev.20260429-4

package/{go-plugin/lint → plugin}/rules_strings.go

@@ -1,4 +1,4 @@
-package lint
+package main
 
 import (
 	"strings"
@@ -11,8 +11,10 @@ import (
 // https://eslint.org/docs/latest/rules/no-template-curly-in-string
 type noTemplateCurlyInString struct{}
 
-func (noTemplateCurlyInString) Name() string             { return "no-template-curly-in-string" }
-func (noTemplateCurlyInString) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindStringLiteral} }
+func (noTemplateCurlyInString) Name() string { return "no-template-curly-in-string" }
+func (noTemplateCurlyInString) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindStringLiteral}
+}
 func (noTemplateCurlyInString) Check(ctx *Context, node *shimast.Node) {
 	text := stringLiteralText(node)
 	if hasTemplatePlaceholder(text) {
@@ -45,8 +47,8 @@ func hasTemplatePlaceholder(text string) bool {
 // https://eslint.org/docs/latest/rules/no-multi-str
 type noMultiStr struct{}
 
-func (noMultiStr) Name() string             { return "no-multi-str" }
-func (noMultiStr) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindStringLiteral} }
+func (noMultiStr) Name() string           { return "no-multi-str" }
+func (noMultiStr) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindStringLiteral} }
 func (noMultiStr) Check(ctx *Context, node *shimast.Node) {
 	src := nodeText(ctx.File, node)
 	// Look for `\` immediately before a newline in the *raw* source text.
@@ -72,8 +74,8 @@ func hasBackslashLineContinuation(src string) bool {
 // https://eslint.org/docs/latest/rules/no-useless-concat
 type noUselessConcat struct{}
 
-func (noUselessConcat) Name() string             { return "no-useless-concat" }
-func (noUselessConcat) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (noUselessConcat) Name() string           { return "no-useless-concat" }
+func (noUselessConcat) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (noUselessConcat) Check(ctx *Context, node *shimast.Node) {
 	expr := node.AsBinaryExpression()
 	if expr == nil || expr.OperatorToken == nil {
@@ -103,8 +105,8 @@ func isStringLikeLiteral(node *shimast.Node) bool {
 // https://eslint.org/docs/latest/rules/no-octal
 type noOctal struct{}
 
-func (noOctal) Name() string             { return "no-octal" }
-func (noOctal) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindNumericLiteral} }
+func (noOctal) Name() string           { return "no-octal" }
+func (noOctal) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindNumericLiteral} }
 func (noOctal) Check(ctx *Context, node *shimast.Node) {
 	src := nodeText(ctx.File, node)
 	src = strings.TrimLeft(src, " \t")

package/{go-plugin/lint → plugin}/rules_suggestions.go

@@ -1,7 +1,7 @@
 // Bulk implementation of ESLint's "Suggestions" category — rules that
 // don't catch outright bugs but flag stylistic or maintainability
 // patterns. AST-only, no scope analysis.
-package lint
+package main
 
 import (
 	"strings"
@@ -13,8 +13,8 @@ import (
 // answer in production code.
 type noAlert struct{}
 
-func (noAlert) Name() string             { return "no-alert" }
-func (noAlert) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindCallExpression} }
+func (noAlert) Name() string           { return "no-alert" }
+func (noAlert) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindCallExpression} }
 func (noAlert) Check(ctx *Context, node *shimast.Node) {
 	call := node.AsCallExpression()
 	if call == nil {
@@ -70,8 +70,8 @@ func (noBitwise) Check(ctx *Context, node *shimast.Node) {
 // errors elsewhere; lint catches them earlier.
 type noCaller struct{}
 
-func (noCaller) Name() string             { return "no-caller" }
-func (noCaller) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindPropertyAccessExpression} }
+func (noCaller) Name() string           { return "no-caller" }
+func (noCaller) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindPropertyAccessExpression} }
 func (noCaller) Check(ctx *Context, node *shimast.Node) {
 	access := node.AsPropertyAccessExpression()
 	if access == nil {
@@ -121,8 +121,8 @@ func (noCaseDeclarations) Check(ctx *Context, node *shimast.Node) {
 // (loop body should usually be reorganized).
 type noContinue struct{}
 
-func (noContinue) Name() string             { return "no-continue" }
-func (noContinue) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindContinueStatement} }
+func (noContinue) Name() string           { return "no-continue" }
+func (noContinue) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindContinueStatement} }
 func (noContinue) Check(ctx *Context, node *shimast.Node) {
 	ctx.Report(node, "Unexpected use of continue statement.")
 }
@@ -130,8 +130,8 @@ func (noContinue) Check(ctx *Context, node *shimast.Node) {
 // no-delete-var: `delete x` where `x` is a variable. Strict-mode error.
 type noDeleteVar struct{}
 
-func (noDeleteVar) Name() string             { return "no-delete-var" }
-func (noDeleteVar) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindDeleteExpression} }
+func (noDeleteVar) Name() string           { return "no-delete-var" }
+func (noDeleteVar) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindDeleteExpression} }
 func (noDeleteVar) Check(ctx *Context, node *shimast.Node) {
 	del := node.AsDeleteExpression()
 	if del == nil {
@@ -146,8 +146,8 @@ func (noDeleteVar) Check(ctx *Context, node *shimast.Node) {
 // when developers want to also catch `undefined`.
 type noEqNull struct{}
 
-func (noEqNull) Name() string             { return "no-eq-null" }
-func (noEqNull) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (noEqNull) Name() string           { return "no-eq-null" }
+func (noEqNull) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (noEqNull) Check(ctx *Context, node *shimast.Node) {
 	expr := node.AsBinaryExpression()
 	if expr == nil || expr.OperatorToken == nil {
@@ -170,8 +170,8 @@ func isNullLiteral(node *shimast.Node) bool {
 // keeping false-positives down.
 type noExtraBind struct{}
 
-func (noExtraBind) Name() string             { return "no-extra-bind" }
-func (noExtraBind) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindCallExpression} }
+func (noExtraBind) Name() string           { return "no-extra-bind" }
+func (noExtraBind) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindCallExpression} }
 func (noExtraBind) Check(ctx *Context, node *shimast.Node) {
 	call := node.AsCallExpression()
 	if call == nil || call.Expression == nil {
@@ -233,8 +233,8 @@ func bodyReferencesThis(node *shimast.Node) bool {
 // confusing and rarely needed.
 type noLabels struct{}
 
-func (noLabels) Name() string             { return "no-labels" }
-func (noLabels) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindLabeledStatement} }
+func (noLabels) Name() string           { return "no-labels" }
+func (noLabels) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindLabeledStatement} }
 func (noLabels) Check(ctx *Context, node *shimast.Node) {
 	ctx.Report(node, "Unexpected labeled statement.")
 }
@@ -243,8 +243,8 @@ func (noLabels) Check(ctx *Context, node *shimast.Node) {
 // the braces add no scope (in non-strict mode) and obscure intent.
 type noLoneBlocks struct{}
 
-func (noLoneBlocks) Name() string             { return "no-lone-blocks" }
-func (noLoneBlocks) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindBlock} }
+func (noLoneBlocks) Name() string           { return "no-lone-blocks" }
+func (noLoneBlocks) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBlock} }
 func (noLoneBlocks) Check(ctx *Context, node *shimast.Node) {
 	parent := node.Parent
 	if parent == nil {
@@ -290,8 +290,8 @@ func (noLoneBlocks) Check(ctx *Context, node *shimast.Node) {
 // no-lonely-if: `else { if (...) {...} }` should be `else if (...)`.
 type noLonelyIf struct{}
 
-func (noLonelyIf) Name() string             { return "no-lonely-if" }
-func (noLonelyIf) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindIfStatement} }
+func (noLonelyIf) Name() string           { return "no-lonely-if" }
+func (noLonelyIf) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindIfStatement} }
 func (noLonelyIf) Check(ctx *Context, node *shimast.Node) {
 	parent := node.Parent
 	if parent == nil || parent.Kind != shimast.KindBlock {
@@ -318,8 +318,8 @@ func (noLonelyIf) Check(ctx *Context, node *shimast.Node) {
 // no-multi-assign: `a = b = 1`. Confusing right-to-left chains.
 type noMultiAssign struct{}
 
-func (noMultiAssign) Name() string             { return "no-multi-assign" }
-func (noMultiAssign) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (noMultiAssign) Name() string           { return "no-multi-assign" }
+func (noMultiAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (noMultiAssign) Check(ctx *Context, node *shimast.Node) {
 	expr := node.AsBinaryExpression()
 	if expr == nil || expr.OperatorToken == nil {
@@ -394,8 +394,10 @@ func isNegatedExpression(node *shimast.Node) bool {
 // no-nested-ternary: `a ? b : c ? d : e`.
 type noNestedTernary struct{}
 
-func (noNestedTernary) Name() string             { return "no-nested-ternary" }
-func (noNestedTernary) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindConditionalExpression} }
+func (noNestedTernary) Name() string { return "no-nested-ternary" }
+func (noNestedTernary) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindConditionalExpression}
+}
 func (noNestedTernary) Check(ctx *Context, node *shimast.Node) {
 	cond := node.AsConditionalExpression()
 	if cond == nil {
@@ -415,8 +417,8 @@ func hasConditional(node *shimast.Node) bool {
 // avoid the constructor.
 type noNew struct{}
 
-func (noNew) Name() string             { return "no-new" }
-func (noNew) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindExpressionStatement} }
+func (noNew) Name() string           { return "no-new" }
+func (noNew) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindExpressionStatement} }
 func (noNew) Check(ctx *Context, node *shimast.Node) {
 	stmt := node.AsExpressionStatement()
 	if stmt == nil || stmt.Expression == nil {
@@ -430,8 +432,10 @@ func (noNew) Check(ctx *Context, node *shimast.Node) {
 // no-new-func: `new Function("...")` — a third form of dynamic eval.
 type noNewFunc struct{}
 
-func (noNewFunc) Name() string             { return "no-new-func" }
-func (noNewFunc) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindNewExpression, shimast.KindCallExpression} }
+func (noNewFunc) Name() string { return "no-new-func" }
+func (noNewFunc) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindNewExpression, shimast.KindCallExpression}
+}
 func (noNewFunc) Check(ctx *Context, node *shimast.Node) {
 	var callee *shimast.Node
 	if node.Kind == shimast.KindNewExpression {
@@ -448,8 +452,10 @@ func (noNewFunc) Check(ctx *Context, node *shimast.Node) {
 // no-array-constructor but for objects.
 type noObjectConstructor struct{}
 
-func (noObjectConstructor) Name() string             { return "no-object-constructor" }
-func (noObjectConstructor) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindNewExpression, shimast.KindCallExpression} }
+func (noObjectConstructor) Name() string { return "no-object-constructor" }
+func (noObjectConstructor) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindNewExpression, shimast.KindCallExpression}
+}
 func (noObjectConstructor) Check(ctx *Context, node *shimast.Node) {
 	var callee *shimast.Node
 	var argCount int
@@ -478,8 +484,10 @@ func (noObjectConstructor) Check(ctx *Context, node *shimast.Node) {
 // deprecated and forbidden in template literals.
 type noOctalEscape struct{}
 
-func (noOctalEscape) Name() string             { return "no-octal-escape" }
-func (noOctalEscape) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral} }
+func (noOctalEscape) Name() string { return "no-octal-escape" }
+func (noOctalEscape) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
+}
 func (noOctalEscape) Check(ctx *Context, node *shimast.Node) {
 	src := nodeText(ctx.File, node)
 	if hasOctalEscape(src) {
@@ -535,8 +543,10 @@ func (noPlusPlus) Check(ctx *Context, node *shimast.Node) {
 // because the count is invisible.
 type noRegexSpaces struct{}
 
-func (noRegexSpaces) Name() string             { return "no-regex-spaces" }
-func (noRegexSpaces) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindRegularExpressionLiteral} }
+func (noRegexSpaces) Name() string { return "no-regex-spaces" }
+func (noRegexSpaces) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindRegularExpressionLiteral}
+}
 func (noRegexSpaces) Check(ctx *Context, node *shimast.Node) {
 	src := nodeText(ctx.File, node)
 	if regexHasMultipleSpaces(src) {
@@ -584,8 +594,10 @@ func regexHasMultipleSpaces(src string) bool {
 // no-return-assign: `return a = b` mixes assignment with return.
 type noReturnAssign struct{}
 
-func (noReturnAssign) Name() string             { return "no-return-assign" }
-func (noReturnAssign) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindReturnStatement, shimast.KindArrowFunction} }
+func (noReturnAssign) Name() string { return "no-return-assign" }
+func (noReturnAssign) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindReturnStatement, shimast.KindArrowFunction}
+}
 func (noReturnAssign) Check(ctx *Context, node *shimast.Node) {
 	switch node.Kind {
 	case shimast.KindReturnStatement:
@@ -611,8 +623,8 @@ func (noReturnAssign) Check(ctx *Context, node *shimast.Node) {
 // pattern outside of `for` headers.
 type noSequences struct{}
 
-func (noSequences) Name() string             { return "no-sequences" }
-func (noSequences) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (noSequences) Name() string           { return "no-sequences" }
+func (noSequences) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (noSequences) Check(ctx *Context, node *shimast.Node) {
 	expr := node.AsBinaryExpression()
 	if expr == nil || expr.OperatorToken == nil {
@@ -667,8 +679,8 @@ func (noShadowRestrictedNames) Check(ctx *Context, node *shimast.Node) {
 // because it's writable in older environments.
 type noUndefined struct{}
 
-func (noUndefined) Name() string             { return "no-undefined" }
-func (noUndefined) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindIdentifier} }
+func (noUndefined) Name() string           { return "no-undefined" }
+func (noUndefined) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindIdentifier} }
 func (noUndefined) Check(ctx *Context, node *shimast.Node) {
 	if identifierText(node) != "undefined" {
 		return
@@ -719,8 +731,10 @@ func nodesShareLoc(a, b *shimast.Node) bool {
 // no-unneeded-ternary: `x ? true : false` → `Boolean(x)` / `!!x`.
 type noUnneededTernary struct{}
 
-func (noUnneededTernary) Name() string             { return "no-unneeded-ternary" }
-func (noUnneededTernary) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindConditionalExpression} }
+func (noUnneededTernary) Name() string { return "no-unneeded-ternary" }
+func (noUnneededTernary) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindConditionalExpression}
+}
 func (noUnneededTernary) Check(ctx *Context, node *shimast.Node) {
 	cond := node.AsConditionalExpression()
 	if cond == nil {
@@ -739,8 +753,10 @@ func (noUnneededTernary) Check(ctx *Context, node *shimast.Node) {
 // Filtered down to common patterns ESLint flags by default.
 type noUnusedExpressions struct{}
 
-func (noUnusedExpressions) Name() string             { return "no-unused-expressions" }
-func (noUnusedExpressions) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindExpressionStatement} }
+func (noUnusedExpressions) Name() string { return "no-unused-expressions" }
+func (noUnusedExpressions) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindExpressionStatement}
+}
 func (noUnusedExpressions) Check(ctx *Context, node *shimast.Node) {
 	stmt := node.AsExpressionStatement()
 	if stmt == nil || stmt.Expression == nil {
@@ -800,8 +816,8 @@ func isProductiveExpression(node *shimast.Node) bool {
 // — call/apply with no this binding is just a regular call.
 type noUselessCall struct{}
 
-func (noUselessCall) Name() string             { return "no-useless-call" }
-func (noUselessCall) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindCallExpression} }
+func (noUselessCall) Name() string           { return "no-useless-call" }
+func (noUselessCall) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindCallExpression} }
 func (noUselessCall) Check(ctx *Context, node *shimast.Node) {
 	call := node.AsCallExpression()
 	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
@@ -900,8 +916,8 @@ func (noUselessRename) Check(ctx *Context, node *shimast.Node) {
 // object-shorthand: `{ x: x }` → `{ x }`.
 type objectShorthand struct{}
 
-func (objectShorthand) Name() string             { return "object-shorthand" }
-func (objectShorthand) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindPropertyAssignment} }
+func (objectShorthand) Name() string           { return "object-shorthand" }
+func (objectShorthand) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindPropertyAssignment} }
 func (objectShorthand) Check(ctx *Context, node *shimast.Node) {
 	prop := node.AsPropertyAssignment()
 	if prop == nil || prop.Name() == nil || prop.Initializer == nil {
@@ -920,8 +936,10 @@ func (objectShorthand) Check(ctx *Context, node *shimast.Node) {
 // operator-assignment: `x = x + 1` → `x += 1`.
 type operatorAssignment struct{}
 
-func (operatorAssignment) Name() string             { return "operator-assignment" }
-func (operatorAssignment) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (operatorAssignment) Name() string { return "operator-assignment" }
+func (operatorAssignment) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindBinaryExpression}
+}
 func (operatorAssignment) Check(ctx *Context, node *shimast.Node) {
 	expr := node.AsBinaryExpression()
 	if expr == nil || expr.OperatorToken == nil {
@@ -958,8 +976,10 @@ func isCompoundEligibleOperator(kind shimast.Kind) bool {
 // prefer-exponentiation-operator: `Math.pow(a, b)` → `a ** b`.
 type preferExponentiationOperator struct{}
 
-func (preferExponentiationOperator) Name() string             { return "prefer-exponentiation-operator" }
-func (preferExponentiationOperator) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindCallExpression} }
+func (preferExponentiationOperator) Name() string { return "prefer-exponentiation-operator" }
+func (preferExponentiationOperator) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression}
+}
 func (preferExponentiationOperator) Check(ctx *Context, node *shimast.Node) {
 	call := node.AsCallExpression()
 	if call == nil {
@@ -974,8 +994,8 @@ func (preferExponentiationOperator) Check(ctx *Context, node *shimast.Node) {
 // prefer-spread: `fn.apply(null, args)` → `fn(...args)`.
 type preferSpread struct{}
 
-func (preferSpread) Name() string             { return "prefer-spread" }
-func (preferSpread) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindCallExpression} }
+func (preferSpread) Name() string           { return "prefer-spread" }
+func (preferSpread) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindCallExpression} }
 func (preferSpread) Check(ctx *Context, node *shimast.Node) {
 	call := node.AsCallExpression()
 	if call == nil || call.Expression == nil {
@@ -1007,8 +1027,8 @@ func (preferSpread) Check(ctx *Context, node *shimast.Node) {
 // a non-literal.
 type preferTemplate struct{}
 
-func (preferTemplate) Name() string             { return "prefer-template" }
-func (preferTemplate) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (preferTemplate) Name() string           { return "prefer-template" }
+func (preferTemplate) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (preferTemplate) Check(ctx *Context, node *shimast.Node) {
 	expr := node.AsBinaryExpression()
 	if expr == nil || expr.OperatorToken == nil {
@@ -1054,8 +1074,10 @@ func concatChainShape(node *shimast.Node) (hasString bool, hasOther bool) {
 // never yield are usually unintended.
 type requireYield struct{}
 
-func (requireYield) Name() string             { return "require-yield" }
-func (requireYield) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindFunctionDeclaration, shimast.KindFunctionExpression, shimast.KindMethodDeclaration} }
+func (requireYield) Name() string { return "require-yield" }
+func (requireYield) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindFunctionDeclaration, shimast.KindFunctionExpression, shimast.KindMethodDeclaration}
+}
 func (requireYield) Check(ctx *Context, node *shimast.Node) {
 	if !hasAsteriskModifier(node) {
 		return
@@ -1112,8 +1134,8 @@ func subtreeContainsYield(node *shimast.Node) bool {
 // function/script scope.
 type varsOnTop struct{}
 
-func (varsOnTop) Name() string             { return "vars-on-top" }
-func (varsOnTop) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindVariableStatement} }
+func (varsOnTop) Name() string           { return "vars-on-top" }
+func (varsOnTop) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindVariableStatement} }
 func (varsOnTop) Check(ctx *Context, node *shimast.Node) {
 	stmt := node.AsVariableStatement()
 	if stmt == nil || stmt.DeclarationList == nil {
@@ -1180,8 +1202,8 @@ func parentStatements(parent *shimast.Node) []*shimast.Node {
 // comparison as "yoda conditions". Default mode forbids them.
 type yoda struct{}
 
-func (yoda) Name() string             { return "yoda" }
-func (yoda) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (yoda) Name() string           { return "yoda" }
+func (yoda) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (yoda) Check(ctx *Context, node *shimast.Node) {
 	expr := node.AsBinaryExpression()
 	if expr == nil || expr.OperatorToken == nil {

package/{go-plugin/lint → plugin}/rules_throw.go

@@ -1,4 +1,4 @@
-package lint
+package main
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
@@ -6,8 +6,8 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 // https://eslint.org/docs/latest/rules/no-throw-literal
 type noThrowLiteral struct{}
 
-func (noThrowLiteral) Name() string             { return "no-throw-literal" }
-func (noThrowLiteral) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindThrowStatement} }
+func (noThrowLiteral) Name() string           { return "no-throw-literal" }
+func (noThrowLiteral) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindThrowStatement} }
 func (noThrowLiteral) Check(ctx *Context, node *shimast.Node) {
 	throw := node.AsThrowStatement()
 	if throw == nil {

package/{go-plugin/lint → plugin}/rules_ts.go

@@ -1,4 +1,4 @@
-package lint
+package main
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
@@ -6,8 +6,8 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 // `@typescript-eslint/no-explicit-any`.
 type noExplicitAny struct{}
 
-func (noExplicitAny) Name() string             { return "no-explicit-any" }
-func (noExplicitAny) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindAnyKeyword} }
+func (noExplicitAny) Name() string           { return "no-explicit-any" }
+func (noExplicitAny) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindAnyKeyword} }
 func (noExplicitAny) Check(ctx *Context, node *shimast.Node) {
 	ctx.Report(node, "Unexpected any. Specify a different type.")
 }
@@ -15,8 +15,10 @@ func (noExplicitAny) Check(ctx *Context, node *shimast.Node) {
 // no-non-null-assertion: ban the postfix `!` non-null assertion.
 type noNonNullAssertion struct{}
 
-func (noNonNullAssertion) Name() string             { return "no-non-null-assertion" }
-func (noNonNullAssertion) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindNonNullExpression} }
+func (noNonNullAssertion) Name() string { return "no-non-null-assertion" }
+func (noNonNullAssertion) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindNonNullExpression}
+}
 func (noNonNullAssertion) Check(ctx *Context, node *shimast.Node) {
 	ctx.Report(node, "Forbidden non-null assertion.")
 }
@@ -25,8 +27,10 @@ func (noNonNullAssertion) Check(ctx *Context, node *shimast.Node) {
 // for the supertype with extra ceremony.
 type noEmptyInterface struct{}
 
-func (noEmptyInterface) Name() string             { return "no-empty-interface" }
-func (noEmptyInterface) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindInterfaceDeclaration} }
+func (noEmptyInterface) Name() string { return "no-empty-interface" }
+func (noEmptyInterface) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindInterfaceDeclaration}
+}
 func (noEmptyInterface) Check(ctx *Context, node *shimast.Node) {
 	decl := node.AsInterfaceDeclaration()
 	if decl == nil || decl.Members == nil {
@@ -41,8 +45,10 @@ func (noEmptyInterface) Check(ctx *Context, node *shimast.Node) {
 // would have inferred anyway.
 type noInferrableTypes struct{}
 
-func (noInferrableTypes) Name() string             { return "no-inferrable-types" }
-func (noInferrableTypes) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindVariableDeclaration, shimast.KindParameter, shimast.KindPropertyDeclaration} }
+func (noInferrableTypes) Name() string { return "no-inferrable-types" }
+func (noInferrableTypes) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindVariableDeclaration, shimast.KindParameter, shimast.KindPropertyDeclaration}
+}
 func (noInferrableTypes) Check(ctx *Context, node *shimast.Node) {
 	var typeNode, init *shimast.Node
 	switch node.Kind {
@@ -114,8 +120,8 @@ func isUnaryNumeric(node *shimast.Node) bool {
 // exist for legacy reasons; modern TS uses ES modules.
 type noNamespace struct{}
 
-func (noNamespace) Name() string             { return "no-namespace" }
-func (noNamespace) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindModuleDeclaration} }
+func (noNamespace) Name() string           { return "no-namespace" }
+func (noNamespace) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindModuleDeclaration} }
 func (noNamespace) Check(ctx *Context, node *shimast.Node) {
 	decl := node.AsModuleDeclaration()
 	if decl == nil || decl.Name() == nil {
@@ -133,8 +139,8 @@ func (noNamespace) Check(ctx *Context, node *shimast.Node) {
 // arrow functions or `.bind(this)` instead.
 type noThisAlias struct{}
 
-func (noThisAlias) Name() string             { return "no-this-alias" }
-func (noThisAlias) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindVariableDeclaration} }
+func (noThisAlias) Name() string           { return "no-this-alias" }
+func (noThisAlias) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindVariableDeclaration} }
 func (noThisAlias) Check(ctx *Context, node *shimast.Node) {
 	decl := node.AsVariableDeclaration()
 	if decl == nil || decl.Initializer == nil {
@@ -148,8 +154,10 @@ func (noThisAlias) Check(ctx *Context, node *shimast.Node) {
 // prefer-as-const: `as 'foo'` / `as 1` should be `as const`.
 type preferAsConst struct{}
 
-func (preferAsConst) Name() string             { return "prefer-as-const" }
-func (preferAsConst) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindAsExpression, shimast.KindTypeAssertionExpression} }
+func (preferAsConst) Name() string { return "prefer-as-const" }
+func (preferAsConst) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindAsExpression, shimast.KindTypeAssertionExpression}
+}
 func (preferAsConst) Check(ctx *Context, node *shimast.Node) {
 	var expr, typeNode *shimast.Node
 	switch node.Kind {
@@ -198,8 +206,10 @@ func literalsMatchSourceText(file *shimast.SourceFile, lhs, rhs *shimast.Node) b
 // ES `import` instead.
 type noRequireImports struct{}
 
-func (noRequireImports) Name() string             { return "no-require-imports" }
-func (noRequireImports) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindCallExpression, shimast.KindImportEqualsDeclaration} }
+func (noRequireImports) Name() string { return "no-require-imports" }
+func (noRequireImports) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression, shimast.KindImportEqualsDeclaration}
+}
 func (noRequireImports) Check(ctx *Context, node *shimast.Node) {
 	switch node.Kind {
 	case shimast.KindCallExpression:
@@ -221,8 +231,8 @@ func (noRequireImports) Check(ctx *Context, node *shimast.Node) {
 // silence the type checker. Default mode flags every variant.
 type banTsComment struct{}
 
-func (banTsComment) Name() string             { return "ban-ts-comment" }
-func (banTsComment) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindSourceFile} }
+func (banTsComment) Name() string           { return "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