carrick 0.3.117 → 0.3.118

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carrick",
-  "version": "0.3.117",
+  "version": "0.3.118",
   "carrickCache": {
     "cache_version": 22,
     "intent_cache_version": 2
@@ -113,11 +113,11 @@
     "zod": "^3.23.0"
   },
   "optionalDependencies": {
-    "@carrick-tools/cli-darwin-arm64": "0.3.117",
-    "@carrick-tools/cli-darwin-x64": "0.3.117",
-    "@carrick-tools/cli-linux-arm64": "0.3.117",
-    "@carrick-tools/cli-linux-x64": "0.3.117",
-    "@carrick-tools/cli-win32-x64": "0.3.117"
+    "@carrick-tools/cli-darwin-arm64": "0.3.118",
+    "@carrick-tools/cli-darwin-x64": "0.3.118",
+    "@carrick-tools/cli-linux-arm64": "0.3.118",
+    "@carrick-tools/cli-linux-x64": "0.3.118",
+    "@carrick-tools/cli-win32-x64": "0.3.118"
   },
   "devDependencies": {
     "@types/node": "^24.13.3"

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "carrick",
   "description": "Claude Code plugin for Carrick, which indexes TypeScript codebases across service and repository boundaries. After each edit it adds the file's routes, calls, and cross-service type mismatches to the session, and it registers Carrick's language server. It pairs with the Carrick MCP server, which lets agents search functions by intent rather than name.",
-  "version": "0.3.117",
+  "version": "0.3.118",
   "author": {
     "name": "Carrick",
     "email": "hello@carrick.tools"

package/sidecar/dist/src/library-claims.js

@@ -2896,16 +2896,21 @@ class DeclarationReader {
     }
     /**
      * What a factory builds says nothing: the type itself, or any branch of a
-     * conditional return type, does.
+     * conditional return type, does. A conditional whose branches lead back to
+     * itself (a recursive alias) is read once: `seen` holds the conditionals
+     * on the way down, and one met again says nothing new.
      */
-    returnSaysNothing(type) {
+    returnSaysNothing(type, seen = new Set()) {
         if (this.saysNothing(type))
             return true;
         return this.parts(type).some(part => {
             if (!(part.flags & ts.TypeFlags.Conditional))
                 return false;
             const node = part.root.node;
-            return [node.trueType, node.falseType].some(branch => this.returnSaysNothing(this.checker.getTypeFromTypeNode(branch)));
+            if (seen.has(node))
+                return false;
+            seen.add(node);
+            return [node.trueType, node.falseType].some(branch => this.returnSaysNothing(this.checker.getTypeFromTypeNode(branch), seen));
         });
     }
     /** `any` (an unresolved type included) or `unknown`. */

package/sidecar/dist/src/position-rows.d.ts

@@ -2,7 +2,7 @@
  * Per-position compiler rows for a service (carrick#2405, move 2 of the fact
  * layer). Record-only: nothing in a scan reads the file yet.
  *
- * For every source file the scanner sends, one row for each position of four
+ * For every source file the scanner sends, one row for each position of six
  * kinds, each holding what the compiler knows there: the symbol, the
  * declaration it is attributed to (file and line), the package that declares
  * it and the type text.
@@ -13,11 +13,22 @@
  * | `member`  | property or element access                        | the name or the argument  | the access     |
  * | `compare` | `=== !== == != < > <= >= instanceof in`           | the left operand          | the left operand |
  * | `ident`   | an identifier in expression position              | itself                    | itself         |
+ * | `impl`    | a `call` or `member` whose declaration has no body | an implementation of it  | nothing        |
+ * | `jsx`     | a JSX opening or self-closing element's tag        | the tag's name           | the tag        |
  *
- * A row's key is `(start, end, kind)`: TypeScript `getStart()`/`getEnd()` of
- * the node, in UTF-16 code units from the start of the file, which is what
- * the scanner's `sidecar_position` gives for an SWC span. Every path written
- * is relative to the scanned repo's root, with `/` separators.
+ * An `impl` row (version 2, carrick#2430) follows the `call` or `member` row
+ * it belongs to and has its span: one per declaration that go-to-implementation
+ * names for that row's declaration, when that declaration is an interface's
+ * or type literal's method, a function-typed property signature, an abstract
+ * member, or a function-typed class property or parameter with no
+ * initializer. Its `decl_*` name the implementing declaration. Past
+ * {@link IMPL_CAP} the row is one, with {@link FLAG_TOO_MANY} and nothing else.
+ *
+ * A row's key is `(start, end, kind)`, except that several `impl` rows share
+ * one: TypeScript `getStart()`/`getEnd()` of the node, in UTF-16 code units
+ * from the start of the file, which is what the scanner's `sidecar_position`
+ * gives for an SWC span. Every path written is relative to the scanned repo's
+ * root, with `/` separators.
  *
  * Each file is read in the program of the project that owns it
  * (`ProjectLoader.projectKeyFor`, carrick#1604), one owner's program at a
@@ -33,7 +44,7 @@ import { ts } from 'ts-morph';
 import type { ProjectLoader } from './project-loader.js';
 import type { PositionRowsCounts } from './types.js';
 /** The format's version, written in the header. */
-export declare const POSITION_ROWS_VERSION = 1;
+export declare const POSITION_ROWS_VERSION = 2;
 /** The type is `any`, declared or inferred. Never set with the error type. */
 export declare const FLAG_ANY = 1;
 /** The type is the compiler's error type: something did not resolve. */
@@ -42,7 +53,13 @@ export declare const FLAG_ERROR_TYPE = 2;
 export declare const FLAG_CHECKER_THREW = 4;
 /** The declaration is outside the checkout, not the default library and in no installed package. */
 export declare const FLAG_DECLARATION_UNNAMED = 8;
-export type PositionKind = 'call' | 'member' | 'compare' | 'ident';
+/** An `impl` row standing for more implementations than {@link IMPL_CAP}; it names none. */
+export declare const FLAG_TOO_MANY = 16;
+/** The most implementations one declaration's `impl` rows list. */
+export declare const IMPL_CAP = 16;
+/** The kinds {@link kindOf} gives a node; `impl` and `jsx` rows are written beside them. */
+export type NodeKind = 'call' | 'member' | 'compare' | 'ident';
+export type PositionKind = NodeKind | 'impl' | 'jsx';
 /** `[kind, start, end, symbol, decl_file, decl_line, decl_package, type_text, flags]` */
 export type PositionRow = [
     PositionKind,
@@ -75,4 +92,4 @@ export interface PositionRowsOptions {
  */
 export declare function writePositionRows(options: PositionRowsOptions): PositionRowsCounts;
 /** The kind of row a node gives, if any (exported for the editor-parity test, carrick#2418). */
-export declare function kindOf(node: ts.Node): PositionKind | undefined;
+export declare function kindOf(node: ts.Node): NodeKind | undefined;

package/sidecar/dist/src/position-rows.js

@@ -2,7 +2,7 @@
  * Per-position compiler rows for a service (carrick#2405, move 2 of the fact
  * layer). Record-only: nothing in a scan reads the file yet.
  *
- * For every source file the scanner sends, one row for each position of four
+ * For every source file the scanner sends, one row for each position of six
  * kinds, each holding what the compiler knows there: the symbol, the
  * declaration it is attributed to (file and line), the package that declares
  * it and the type text.
@@ -13,11 +13,22 @@
  * | `member`  | property or element access                        | the name or the argument  | the access     |
  * | `compare` | `=== !== == != < > <= >= instanceof in`           | the left operand          | the left operand |
  * | `ident`   | an identifier in expression position              | itself                    | itself         |
+ * | `impl`    | a `call` or `member` whose declaration has no body | an implementation of it  | nothing        |
+ * | `jsx`     | a JSX opening or self-closing element's tag        | the tag's name           | the tag        |
  *
- * A row's key is `(start, end, kind)`: TypeScript `getStart()`/`getEnd()` of
- * the node, in UTF-16 code units from the start of the file, which is what
- * the scanner's `sidecar_position` gives for an SWC span. Every path written
- * is relative to the scanned repo's root, with `/` separators.
+ * An `impl` row (version 2, carrick#2430) follows the `call` or `member` row
+ * it belongs to and has its span: one per declaration that go-to-implementation
+ * names for that row's declaration, when that declaration is an interface's
+ * or type literal's method, a function-typed property signature, an abstract
+ * member, or a function-typed class property or parameter with no
+ * initializer. Its `decl_*` name the implementing declaration. Past
+ * {@link IMPL_CAP} the row is one, with {@link FLAG_TOO_MANY} and nothing else.
+ *
+ * A row's key is `(start, end, kind)`, except that several `impl` rows share
+ * one: TypeScript `getStart()`/`getEnd()` of the node, in UTF-16 code units
+ * from the start of the file, which is what the scanner's `sidecar_position`
+ * gives for an SWC span. Every path written is relative to the scanned repo's
+ * root, with `/` separators.
  *
  * Each file is read in the program of the project that owns it
  * (`ProjectLoader.projectKeyFor`, carrick#1604), one owner's program at a
@@ -38,7 +49,7 @@ import { WriteGuard, installedPackageDirectory, isDeclarationFileName, moduleExp
 import { attributedDeclaration, installedPackageOf } from './declaration-attribution.js';
 import { typeToStringAsDeclared } from './print-type.js';
 /** The format's version, written in the header. */
-export const POSITION_ROWS_VERSION = 1;
+export const POSITION_ROWS_VERSION = 2;
 /** The type is `any`, declared or inferred. Never set with the error type. */
 export const FLAG_ANY = 1;
 /** The type is the compiler's error type: something did not resolve. */
@@ -47,6 +58,10 @@ export const FLAG_ERROR_TYPE = 2;
 export const FLAG_CHECKER_THREW = 4;
 /** The declaration is outside the checkout, not the default library and in no installed package. */
 export const FLAG_DECLARATION_UNNAMED = 8;
+/** An `impl` row standing for more implementations than {@link IMPL_CAP}; it names none. */
+export const FLAG_TOO_MANY = 16;
+/** The most implementations one declaration's `impl` rows list. */
+export const IMPL_CAP = 16;
 const COMPARE_OPERATORS = new Set([
     ts.SyntaxKind.EqualsEqualsEqualsToken,
     ts.SyntaxKind.ExclamationEqualsEqualsToken,
@@ -79,6 +94,8 @@ export function writePositionRows(options) {
         resolved: 0,
         any: 0,
         error_type: 0,
+        impl: 0,
+        jsx: 0,
         bytes: 0,
         load_ms: 0,
         walk_ms: 0,
@@ -127,11 +144,16 @@ export function writePositionRows(options) {
             }
             read.set(index, sourceFile?.getFilePath());
         }
-        // Built once, after every file the group adds.
-        const program = project.getProgram().compilerObject;
+        // Built once, after every file the group adds. The language service's
+        // program is the one walked, so go-to-implementation answers over it
+        // and no second program is built.
+        const service = project.getLanguageService().compilerObject;
+        const program = service.getProgram();
+        if (!program)
+            throw new Error('the language service built no program');
         counts.load_ms += performance.now() - loadStarted;
         const walkStarted = performance.now();
-        const walker = new PositionWalker(program, paths, loader);
+        const walker = new PositionWalker(program, service, paths, loader);
         const missed = [];
         for (const index of indexes) {
             if (!read.has(index))
@@ -151,22 +173,23 @@ export function writePositionRows(options) {
                     counts.any += 1;
                 if (row[8] & FLAG_ERROR_TYPE)
                     counts.error_type += 1;
+                if (row[0] === 'impl')
+                    counts.impl += 1;
+                if (row[0] === 'jsx')
+                    counts.jsx += 1;
             }
             lines[index] = fileLine({ f: paths.relative(files[index]), h: hashes.get(index), r: rows });
             options.onFile?.();
         }
         counts.walk_ms += performance.now() - walkStarted;
-        return missed;
+        return { missed, program };
     };
     const hashes = new Map();
     for (const [key, indexes] of groups) {
         const project = loader.getProjectFor(key);
-        const missed = walkGroup(project, indexes, hashes);
+        const { missed, program } = walkGroup(project, indexes, hashes);
         if (missed.length > 0) {
-            const declarations = project
-                .getProgram()
-                .compilerObject.getRootFileNames()
-                .filter(isDeclarationFileName);
+            const declarations = program.getRootFileNames().filter(isDeclarationFileName);
             untaken.set(key, { indexes: missed, declarations });
         }
         // One owner's program at a time.
@@ -184,7 +207,7 @@ export function writePositionRows(options) {
             }
         }
         counts.load_ms += performance.now() - loadStarted;
-        for (const index of walkGroup(project, indexes, hashes)) {
+        for (const index of walkGroup(project, indexes, hashes).missed) {
             lines[index] = fileLine({ f: paths.relative(files[index]), h: hashes.get(index), skip: 'not_in_program', r: [] });
             options.onFile?.();
         }
@@ -344,11 +367,21 @@ function toSlashes(p) {
 /** The rows of one program's files. */
 class PositionWalker {
     program;
+    service;
     paths;
     loader;
     checker;
-    constructor(program, paths, loader) {
+    /**
+     * Each bodyless declaration's implementations, as `impl` rows with no span
+     * yet (`start` and `end` are 0): go-to-implementation searches the whole
+     * program, so it is asked once per declaration, never per call.
+     */
+    implementations = new Map();
+    /** The same for a member whose symbol has no declaration, keyed by symbol. */
+    undeclaredImplementations = new Map();
+    constructor(program, service, paths, loader) {
         this.program = program;
+        this.service = service;
         this.paths = paths;
         this.loader = loader;
         this.checker = program.getTypeChecker();
@@ -357,8 +390,17 @@ class PositionWalker {
         const rows = [];
         const visit = (node) => {
             const kind = kindOf(node);
-            if (kind)
-                rows.push(this.row(kind, node, sourceFile));
+            if (kind) {
+                const row = this.row(kind, node, sourceFile);
+                rows.push(row);
+                if ((kind === 'call' || kind === 'member') && !(row[8] & FLAG_CHECKER_THREW)) {
+                    for (const impl of this.implRows(kind, node))
+                        rows.push(['impl', row[1], row[2], ...tail(impl)]);
+                }
+            }
+            if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+                rows.push(this.row('jsx', node.tagName, sourceFile));
+            }
             ts.forEachChild(node, visit);
         };
         ts.forEachChild(sourceFile, visit);
@@ -370,7 +412,7 @@ class PositionWalker {
         try {
             const symbol = this.symbolOf(kind, node);
             const typed = kind === 'compare' ? node.left : node;
-            const type = this.checker.getTypeAtLocation(typed);
+            const type = (kind === 'jsx' && this.intrinsicProps(node)) || this.checker.getTypeAtLocation(typed);
             let flags = 0;
             if (type.flags & ts.TypeFlags.Any) {
                 flags |= type.intrinsicName === 'error' ? FLAG_ERROR_TYPE : FLAG_ANY;
@@ -389,13 +431,9 @@ class PositionWalker {
             const symbolName = ts.symbolName(symbol);
             const isModule = declaration.kind === ts.SyntaxKind.SourceFile && symbolName.startsWith('"');
             const declaringFile = declaration.getSourceFile();
-            const declFile = this.program.isSourceFileDefaultLibrary(declaringFile)
-                ? `lib:${path.basename(declaringFile.fileName)}`
-                : this.paths.declaringFile(declaringFile.fileName);
+            const { declFile, declLine, declPackage } = this.located(declaringFile, declaration.getStart(declaringFile));
             if (declFile === null)
                 flags |= FLAG_DECLARATION_UNNAMED;
-            const declLine = declaringFile.getLineAndCharacterOfPosition(declaration.getStart(declaringFile)).line + 1;
-            const declPackage = this.paths.declaringPackage(declaringFile.fileName, (file) => this.loader.packageOf(file));
             const name = isModule ? declFile : symbolName;
             return [kind, start, end, name, declFile, declLine, declPackage, typeText, flags];
         }
@@ -403,6 +441,121 @@ class PositionWalker {
             return [kind, start, end, null, null, null, null, null, FLAG_CHECKER_THREW];
         }
     }
+    /**
+     * An intrinsic element's type: the attributes `JSX.IntrinsicElements`
+     * gives its tag. The compiler types an intrinsic tag name itself as the
+     * error type, though the name resolves. A tag is intrinsic when it is an
+     * identifier that starts with a lowercase letter or holds a `-`, as the
+     * language reads it.
+     */
+    intrinsicProps(tag) {
+        if (!ts.isIdentifier(tag) || !/^[a-z]|-/.test(tag.text))
+            return undefined;
+        const element = tag.parent;
+        if (!ts.isJsxOpeningElement(element) && !ts.isJsxSelfClosingElement(element))
+            return undefined;
+        return this.checker.getContextualType(element.attributes);
+    }
+    /** How rows name a position in a program file: its file, 1-based line and package. */
+    located(declaringFile, position) {
+        const declFile = this.program.isSourceFileDefaultLibrary(declaringFile)
+            ? `lib:${path.basename(declaringFile.fileName)}`
+            : this.paths.declaringFile(declaringFile.fileName);
+        const declLine = declaringFile.getLineAndCharacterOfPosition(position).line + 1;
+        const declPackage = this.paths.declaringPackage(declaringFile.fileName, (file) => this.loader.packageOf(file));
+        return { declFile, declLine, declPackage };
+    }
+    /**
+     * The `impl` rows of a `call` or `member` row (spans unset): none unless the
+     * row's declaration has no body of its own ({@link isBodyless}). Its own
+     * search, apart from the row's: a throw here writes one `impl` row flagged
+     * {@link FLAG_CHECKER_THREW} and leaves the row as it was.
+     */
+    implRows(kind, node) {
+        let declaration;
+        try {
+            const symbol = this.symbolOf(kind, node);
+            if (symbol && (symbol.declarations ?? []).length === 0)
+                return this.undeclaredImplRows(kind, node, symbol);
+            declaration = symbol ? attributedDeclaration(() => this.program, symbol.declarations ?? []) : undefined;
+            if (!declaration || !isBodyless(declaration, this.checker))
+                return [];
+        }
+        catch {
+            return [];
+        }
+        let rows = this.implementations.get(declaration);
+        if (!rows) {
+            try {
+                rows = this.implementationsOf(declaration);
+            }
+            catch {
+                rows = [['impl', 0, 0, null, null, null, null, null, FLAG_CHECKER_THREW]];
+            }
+            this.implementations.set(declaration, rows);
+        }
+        return rows;
+    }
+    /**
+     * The `impl` rows of a member whose symbol has no declaration (a mapped
+     * type's member): there is no declaration name to ask at, so the answer is
+     * asked at the use site's name, once per symbol. Same shape as
+     * {@link implementationsOf}; nothing of the symbol's own is filtered out.
+     */
+    undeclaredImplRows(kind, node, symbol) {
+        const cached = this.undeclaredImplementations.get(symbol);
+        if (cached)
+            return cached;
+        let rows;
+        try {
+            const named = nameNodeOf(kind, node);
+            rows = named ? this.implementationRows(named, []) : [];
+        }
+        catch {
+            rows = [['impl', 0, 0, null, null, null, null, null, FLAG_CHECKER_THREW]];
+        }
+        this.undeclaredImplementations.set(symbol, rows);
+        return rows;
+    }
+    /**
+     * What go-to-implementation names for `declaration`, asked at its name:
+     * every declaration the language service answers, except the symbol's own
+     * (an overloaded method answers with its other signatures), in file and
+     * position order.
+     */
+    implementationsOf(declaration) {
+        const name = ts.getNameOfDeclaration(declaration) ?? declaration;
+        const own = (this.checker.getSymbolAtLocation(name) ?? declaration.symbol)
+            ?.declarations ?? [declaration];
+        return this.implementationRows(name, own);
+    }
+    /** Go-to-implementation at `name`, minus results inside `own`, as sorted `impl` rows. */
+    implementationRows(name, own) {
+        const declaringFile = name.getSourceFile();
+        const found = new Map();
+        for (const location of this.service.getImplementationAtPosition(declaringFile.fileName, name.getStart(declaringFile)) ?? []) {
+            const file = this.program.getSourceFile(location.fileName);
+            if (!file)
+                continue;
+            const start = location.textSpan.start;
+            if (own.some((d) => d.getSourceFile() === file && d.pos <= start && start < d.end))
+                continue;
+            found.set(`${location.fileName}\u0000${start}`, { file, start });
+        }
+        if (found.size === 0)
+            return [];
+        if (found.size > IMPL_CAP)
+            return [['impl', 0, 0, null, null, null, null, null, FLAG_TOO_MANY]];
+        const rows = [...found.values()].map(({ file, start }) => {
+            const { declFile, declLine, declPackage } = this.located(file, start);
+            const named = nodeStartingAt(file, start);
+            const symbol = named ? this.checker.getSymbolAtLocation(named) : undefined;
+            const flags = declFile === null ? FLAG_DECLARATION_UNNAMED : 0;
+            return { start, row: ['impl', 0, 0, symbol ? ts.symbolName(symbol) : null, declFile, declLine, declPackage, null, flags] };
+        });
+        rows.sort((a, b) => compareNames(a.row[4], b.row[4]) || a.start - b.start);
+        return rows.map(({ row }) => row);
+    }
     /**
      * The declaration a member with none is attributed to (carrick#2448): the
      * mapped type node, or the alias naming it, of the receiver's type. A
@@ -550,6 +703,54 @@ class PositionWalker {
         return this.host;
     }
 }
+/** A row's fields after its kind and span. */
+function tail(row) {
+    return [row[3], row[4], row[5], row[6], row[7], row[8]];
+}
+/** Order two `decl_file` names, `null` last. */
+function compareNames(a, b) {
+    if (a === b)
+        return 0;
+    if (a === null)
+        return 1;
+    if (b === null)
+        return -1;
+    return a < b ? -1 : 1;
+}
+/**
+ * Whether a declaration has no body for a call to run: an interface's or type
+ * literal's method, a function-typed property signature, an abstract method or
+ * property, or a function-typed class property or parameter with no
+ * initializer. Its implementations are what go-to-implementation names.
+ */
+function isBodyless(declaration, checker) {
+    const functionTyped = () => checker.getTypeAtLocation(declaration).getNonNullableType().getCallSignatures().length > 0;
+    if (ts.isMethodSignature(declaration))
+        return true;
+    if (ts.isPropertySignature(declaration))
+        return functionTyped();
+    if (ts.isMethodDeclaration(declaration) || ts.isPropertyDeclaration(declaration)) {
+        if (ts.getCombinedModifierFlags(declaration) & ts.ModifierFlags.Abstract)
+            return true;
+        return ts.isPropertyDeclaration(declaration) && !declaration.initializer && functionTyped();
+    }
+    if (ts.isParameter(declaration))
+        return !declaration.initializer && functionTyped();
+    return false;
+}
+/** The innermost node of `file` that starts at `position` (an implementation's name). */
+function nodeStartingAt(file, position) {
+    let found;
+    const visit = (node) => {
+        if (position < node.getStart(file) || position >= node.getEnd())
+            return;
+        if (node.getStart(file) === position)
+            found = node;
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(file, visit);
+    return found;
+}
 /** The kind of row a node gives, if any (exported for the editor-parity test, carrick#2418). */
 export function kindOf(node) {
     if (ts.isCallExpression(node) || ts.isNewExpression(node) || ts.isTaggedTemplateExpression(node)) {
@@ -576,6 +777,12 @@ function nameNodeOf(kind, node) {
             return referenceName(node.left);
         case 'ident':
             return node;
+        case 'impl':
+            return undefined;
+        case 'jsx':
+            // The tag: `<Badge>`, `<ui.Button>`, `<this.Panel>`; a namespaced
+            // name (`<svg:path>`) names nothing.
+            return ts.isJsxNamespacedName(node) ? undefined : (referenceName(node) ?? node);
     }
 }
 /**

package/sidecar/dist/src/types.d.ts

@@ -765,6 +765,10 @@ export interface PositionRowsCounts {
     any: number;
     /** Rows whose type is the compiler's error type (flag 2). */
     error_type: number;
+    /** `impl` rows: implementations of a bodyless declaration, or one past the cap (carrick#2430). */
+    impl: number;
+    /** `jsx` rows: one per JSX opening or self-closing element. */
+    jsx: number;
     /** The rows file's size on disk, compressed. */
     bytes: number;
     /** Time spent building programs and reading files into them. */