kimaki 0.4.78 → 0.4.80

package/skills/lintcn/SKILL.md

@@ -0,0 +1,749 @@
+---
+name: lintcn
+description: >
+  Write, add, and update type-aware TypeScript lint rules in .lintcn/ Go files.
+  ALWAYS use this skill when creating, editing, or debugging .lintcn/*.go rule files.
+  Covers the tsgolint rule API, AST visitors, type checker, reporting, fixes,
+  testing, and all patterns from the 50+ built-in rules.
+---
+
+# lintcn — Writing Custom tsgolint Lint Rules
+
+tsgolint rules are Go functions that listen for TypeScript AST nodes and use the
+TypeScript type checker for type-aware analysis. Rules live as `.go` files in
+`.lintcn/` and are compiled into a custom tsgolint binary.
+
+Always run `go build ./...` inside `.lintcn/` to validate rules compile.
+Always run `go test -v ./...` inside `.lintcn/` to run tests.
+
+## Rule Anatomy
+
+Every rule is a `rule.Rule` struct with a `Name` and a `Run` function.
+`Run` receives a `RuleContext` and returns a `RuleListeners` map — a map from
+`ast.Kind` to callback functions. The linter walks the AST and calls your
+callback when it encounters a node of that kind.
+
+```go
+package lintcn
+
+import (
+    "github.com/microsoft/typescript-go/shim/ast"
+    "github.com/typescript-eslint/tsgolint/internal/rule"
+)
+
+var MyRule = rule.Rule{
+    Name: "my-rule",
+    Run: func(ctx rule.RuleContext, options any) rule.RuleListeners {
+        return rule.RuleListeners{
+            ast.KindCallExpression: func(node *ast.Node) {
+                call := node.AsCallExpression()
+                // analyze the call...
+                ctx.ReportNode(node, rule.RuleMessage{
+                    Id:          "myError",
+                    Description: "Something is wrong here.",
+                })
+            },
+        }
+    },
+}
+```
+
+### Metadata Comments
+
+Add `// lintcn:` comments at the top for CLI metadata:
+
+```go
+// lintcn:name my-rule
+// lintcn:description Disallow doing X without checking Y
+```
+
+### Package Name
+
+All rule files in `.lintcn/` share `package lintcn`. The exported variable name
+must be unique and match the pattern `var XxxRule = rule.Rule{...}`.
+
+## RuleContext
+
+`ctx rule.RuleContext` provides:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `SourceFile` | `*ast.SourceFile` | Current file being linted |
+| `Program` | `*compiler.Program` | Full TypeScript program |
+| `TypeChecker` | `*checker.Checker` | TypeScript type checker |
+| `ReportNode` | `func(node, msg)` | Report error on a node |
+| `ReportNodeWithFixes` | `func(node, msg, fixesFn)` | Report with auto-fixes |
+| `ReportNodeWithSuggestions` | `func(node, msg, suggFn)` | Report with suggestions |
+| `ReportRange` | `func(range, msg)` | Report on a text range |
+| `ReportDiagnostic` | `func(diagnostic)` | Report with labeled ranges |
+
+## AST Node Listeners
+
+### Most Useful ast.Kind Values
+
+```go
+// Statements
+ast.KindExpressionStatement      // bare expression: `foo();`
+ast.KindReturnStatement          // `return x`
+ast.KindThrowStatement           // `throw x`
+ast.KindIfStatement              // `if (x) { ... }`
+ast.KindVariableDeclaration      // `const x = ...`
+ast.KindForInStatement           // `for (x in y)`
+
+// Expressions
+ast.KindCallExpression           // `foo()` — most commonly listened
+ast.KindNewExpression            // `new Foo()`
+ast.KindBinaryExpression         // `a + b`, `a === b`, `a = b`
+ast.KindPropertyAccessExpression // `obj.prop`
+ast.KindElementAccessExpression  // `obj[key]`
+ast.KindAwaitExpression          // `await x`
+ast.KindConditionalExpression    // `a ? b : c`
+ast.KindPrefixUnaryExpression    // `!x`, `-x`, `typeof x`
+ast.KindTemplateExpression       // `hello ${name}`
+ast.KindDeleteExpression         // `delete obj.x`
+ast.KindVoidExpression           // `void x`
+
+// Declarations
+ast.KindFunctionDeclaration
+ast.KindArrowFunction
+ast.KindMethodDeclaration
+ast.KindClassDeclaration
+ast.KindEnumDeclaration
+
+// Types
+ast.KindUnionType                // `A | B`
+ast.KindIntersectionType         // `A & B`
+ast.KindAsExpression             // `x as T`
+```
+
+### Enter and Exit Listeners
+
+By default, listeners fire when the AST walker **enters** a node.
+Use `rule.ListenerOnExit(kind)` to fire when the walker **exits** — useful
+for scope tracking:
+
+```go
+return rule.RuleListeners{
+    // enter function — push scope
+    ast.KindFunctionDeclaration: func(node *ast.Node) {
+        currentScope = &scopeInfo{upper: currentScope}
+    },
+    // exit function — pop scope and check
+    rule.ListenerOnExit(ast.KindFunctionDeclaration): func(node *ast.Node) {
+        if !currentScope.hasAwait {
+            ctx.ReportNode(node, msg)
+        }
+        currentScope = currentScope.upper
+    },
+}
+```
+
+Used by require_await, return_await, consistent_return, prefer_readonly for
+tracking state across function bodies with a scope stack.
+
+### Allow/NotAllow Pattern Listeners
+
+For destructuring and assignment contexts:
+
+```go
+rule.ListenerOnAllowPattern(ast.KindObjectLiteralExpression)     // inside destructuring
+rule.ListenerOnNotAllowPattern(ast.KindArrayLiteralExpression)   // outside destructuring
+```
+
+Used by no_unsafe_assignment and unbound_method.
+
+## Type Checker APIs
+
+### Getting Types
+
+```go
+// Get the type of any AST node
+t := ctx.TypeChecker.GetTypeAtLocation(node)
+
+// Get type with constraint resolution (unwraps type params)
+t := utils.GetConstrainedTypeAtLocation(ctx.TypeChecker, node)
+
+// Get the contextual type (what TypeScript expects at this position)
+t := checker.Checker_getContextualType(ctx.TypeChecker, node, checker.ContextFlagsNone)
+
+// Get the apparent type (resolves mapped types, intersections)
+t := checker.Checker_getApparentType(ctx.TypeChecker, t)
+
+// Get awaited type (unwraps Promise)
+t := checker.Checker_getAwaitedType(ctx.TypeChecker, t)
+
+// Get type from a type annotation node
+t := checker.Checker_getTypeFromTypeNode(ctx.TypeChecker, typeNode)
+```
+
+### Type Flag Checks
+
+TypeFlags are bitmasks — check with `utils.IsTypeFlagSet`:
+
+```go
+// Check specific flags
+if utils.IsTypeFlagSet(t, checker.TypeFlagsVoid) { return }
+if utils.IsTypeFlagSet(t, checker.TypeFlagsUndefined) { return }
+if utils.IsTypeFlagSet(t, checker.TypeFlagsNever) { return }
+if utils.IsTypeFlagSet(t, checker.TypeFlagsAny) { return }
+
+// Combine flags with |
+if utils.IsTypeFlagSet(t, checker.TypeFlagsVoid|checker.TypeFlagsUndefined|checker.TypeFlagsNever) {
+    return // skip void, undefined, and never
+}
+
+// Convenience helpers
+utils.IsTypeAnyType(t)
+utils.IsTypeUnknownType(t)
+utils.IsObjectType(t)
+utils.IsTypeParameter(t)
+```
+
+### Union and Intersection Types
+
+**Decomposing unions is the most common pattern** — 58 uses across all rules:
+
+```go
+// Iterate over union parts: `Error | string` → [Error, string]
+for _, part := range utils.UnionTypeParts(t) {
+    if utils.IsErrorLike(ctx.Program, ctx.TypeChecker, part) {
+        hasError = true
+        break
+    }
+}
+
+// Check if it's a union type
+if utils.IsUnionType(t) { ... }
+if utils.IsIntersectionType(t) { ... }
+
+// Iterate intersection parts
+for _, part := range utils.IntersectionTypeParts(t) { ... }
+
+// Recursive predicate check across union/intersection
+result := utils.TypeRecurser(t, func(t *checker.Type) bool {
+    return utils.IsTypeAnyType(t)
+})
+```
+
+### Built-in Type Checks
+
+```go
+// Error types
+utils.IsErrorLike(ctx.Program, ctx.TypeChecker, t)
+utils.IsReadonlyErrorLike(ctx.Program, ctx.TypeChecker, t)
+
+// Promise types
+utils.IsPromiseLike(ctx.Program, ctx.TypeChecker, t)
+utils.IsThenableType(ctx.TypeChecker, node, t)
+
+// Array types
+checker.Checker_isArrayType(ctx.TypeChecker, t)
+checker.IsTupleType(t)
+checker.Checker_isArrayOrTupleType(ctx.TypeChecker, t)
+
+// Generic built-in matching
+utils.IsBuiltinSymbolLike(ctx.Program, ctx.TypeChecker, t, "Function")
+utils.IsBuiltinSymbolLike(ctx.Program, ctx.TypeChecker, t, "RegExp")
+utils.IsBuiltinSymbolLike(ctx.Program, ctx.TypeChecker, t, "ReadonlyArray")
+```
+
+### Type Properties and Signatures
+
+```go
+// Get a named property from a type
+prop := checker.Checker_getPropertyOfType(ctx.TypeChecker, t, "then")
+if prop != nil {
+    propType := ctx.TypeChecker.GetTypeOfSymbolAtLocation(prop, node)
+}
+
+// Get all properties
+props := checker.Checker_getPropertiesOfType(ctx.TypeChecker, t)
+
+// Get call signatures (for callable types)
+sigs := utils.GetCallSignatures(ctx.TypeChecker, t)
+// or
+sigs := ctx.TypeChecker.GetCallSignatures(t)
+
+// Get signature parameters
+params := checker.Signature_parameters(sig)
+
+// Get return type of a signature
+returnType := checker.Checker_getReturnTypeOfSignature(ctx.TypeChecker, sig)
+
+// Get type arguments (for generics, arrays, tuples)
+typeArgs := checker.Checker_getTypeArguments(ctx.TypeChecker, t)
+
+// Get resolved call signature at a call site
+sig := checker.Checker_getResolvedSignature(ctx.TypeChecker, callNode)
+```
+
+### Type Assignability
+
+```go
+// Check if source is assignable to target
+if checker.Checker_isTypeAssignableTo(ctx.TypeChecker, sourceType, targetType) {
+    // source extends target
+}
+
+// Get base constraint of a type parameter
+constraint := checker.Checker_getBaseConstraintOfType(ctx.TypeChecker, t)
+```
+
+### Symbols
+
+```go
+// Get symbol at a location
+symbol := ctx.TypeChecker.GetSymbolAtLocation(node)
+
+// Get declaration for a symbol
+decl := utils.GetDeclaration(ctx.TypeChecker, node)
+
+// Get type from symbol
+t := checker.Checker_getTypeOfSymbol(ctx.TypeChecker, symbol)
+t := checker.Checker_getDeclaredTypeOfSymbol(ctx.TypeChecker, symbol)
+
+// Check if symbol comes from default library
+utils.IsSymbolFromDefaultLibrary(ctx.Program, symbol)
+
+// Get the accessed property name (works with computed properties too)
+name, ok := checker.Checker_getAccessedPropertyName(ctx.TypeChecker, node)
+```
+
+### Formatting Types for Error Messages
+
+```go
+typeName := ctx.TypeChecker.TypeToString(t)
+// → "string", "Error | User", "Promise<number>", etc.
+
+// Shorter type name helper
+name := utils.GetTypeName(ctx.TypeChecker, t)
+```
+
+## AST Navigation
+
+### Node Casting
+
+Every AST node is `*ast.Node`. Use `.AsXxx()` to access specific fields:
+
+```go
+call := node.AsCallExpression()
+call.Expression    // the callee
+call.Arguments     // argument list
+
+binary := node.AsBinaryExpression()
+binary.Left
+binary.Right
+binary.OperatorToken.Kind  // ast.KindEqualsToken, ast.KindPlusToken, etc.
+
+prop := node.AsPropertyAccessExpression()
+prop.Expression    // object
+prop.Name()        // property name node
+```
+
+### Type Predicates
+
+```go
+ast.IsCallExpression(node)
+ast.IsPropertyAccessExpression(node)
+ast.IsIdentifier(node)
+ast.IsAccessExpression(node)   // property OR element access
+ast.IsBinaryExpression(node)
+ast.IsAssignmentExpression(node, includeCompound)  // a = b, a += b
+ast.IsVoidExpression(node)
+ast.IsAwaitExpression(node)
+ast.IsFunctionLike(node)
+ast.IsArrowFunction(node)
+ast.IsStringLiteral(node)
+```
+
+### Skipping Parentheses
+
+Always skip parentheses when analyzing expression content:
+
+```go
+expression := ast.SkipParentheses(node.AsExpressionStatement().Expression)
+```
+
+### Walking Parents
+
+```go
+parent := node.Parent
+for parent != nil {
+    if ast.IsCallExpression(parent) {
+        // node is inside a call expression
+        break
+    }
+    parent = parent.Parent
+}
+```
+
+## Reporting Errors
+
+### Simple Error
+
+```go
+ctx.ReportNode(node, rule.RuleMessage{
+    Id:          "myErrorId",    // unique ID for the error
+    Description: "Something is wrong.",
+    Help:        "Optional longer explanation.",  // shown as help text
+})
+```
+
+### Error with Auto-Fix
+
+Fixes are applied automatically by the linter:
+
+```go
+ctx.ReportNodeWithFixes(node, msg, func() []rule.RuleFix {
+    return []rule.RuleFix{
+        rule.RuleFixInsertBefore(ctx.SourceFile, node, "await "),
+    }
+})
+```
+
+### Error with Suggestions
+
+Suggestions require user confirmation:
+
+```go
+ctx.ReportNodeWithSuggestions(node, msg, func() []rule.RuleSuggestion {
+    return []rule.RuleSuggestion{{
+        Message:  rule.RuleMessage{Id: "addAwait", Description: "Add await"},
+        FixesArr: []rule.RuleFix{
+            rule.RuleFixInsertBefore(ctx.SourceFile, node, "await "),
+        },
+    }}
+})
+```
+
+### Error with Multiple Labeled Ranges
+
+Highlight multiple code locations:
+
+```go
+ctx.ReportDiagnostic(rule.RuleDiagnostic{
+    Range:   exprRange,
+    Message: rule.RuleMessage{Id: "typeMismatch", Description: "Types are incompatible"},
+    LabeledRanges: []rule.RuleLabeledRange{
+        {Label: fmt.Sprintf("Type: %v", leftType), Range: leftRange},
+        {Label: fmt.Sprintf("Type: %v", rightType), Range: rightRange},
+    },
+})
+```
+
+### Fix Helpers
+
+```go
+// Insert text before a node
+rule.RuleFixInsertBefore(ctx.SourceFile, node, "await ")
+
+// Insert text after a node
+rule.RuleFixInsertAfter(node, ")")
+
+// Replace a node with text
+rule.RuleFixReplace(ctx.SourceFile, node, "newCode")
+
+// Remove a node
+rule.RuleFixRemove(ctx.SourceFile, node)
+
+// Replace a specific text range
+rule.RuleFixReplaceRange(textRange, "replacement")
+
+// Remove a specific text range
+rule.RuleFixRemoveRange(textRange)
+```
+
+### Getting Token Ranges for Fixes
+
+When you need the exact range of a keyword token (like `void`, `as`, `await`):
+
+```go
+import "github.com/microsoft/typescript-go/shim/scanner"
+
+// Get range of token at a position
+voidTokenRange := scanner.GetRangeOfTokenAtPosition(ctx.SourceFile, node.Pos())
+
+// Get a scanner to scan forward
+s := scanner.GetScannerForSourceFile(ctx.SourceFile, startPos)
+tokenRange := s.TokenRange()
+```
+
+## Rule Options
+
+Rules can accept configuration via JSON:
+
+```go
+var MyRule = rule.Rule{
+    Name: "my-rule",
+    Run: func(ctx rule.RuleContext, options any) rule.RuleListeners {
+        opts := utils.UnmarshalOptions[MyRuleOptions](options, "my-rule")
+        // opts is now typed
+    },
+}
+
+type MyRuleOptions struct {
+    IgnoreVoid    bool     `json:"ignoreVoid"`
+    AllowedTypes  []string `json:"allowedTypes"`
+}
+```
+
+For lintcn rules, define the options struct directly in your rule file.
+Built-in tsgolint rules use `schema.json` + codegen, but for custom rules
+a manual struct is simpler.
+
+## State Tracking (Scope Stacks)
+
+When you need to track state across function boundaries (like "does this
+function contain an await?"), use enter/exit listener pairs with a linked
+list as a stack:
+
+```go
+type scopeInfo struct {
+    hasAwait bool
+    upper    *scopeInfo
+}
+var currentScope *scopeInfo
+
+enterFunc := func(node *ast.Node) {
+    currentScope = &scopeInfo{upper: currentScope}
+}
+
+exitFunc := func(node *ast.Node) {
+    if !currentScope.hasAwait {
+        ctx.ReportNode(node, msg)
+    }
+    currentScope = currentScope.upper
+}
+
+return rule.RuleListeners{
+    ast.KindFunctionDeclaration:                      enterFunc,
+    rule.ListenerOnExit(ast.KindFunctionDeclaration): exitFunc,
+    ast.KindArrowFunction:                            enterFunc,
+    rule.ListenerOnExit(ast.KindArrowFunction):       exitFunc,
+    ast.KindAwaitExpression: func(node *ast.Node) {
+        currentScope.hasAwait = true
+    },
+}
+```
+
+## Testing
+
+Tests use `rule_tester.RunRuleTester` which creates a TypeScript program from
+inline code and runs the rule against it.
+
+```go
+package lintcn
+
+import (
+    "testing"
+    "github.com/typescript-eslint/tsgolint/internal/rule_tester"
+    "github.com/typescript-eslint/tsgolint/internal/rules/fixtures"
+)
+
+func TestMyRule(t *testing.T) {
+    t.Parallel()
+    rule_tester.RunRuleTester(
+        fixtures.GetRootDir(),
+        "tsconfig.minimal.json",
+        t,
+        &MyRule,
+        validCases,
+        invalidCases,
+    )
+}
+```
+
+### Valid Test Cases (should NOT trigger)
+
+```go
+var validCases = []rule_tester.ValidTestCase{
+    {Code: `const x = getUser("id");`},
+    {Code: `void dangerousCall();`},
+    // tsx support
+    {Code: `<div onClick={() => {}} />`, Tsx: true},
+    // custom filename
+    {Code: `import x from './foo'`, FileName: "index.ts"},
+    // with rule options
+    {Code: `getUser("id");`, Options: MyRuleOptions{IgnoreVoid: true}},
+    // with extra files for multi-file tests
+    {
+        Code: `import { x } from './helper';`,
+        Files: map[string]string{
+            "helper.ts": `export const x = 1;`,
+        },
+    },
+}
+```
+
+### Invalid Test Cases (SHOULD trigger)
+
+```go
+var invalidCases = []rule_tester.InvalidTestCase{
+    // Basic — just check the error fires
+    {
+        Code: `
+            declare function getUser(id: string): Error | { name: string };
+            getUser("id");
+        `,
+        Errors: []rule_tester.InvalidTestCaseError{
+            {MessageId: "noUnhandledError"},
+        },
+    },
+    // With exact position
+    {
+        Code: `getUser("id");`,
+        Errors: []rule_tester.InvalidTestCaseError{
+            {MessageId: "noUnhandledError", Line: 1, Column: 1, EndColumn: 15},
+        },
+    },
+    // With suggestions
+    {
+        Code: `
+            declare const arr: number[];
+            delete arr[0];
+        `,
+        Errors: []rule_tester.InvalidTestCaseError{
+            {
+                MessageId: "noArrayDelete",
+                Suggestions: []rule_tester.InvalidTestCaseSuggestion{
+                    {
+                        MessageId: "useSplice",
+                        Output: `
+            declare const arr: number[];
+             arr.splice(0, 1);
+        `,
+                    },
+                },
+            },
+        },
+    },
+    // With auto-fix output (code after fix applied)
+    {
+        Code: `const x = foo as any;`,
+        Output: []string{`const x = foo;`},
+        Errors: []rule_tester.InvalidTestCaseError{
+            {MessageId: "unsafeAssertion"},
+        },
+    },
+}
+```
+
+### Important Test Details
+
+- **MessageId** must match the `Id` field in your `rule.RuleMessage`
+- **Line/Column** are 1-indexed, optional (omit for flexibility)
+- **Output** is the code after ALL auto-fixes are applied (iterates up to 10 times)
+- **Suggestions** check the output of each individual suggestion fix
+- Tests run in parallel by default (`t.Parallel()`)
+- Use `Only: true` on a test case to run only that test (like `.only` in vitest)
+- Use `Skip: true` to skip a test case
+
+### Running Tests
+
+```bash
+cd .lintcn
+go test -v ./...              # all tests
+go test -v -run TestMyRule    # specific test
+go test -count=1 ./...        # bypass test cache
+```
+
+## Complete Rule Example: no-unhandled-error
+
+A real rule that enforces the errore pattern — errors when a call expression
+returns a type containing `Error` and the result is discarded:
+
+```go
+// lintcn:name no-unhandled-error
+// lintcn:description Disallow discarding expressions that are subtypes of Error
+
+package lintcn
+
+import (
+    "github.com/microsoft/typescript-go/shim/ast"
+    "github.com/microsoft/typescript-go/shim/checker"
+    "github.com/typescript-eslint/tsgolint/internal/rule"
+    "github.com/typescript-eslint/tsgolint/internal/utils"
+)
+
+var NoUnhandledErrorRule = rule.Rule{
+    Name: "no-unhandled-error",
+    Run: func(ctx rule.RuleContext, options any) rule.RuleListeners {
+        return rule.RuleListeners{
+            ast.KindExpressionStatement: func(node *ast.Node) {
+                exprStatement := node.AsExpressionStatement()
+                expression := ast.SkipParentheses(exprStatement.Expression)
+
+                // void expressions are intentional discards
+                if ast.IsVoidExpression(expression) {
+                    return
+                }
+
+                // only check call expressions and await expressions wrapping calls
+                innerExpr := expression
+                if ast.IsAwaitExpression(innerExpr) {
+                    innerExpr = ast.SkipParentheses(innerExpr.Expression())
+                }
+                if !ast.IsCallExpression(innerExpr) {
+                    return
+                }
+
+                t := ctx.TypeChecker.GetTypeAtLocation(expression)
+
+                // skip void, undefined, never
+                if utils.IsTypeFlagSet(t,
+                    checker.TypeFlagsVoid|checker.TypeFlagsVoidLike|
+                    checker.TypeFlagsUndefined|checker.TypeFlagsNever) {
+                    return
+                }
+
+                // check if any union part is Error-like
+                for _, part := range utils.UnionTypeParts(t) {
+                    if utils.IsErrorLike(ctx.Program, ctx.TypeChecker, part) {
+                        ctx.ReportNode(node, rule.RuleMessage{
+                            Id:          "noUnhandledError",
+                            Description: "Error-typed return value is not handled.",
+                        })
+                        return
+                    }
+                }
+            },
+        }
+    },
+}
+```
+
+## Go Workspace Setup
+
+`.lintcn/` needs these generated files (created by `lintcn add` or manually):
+
+**go.mod** — module name MUST be a child path of tsgolint for `internal/`
+package access:
+
+```
+module github.com/typescript-eslint/tsgolint/lintcn-rules
+
+go 1.26
+```
+
+**go.work** — workspace linking to cached tsgolint source:
+
+```
+go 1.26
+
+use (
+    .
+    ./.tsgolint
+    ./.tsgolint/typescript-go
+)
+
+replace (
+    github.com/microsoft/typescript-go/shim/ast => ./.tsgolint/shim/ast
+    github.com/microsoft/typescript-go/shim/checker => ./.tsgolint/shim/checker
+    // ... all 14 shim modules
+)
+```
+
+**.tsgolint/** — symlink to cached tsgolint clone (gitignored).
+
+With this setup, gopls provides full autocomplete and go-to-definition on all
+tsgolint and typescript-go APIs.