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

package/{go-plugin/go.mod → go.mod}

@@ -1,11 +1,11 @@
-module github.com/samchon/ttsc/packages/lint/go-plugin
+module github.com/samchon/ttsc/packages/lint
 
 go 1.26
 
 // The plugin depends only on the `microsoft/typescript-go/shim/*`
 // modules so that `go mod tidy` works against the public proxy. The
 // bootstrap glue (Program creation, diagnostic rendering, emit) is
-// inlined under ./lint/host.go to avoid a transitive dependency on the
+// inlined under ./plugin/host.go to avoid a transitive dependency on the
 // in-tree `github.com/samchon/ttsc/packages/ttsc` module — that module
 // has no public version tag and would only resolve through ttsc's
 // scratch-dir go.work overlay, which conflicts with go.mod-level
@@ -30,7 +30,7 @@ require (
 require (
 	github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
-	github.com/microsoft/typescript-go v0.0.0-20260424234512-515d036f927a // indirect
+	github.com/microsoft/typescript-go v0.0.0-20260428010401-3499951dbc49 // indirect
 	github.com/zeebo/xxh3 v1.1.0 // indirect
 	golang.org/x/sync v0.20.0 // indirect
 	golang.org/x/sys v0.42.0 // indirect

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.5.0-dev.20260429",
+  "version": "0.5.0-dev.20260429-2",
   "description": "Reference ttsc plugin: ESLint-style lint rules hosted in the same Program/Checker as the type-check pass.",
-  "main": "index.cjs",
+  "main": "src/index.cjs",
   "exports": {
-    ".": "./index.cjs",
+    ".": "./src/index.cjs",
     "./package.json": "./package.json"
   },
   "keywords": [
@@ -16,10 +16,9 @@
   ],
   "files": [
     "README.md",
-    "index.cjs",
-    "go-plugin/go.mod",
-    "go-plugin/main.go",
-    "go-plugin/lint"
+    "src/index.cjs",
+    "go.mod",
+    "plugin"
   ],
   "repository": {
     "type": "git",

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

@@ -1,4 +1,4 @@
-package lint
+package main
 
 import (
 	"strings"

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

@@ -9,7 +9,7 @@
 // The split between this file and `engine.go` is deliberate: the engine
 // is pure (rules + AST traversal), and this file owns every side effect
 // (process flags, stderr/stdout, emit, exit codes).
-package lint
+package main
 
 import (
 	"context"

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

@@ -1,4 +1,4 @@
-package lint
+package main
 
 import (
 	"encoding/json"

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

@@ -1,4 +1,4 @@
-// Package lint hosts the rule registry, the AST-walking engine, and the
+// The lint plugin hosts the rule registry, the AST-walking engine, and the
 // orchestration glue that the `@ttsc/lint` native plugin uses to run rules
 // against a tsgo Program.
 //
@@ -15,7 +15,7 @@
 // and may not retain references to the previous file. This keeps the
 // engine concurrent-friendly even though the v0 implementation runs
 // serially.
-package lint
+package main
 
 import (
 	"sort"
@@ -146,10 +146,10 @@ func AllRuleNames() []string {
 // Engine binds a rule configuration to a Program and walks the AST once
 // per source file, dispatching each visited node to its interested rules.
 type Engine struct {
-	config   RuleConfig
-	rules    map[shimast.Kind][]Rule
-	enabled  map[string]Severity
-	unknown  []string
+	config  RuleConfig
+	rules   map[shimast.Kind][]Rule
+	enabled map[string]Severity
+	unknown []string
 }
 
 // NewEngine returns an engine configured for `config`. Rules whose

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

@@ -7,7 +7,7 @@
 // ttsc's runtime-generated go.work overlay. Instead, this file inlines a
 // minimal Program/Checker bootstrap (the same pattern documented in
 // 03-tsgo.md and used by every other source-plugin reference fixture).
-package lint
+package main
 
 import (
 	"context"

package/{go-plugin → plugin}/main.go

@@ -18,8 +18,6 @@ package main
 import (
 	"fmt"
 	"os"
-
-	"github.com/samchon/ttsc/packages/lint/go-plugin/lint"
 )
 
 const version = "0.0.1"
@@ -38,11 +36,11 @@ func run(args []string) int {
 		fmt.Fprintf(os.Stdout, "@ttsc/lint %s\n", version)
 		return 0
 	case "check":
-		return lint.RunCheck(args[1:])
+		return RunCheck(args[1:])
 	case "build":
-		return lint.RunBuild(args[1:])
+		return RunBuild(args[1:])
 	case "transform":
-		return lint.RunTransform(args[1:])
+		return RunTransform(args[1:])
 	default:
 		fmt.Fprintf(os.Stderr, "@ttsc/lint: unknown command %q\n", args[0])
 		return 2

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

@@ -1,4 +1,4 @@
-package lint
+package main
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
@@ -7,8 +7,10 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 // https://eslint.org/docs/latest/rules/no-sparse-arrays
 type noSparseArrays struct{}
 
-func (noSparseArrays) Name() string             { return "no-sparse-arrays" }
-func (noSparseArrays) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindArrayLiteralExpression} }
+func (noSparseArrays) Name() string { return "no-sparse-arrays" }
+func (noSparseArrays) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindArrayLiteralExpression}
+}
 func (noSparseArrays) Check(ctx *Context, node *shimast.Node) {
 	arr := node.AsArrayLiteralExpression()
 	if arr == nil || arr.Elements == nil {

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

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

package/{go-plugin/lint → plugin}/rules_debugger.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-debugger
 type noDebugger struct{}
 
-func (noDebugger) Name() string             { return "no-debugger" }
-func (noDebugger) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindDebuggerStatement} }
+func (noDebugger) Name() string           { return "no-debugger" }
+func (noDebugger) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindDebuggerStatement} }
 func (noDebugger) Check(ctx *Context, node *shimast.Node) {
 	ctx.Report(node, "Unexpected `debugger` statement.")
 }
@@ -17,8 +17,8 @@ func (noDebugger) Check(ctx *Context, node *shimast.Node) {
 // https://eslint.org/docs/latest/rules/no-with
 type noWith struct{}
 
-func (noWith) Name() string             { return "no-with" }
-func (noWith) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindWithStatement} }
+func (noWith) Name() string           { return "no-with" }
+func (noWith) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindWithStatement} }
 func (noWith) Check(ctx *Context, node *shimast.Node) {
 	ctx.Report(node, "Unexpected `with` statement.")
 }

package/{go-plugin/lint → plugin}/rules_dupes.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-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) 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 {
@@ -42,8 +42,8 @@ func (noDuplicateCase) Check(ctx *Context, node *shimast.Node) {
 // 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) 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 {

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

@@ -1,4 +1,4 @@
-package lint
+package main
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
@@ -7,8 +7,8 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 // 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) 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 {
@@ -31,7 +31,7 @@ func (noEmpty) Check(ctx *Context, node *shimast.Node) {
 // https://eslint.org/docs/latest/rules/no-empty-function
 type noEmptyFunction struct{}
 
-func (noEmptyFunction) Name() string             { return "no-empty-function" }
+func (noEmptyFunction) Name() string { return "no-empty-function" }
 func (noEmptyFunction) Visits() []shimast.Kind {
 	return []shimast.Kind{
 		shimast.KindFunctionDeclaration,

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

@@ -1,4 +1,4 @@
-package lint
+package main
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
@@ -8,8 +8,8 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 // 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) 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 {
@@ -25,8 +25,10 @@ func (noEval) Check(ctx *Context, node *shimast.Node) {
 // 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) 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) {

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

@@ -1,4 +1,4 @@
-package lint
+package main
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
@@ -76,8 +76,8 @@ func keywordOfControl(node *shimast.Node) string {
 // 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) 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 {

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

@@ -1,4 +1,4 @@
-package lint
+package main
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
@@ -83,8 +83,8 @@ func skipParents(node *shimast.Node) *shimast.Node {
 // https://eslint.org/docs/latest/rules/no-unsafe-negation
 type noUnsafeNegation struct{}
 
-func (noUnsafeNegation) Name() string             { return "no-unsafe-negation" }
-func (noUnsafeNegation) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (noUnsafeNegation) Name() string           { return "no-unsafe-negation" }
+func (noUnsafeNegation) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (noUnsafeNegation) Check(ctx *Context, node *shimast.Node) {
 	expr := node.AsBinaryExpression()
 	if expr == nil || expr.OperatorToken == nil {
@@ -110,8 +110,8 @@ func (noUnsafeNegation) Check(ctx *Context, node *shimast.Node) {
 // https://eslint.org/docs/latest/rules/eqeqeq
 type eqeqeq struct{}
 
-func (eqeqeq) Name() string             { return "eqeqeq" }
-func (eqeqeq) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (eqeqeq) Name() string           { return "eqeqeq" }
+func (eqeqeq) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (eqeqeq) Check(ctx *Context, node *shimast.Node) {
 	expr := node.AsBinaryExpression()
 	if expr == nil || expr.OperatorToken == nil {
@@ -129,8 +129,8 @@ func (eqeqeq) Check(ctx *Context, node *shimast.Node) {
 // https://eslint.org/docs/latest/rules/use-isnan
 type useIsnan struct{}
 
-func (useIsnan) Name() string             { return "use-isnan" }
-func (useIsnan) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (useIsnan) Name() string           { return "use-isnan" }
+func (useIsnan) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (useIsnan) Check(ctx *Context, node *shimast.Node) {
 	expr := node.AsBinaryExpression()
 	if expr == nil || expr.OperatorToken == nil {
@@ -149,8 +149,8 @@ func (useIsnan) Check(ctx *Context, node *shimast.Node) {
 // https://eslint.org/docs/latest/rules/valid-typeof
 type validTypeof struct{}
 
-func (validTypeof) Name() string             { return "valid-typeof" }
-func (validTypeof) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (validTypeof) Name() string           { return "valid-typeof" }
+func (validTypeof) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (validTypeof) Check(ctx *Context, node *shimast.Node) {
 	expr := node.AsBinaryExpression()
 	if expr == nil || expr.OperatorToken == nil {
@@ -194,8 +194,8 @@ func isValidTypeofString(value string) bool {
 // https://eslint.org/docs/latest/rules/no-compare-neg-zero
 type noCompareNegZero struct{}
 
-func (noCompareNegZero) Name() string             { return "no-compare-neg-zero" }
-func (noCompareNegZero) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (noCompareNegZero) Name() string           { return "no-compare-neg-zero" }
+func (noCompareNegZero) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (noCompareNegZero) Check(ctx *Context, node *shimast.Node) {
 	expr := node.AsBinaryExpression()
 	if expr == nil || expr.OperatorToken == nil {

package/{go-plugin/lint → plugin}/rules_loops.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/for-direction
 type forDirection struct{}
 
-func (forDirection) Name() string             { return "for-direction" }
-func (forDirection) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindForStatement} }
+func (forDirection) Name() string           { return "for-direction" }
+func (forDirection) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindForStatement} }
 func (forDirection) Check(ctx *Context, node *shimast.Node) {
 	loop := node.AsForStatement()
 	if loop == nil || loop.Condition == nil || loop.Incrementor == nil {

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

@@ -1,4 +1,4 @@
-package lint
+package main
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
@@ -7,8 +7,8 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 // https://eslint.org/docs/latest/rules/radix
 type radix struct{}
 
-func (radix) Name() string             { return "radix" }
-func (radix) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindCallExpression} }
+func (radix) Name() string           { return "radix" }
+func (radix) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindCallExpression} }
 func (radix) Check(ctx *Context, node *shimast.Node) {
 	call := node.AsCallExpression()
 	if call == nil {
@@ -50,8 +50,8 @@ func (radix) Check(ctx *Context, node *shimast.Node) {
 // https://eslint.org/docs/latest/rules/no-new-wrappers
 type noNewWrappers struct{}
 
-func (noNewWrappers) Name() string             { return "no-new-wrappers" }
-func (noNewWrappers) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindNewExpression} }
+func (noNewWrappers) Name() string           { return "no-new-wrappers" }
+func (noNewWrappers) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindNewExpression} }
 func (noNewWrappers) Check(ctx *Context, node *shimast.Node) {
 	ne := node.AsNewExpression()
 	if ne == nil {

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

@@ -5,7 +5,7 @@
 // fast and predictable. Rules that require scope binding or
 // flow-sensitive analysis are intentionally not implemented here —
 // those are upstream's job.
-package lint
+package main
 
 import (
 	"strings"
@@ -17,8 +17,8 @@ import (
 // unreachable.
 type noDupeElseIf struct{}
 
-func (noDupeElseIf) Name() string             { return "no-dupe-else-if" }
-func (noDupeElseIf) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindIfStatement} }
+func (noDupeElseIf) Name() string           { return "no-dupe-else-if" }
+func (noDupeElseIf) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindIfStatement} }
 func (noDupeElseIf) Check(ctx *Context, node *shimast.Node) {
 	// Only fire on the *outermost* if; the recursion below scans the
 	// chain once.
@@ -53,8 +53,8 @@ func (noDupeElseIf) Check(ctx *Context, node *shimast.Node) {
 // binding silently throws away the error.
 type noExAssign struct{}
 
-func (noExAssign) Name() string             { return "no-ex-assign" }
-func (noExAssign) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindCatchClause} }
+func (noExAssign) Name() string           { return "no-ex-assign" }
+func (noExAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindCatchClause} }
 func (noExAssign) Check(ctx *Context, node *shimast.Node) {
 	clause := node.AsCatchClause()
 	if clause == nil || clause.VariableDeclaration == nil || clause.Block == nil {
@@ -99,8 +99,10 @@ func walkAssignments(root *shimast.Node, name string, report func(*shimast.Node)
 // no-empty-character-class: `/[]/` matches nothing.
 type noEmptyCharacterClass struct{}
 
-func (noEmptyCharacterClass) Name() string             { return "no-empty-character-class" }
-func (noEmptyCharacterClass) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindRegularExpressionLiteral} }
+func (noEmptyCharacterClass) Name() string { return "no-empty-character-class" }
+func (noEmptyCharacterClass) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindRegularExpressionLiteral}
+}
 func (noEmptyCharacterClass) Check(ctx *Context, node *shimast.Node) {
 	src := nodeText(ctx.File, node)
 	if hasEmptyCharClass(src) {
@@ -130,8 +132,10 @@ func hasEmptyCharClass(src string) bool {
 // no-misleading-character-class: `/[👍]/` — surrogate pairs in regex.
 type noMisleadingCharacterClass struct{}
 
-func (noMisleadingCharacterClass) Name() string             { return "no-misleading-character-class" }
-func (noMisleadingCharacterClass) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindRegularExpressionLiteral} }
+func (noMisleadingCharacterClass) Name() string { return "no-misleading-character-class" }
+func (noMisleadingCharacterClass) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindRegularExpressionLiteral}
+}
 func (noMisleadingCharacterClass) Check(ctx *Context, node *shimast.Node) {
 	src := nodeText(ctx.File, node)
 	if regexHasSurrogatePair(src) {
@@ -172,8 +176,8 @@ func regexHasSurrogatePair(src string) bool {
 // that.
 type noLossOfPrecision struct{}
 
-func (noLossOfPrecision) Name() string             { return "no-loss-of-precision" }
-func (noLossOfPrecision) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindNumericLiteral} }
+func (noLossOfPrecision) Name() string           { return "no-loss-of-precision" }
+func (noLossOfPrecision) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindNumericLiteral} }
 func (noLossOfPrecision) Check(ctx *Context, node *shimast.Node) {
 	source := strings.TrimSpace(nodeText(ctx.File, node))
 	if source == "" {
@@ -214,8 +218,8 @@ func numericLiteralLosesPrecision(text string) bool {
 // no-class-assign: assigning to a class declaration's name.
 type noClassAssign struct{}
 
-func (noClassAssign) Name() string             { return "no-class-assign" }
-func (noClassAssign) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindClassDeclaration} }
+func (noClassAssign) Name() string           { return "no-class-assign" }
+func (noClassAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindClassDeclaration} }
 func (noClassAssign) Check(ctx *Context, node *shimast.Node) {
 	decl := node.AsClassDeclaration()
 	if decl == nil || decl.Name() == nil {
@@ -233,8 +237,8 @@ func (noClassAssign) Check(ctx *Context, node *shimast.Node) {
 // no-func-assign: same idea, but for function declarations.
 type noFuncAssign struct{}
 
-func (noFuncAssign) Name() string             { return "no-func-assign" }
-func (noFuncAssign) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindFunctionDeclaration} }
+func (noFuncAssign) Name() string           { return "no-func-assign" }
+func (noFuncAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindFunctionDeclaration} }
 func (noFuncAssign) Check(ctx *Context, node *shimast.Node) {
 	decl := node.AsFunctionDeclaration()
 	if decl == nil || decl.Name() == nil {
@@ -253,8 +257,8 @@ func (noFuncAssign) Check(ctx *Context, node *shimast.Node) {
 // `Object.prototype.hasOwnProperty.call(obj, x)` or `Object.hasOwn`.
 type noPrototypeBuiltins struct{}
 
-func (noPrototypeBuiltins) Name() string             { return "no-prototype-builtins" }
-func (noPrototypeBuiltins) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindCallExpression} }
+func (noPrototypeBuiltins) Name() string           { return "no-prototype-builtins" }
+func (noPrototypeBuiltins) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindCallExpression} }
 func (noPrototypeBuiltins) Check(ctx *Context, node *shimast.Node) {
 	call := node.AsCallExpression()
 	if call == nil || call.Expression == nil {
@@ -277,8 +281,10 @@ func (noPrototypeBuiltins) Check(ctx *Context, node *shimast.Node) {
 // no-async-promise-executor: `new Promise(async (resolve) => {...})`.
 type noAsyncPromiseExecutor struct{}
 
-func (noAsyncPromiseExecutor) Name() string             { return "no-async-promise-executor" }
-func (noAsyncPromiseExecutor) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindNewExpression} }
+func (noAsyncPromiseExecutor) Name() string { return "no-async-promise-executor" }
+func (noAsyncPromiseExecutor) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindNewExpression}
+}
 func (noAsyncPromiseExecutor) Check(ctx *Context, node *shimast.Node) {
 	ne := node.AsNewExpression()
 	if ne == nil || identifierText(ne.Expression) != "Promise" {
@@ -303,8 +309,10 @@ func (noAsyncPromiseExecutor) Check(ctx *Context, node *shimast.Node) {
 // thrown away.
 type noPromiseExecutorReturn struct{}
 
-func (noPromiseExecutorReturn) Name() string             { return "no-promise-executor-return" }
-func (noPromiseExecutorReturn) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindNewExpression} }
+func (noPromiseExecutorReturn) Name() string { return "no-promise-executor-return" }
+func (noPromiseExecutorReturn) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindNewExpression}
+}
 func (noPromiseExecutorReturn) Check(ctx *Context, node *shimast.Node) {
 	ne := node.AsNewExpression()
 	if ne == nil || identifierText(ne.Expression) != "Promise" {
@@ -332,8 +340,10 @@ func (noPromiseExecutorReturn) Check(ctx *Context, node *shimast.Node) {
 // counterpart.
 type noControlRegex struct{}
 
-func (noControlRegex) Name() string             { return "no-control-regex" }
-func (noControlRegex) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindRegularExpressionLiteral} }
+func (noControlRegex) Name() string { return "no-control-regex" }
+func (noControlRegex) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindRegularExpressionLiteral}
+}
 func (noControlRegex) Check(ctx *Context, node *shimast.Node) {
 	src := nodeText(ctx.File, node)
 	if regexContainsControl(src) {
@@ -388,8 +398,8 @@ func hexDigit(b byte) int {
 // accepts them but copy-paste into source is almost always a mistake.
 type noIrregularWhitespace struct{}
 
-func (noIrregularWhitespace) Name() string             { return "no-irregular-whitespace" }
-func (noIrregularWhitespace) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindSourceFile} }
+func (noIrregularWhitespace) Name() string           { return "no-irregular-whitespace" }
+func (noIrregularWhitespace) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
 func (noIrregularWhitespace) Check(ctx *Context, node *shimast.Node) {
 	if ctx.File == nil {
 		return
@@ -421,8 +431,8 @@ func isIrregularWhitespace(r rune) bool {
 // without an explicit `break` / `return` / `throw` / `continue`.
 type noFallthrough struct{}
 
-func (noFallthrough) Name() string             { return "no-fallthrough" }
-func (noFallthrough) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindSwitchStatement} }
+func (noFallthrough) Name() string           { return "no-fallthrough" }
+func (noFallthrough) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSwitchStatement} }
 func (noFallthrough) Check(ctx *Context, node *shimast.Node) {
 	sw := node.AsSwitchStatement()
 	if sw == nil || sw.CaseBlock == nil {
@@ -519,8 +529,10 @@ func (noInnerDeclarations) Check(ctx *Context, node *shimast.Node) {
 // callables. ESLint catches a small list.
 type noObjCalls struct{}
 
-func (noObjCalls) Name() string             { return "no-obj-calls" }
-func (noObjCalls) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindCallExpression, shimast.KindNewExpression} }
+func (noObjCalls) Name() string { return "no-obj-calls" }
+func (noObjCalls) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindCallExpression, shimast.KindNewExpression}
+}
 func (noObjCalls) Check(ctx *Context, node *shimast.Node) {
 	var callee *shimast.Node
 	if node.Kind == shimast.KindCallExpression {

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

@@ -1,4 +1,4 @@
-package lint
+package main
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
@@ -7,8 +7,10 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 // https://eslint.org/docs/latest/rules/no-iterator
 type noIterator struct{}
 
-func (noIterator) Name() string             { return "no-iterator" }
-func (noIterator) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindPropertyAccessExpression} }
+func (noIterator) Name() string { return "no-iterator" }
+func (noIterator) Visits() []shimast.Kind {
+	return []shimast.Kind{shimast.KindPropertyAccessExpression}
+}
 func (noIterator) Check(ctx *Context, node *shimast.Node) {
 	access := node.AsPropertyAccessExpression()
 	if access == nil {
@@ -24,8 +26,8 @@ func (noIterator) Check(ctx *Context, node *shimast.Node) {
 // https://eslint.org/docs/latest/rules/no-proto
 type noProto struct{}
 
-func (noProto) Name() string             { return "no-proto" }
-func (noProto) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindPropertyAccessExpression} }
+func (noProto) Name() string           { return "no-proto" }
+func (noProto) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindPropertyAccessExpression} }
 func (noProto) Check(ctx *Context, node *shimast.Node) {
 	access := node.AsPropertyAccessExpression()
 	if access == nil {

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

@@ -1,4 +1,4 @@
-package lint
+package main
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
@@ -8,8 +8,8 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 // https://eslint.org/docs/latest/rules/no-self-assign
 type noSelfAssign struct{}
 
-func (noSelfAssign) Name() string             { return "no-self-assign" }
-func (noSelfAssign) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (noSelfAssign) Name() string           { return "no-self-assign" }
+func (noSelfAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (noSelfAssign) Check(ctx *Context, node *shimast.Node) {
 	expr := node.AsBinaryExpression()
 	if expr == nil || expr.OperatorToken == nil {
@@ -47,8 +47,8 @@ func isAssignableLeftHand(node *shimast.Node) bool {
 // https://eslint.org/docs/latest/rules/no-self-compare
 type noSelfCompare struct{}
 
-func (noSelfCompare) Name() string             { return "no-self-compare" }
-func (noSelfCompare) Visits() []shimast.Kind   { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (noSelfCompare) Name() string           { return "no-self-compare" }
+func (noSelfCompare) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
 func (noSelfCompare) Check(ctx *Context, node *shimast.Node) {
 	expr := node.AsBinaryExpression()
 	if expr == nil || expr.OperatorToken == nil {