carrick 0.3.122 → 0.3.124

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

@@ -13,29 +13,26 @@
  * | `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        |
  * | `decl`    | a `call` or `member` on a union of declaring types | one of those declarations | nothing       |
  * | `jsx`     | a JSX opening or self-closing element's tag        | the tag's name           | the tag        |
  *
- * 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 `decl` row (version 3, carrick#2448) follows the `call` or `member` row
- * it belongs to, before its `impl` rows, and has its span: one per
+ * it belongs to and has its span: one per
  * declaration of the member when the receiver is a union whose constituents
  * declare it at more than one place (`(pick ? a : b).get()` with two
  * classes). That row names only the first of them. Each constituent's
  * declaration is its own member's, or, for a member with none (a mapped
- * type's), the declaration of the constituent type itself. Sorted and capped
- * as `impl` rows are; `type_text` is `null`.
+ * type's), the declaration of the constituent type itself. Sorted by file and
+ * position; past {@link DECL_CAP} the row is one, with {@link FLAG_TOO_MANY}
+ * and nothing else. `type_text` is `null`.
+ *
+ * Version 4 (carrick#2561) dropped the `impl` rows of versions 2 and 3: the
+ * go-to-implementation search behind them was most of the walk's time, and
+ * nothing read them. Implementations are asked for where discovery stops
+ * (carrick#2432).
  *
- * A row's key is `(start, end, kind)`, except that several `impl` rows, and
- * several `decl` rows, share one: TypeScript `getStart()`/`getEnd()` of the
+ * A row's key is `(start, end, kind)`, except that several `decl` 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.
@@ -59,7 +56,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 = 3;
+export const POSITION_ROWS_VERSION = 4;
 /** 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. */
@@ -68,7 +65,7 @@ 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` or `decl` row standing for more than {@link IMPL_CAP} rows of its kind; it names none. */
+/** A `decl` row standing for more than {@link DECL_CAP} rows; it names none. */
 export const FLAG_TOO_MANY = 16;
 /**
  * The declaration is published under the row's symbol name: its module
@@ -79,8 +76,8 @@ export const FLAG_TOO_MANY = 16;
 export const FLAG_PUBLISHED = 32;
 /** The declaration is what its module exports as `export =` or `default` (carrick#2508). */
 export const FLAG_MODULE_DEFAULT = 64;
-/** The most `impl` rows one declaration lists, and the most `decl` rows one position lists. */
-export const IMPL_CAP = 16;
+/** The most `decl` rows one position lists. */
+export const DECL_CAP = 16;
 const COMPARE_OPERATORS = new Set([
     ts.SyntaxKind.EqualsEqualsEqualsToken,
     ts.SyntaxKind.ExclamationEqualsEqualsToken,
@@ -113,7 +110,6 @@ export function writePositionRows(options) {
         resolved: 0,
         any: 0,
         error_type: 0,
-        impl: 0,
         jsx: 0,
         bytes: 0,
         load_ms: 0,
@@ -164,15 +160,15 @@ export function writePositionRows(options) {
             read.set(index, sourceFile?.getFilePath());
         }
         // 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.
+        // program is the one walked, as it was when go-to-implementation answered
+        // over it (carrick#2430, dropped in #2561): its rows are pinned.
         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, service, paths, loader);
+        const walker = new PositionWalker(program, paths, loader);
         const missed = [];
         for (const index of indexes) {
             if (!read.has(index))
@@ -192,8 +188,6 @@ 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;
             }
@@ -248,6 +242,10 @@ export function writePositionRows(options) {
     counts.load_ms = Math.round(counts.load_ms);
     return counts;
 }
+/** What a declaration's file is written as in a row's `decl_file`: `lib:<name>` for the default library, else `PathNames`'. */
+export function declaringFileName(program, paths, file) {
+    return program.isSourceFileDefaultLibrary(file) ? `lib:${path.basename(file.fileName)}` : paths.declaringFile(file.fileName);
+}
 /** A file's line, with its keys in the pinned order. */
 function fileLine(line) {
     return JSON.stringify(line);
@@ -259,7 +257,7 @@ function fileLine(line) {
  * default library, `pkg:<name>/<path>` for an installed package outside the
  * root, and nothing otherwise.
  */
-class PathNames {
+export class PathNames {
     roots;
     packageNames = new Map();
     /**
@@ -386,23 +384,13 @@ function toSlashes(p) {
 /** The rows of one program's files. */
 class PositionWalker {
     program;
-    service;
     paths;
     loader;
     checker;
-    /**
-     * 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();
     /** Each module's exports by name, and its `export =` and `default` targets, aliases followed. */
     moduleExports = new Map();
-    constructor(program, service, paths, loader) {
+    constructor(program, paths, loader) {
         this.program = program;
-        this.service = service;
         this.paths = paths;
         this.loader = loader;
         this.checker = program.getTypeChecker();
@@ -417,8 +405,6 @@ class PositionWalker {
                 if ((kind === 'call' || kind === 'member') && !(row[8] & FLAG_CHECKER_THREW)) {
                     for (const decl of this.declRows(kind, node))
                         rows.push(['decl', row[1], row[2], ...tail(decl)]);
-                    for (const impl of this.implRows(kind, node))
-                        rows.push(['impl', row[1], row[2], ...tail(impl)]);
                 }
             }
             if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
@@ -484,104 +470,11 @@ class PositionWalker {
     }
     /** 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 declFile = declaringFileName(this.program, this.paths, declaringFile);
         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
@@ -709,7 +602,7 @@ class PositionWalker {
         }
         if (found.size < 2)
             return [];
-        if (found.size > IMPL_CAP)
+        if (found.size > DECL_CAP)
             return [['decl', 0, 0, null, null, null, null, null, FLAG_TOO_MANY]];
         const rows = [...found].map((declaration) => {
             const file = declaration.getSourceFile();
@@ -858,40 +751,6 @@ function compareNames(a, b) {
         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)) {
@@ -918,7 +777,6 @@ function nameNodeOf(kind, node) {
             return referenceName(node.left);
         case 'ident':
             return node;
-        case 'impl':
         case 'decl':
             return undefined;
         case 'jsx':

package/sidecar/dist/src/type-inferrer.js

@@ -115,6 +115,12 @@ export const MACHINERY_MEMBER_INDICATORS = new Set([
     'clone',
     'json',
     'statusText',
+    // FROZEN (old path, 2026-10-21): the reply-object half below only (the
+    // fetch half above and the threshold stay). Deletions and safety fixes
+    // only. Fixes for wrong or missing types go in labelled reply objects
+    // (carrick#2472 C4) and the language library rows (carrick#2445). Delete
+    // when a delete-and-replay on the four repos moves no row wrongly, after
+    // carrick-cloud#2379 and carrick#2445 (carrick#2472, C6).
     // Node http ServerResponse / reply-object surface
     'statusCode',
     'statusMessage',
@@ -1628,6 +1634,8 @@ export class TypeInferrer {
             branches = [
                 ...returnedBranches,
                 ...statementSends
+                    // FROZEN (old path, 2026-10-21): the `statementEndsFunctionPath` test
+                    // here; see that method.
                     .filter((s) => s.send === locatedBranch || this.statementEndsFunctionPath(s.statement, func))
                     .map((s) => s.send),
             ];
@@ -1702,6 +1710,10 @@ export class TypeInferrer {
         }
         return sends;
     }
+    // FROZEN (old path, 2026-10-21): this method and its one use. Deletions and
+    // safety fixes only. Fixes for wrong or missing types go in send versus
+    // setter, read from the framework label (carrick#2472 C4). Delete when C4 is
+    // released (carrick#2472, C6).
     /**
      * True when nothing in `func` runs after `statement`: a bare `return;`
      * follows it, or it is the last statement of its block and the statement
@@ -1748,6 +1760,11 @@ export class TypeInferrer {
             return false;
         }
     }
+    // FROZEN (old path, 2026-10-21): this method's structural test (the whole
+    // method is the upper bound). Deletions and safety fixes only. Fixes for
+    // wrong or missing types go in labelled sends (carrick#2472 C4). Delete when
+    // a delete-and-replay on the four repos moves no row wrongly, after
+    // carrick-cloud#2379 and carrick#2445 (carrick#2472, C6).
     /**
      * True when `candidate` is a response send: a call or `new` whose result is
      * transport machinery (by the extraction config's verified rule or the
@@ -5288,6 +5305,10 @@ export class TypeInferrer {
         }
         return flattened;
     }
+    // FROZEN (old path, 2026-10-21): this method only. Deletions and safety fixes
+    // only. Fixes for wrong or missing types go in labelled sends (carrick#2472
+    // C4). Delete when a delete-and-replay on the four repos moves no row
+    // wrongly, after carrick-cloud#2379 and carrick#2445 (carrick#2472, C6).
     /**
      * The callees these returned expressions PROVE are response serialisers.
      *

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

@@ -411,6 +411,18 @@ export interface Yields {
     export: string;
     side: string;
 }
+/**
+ * Where a route handler's request holds its path and method (#2474 R0): the
+ * handler's parameter `param` is the request, and each of the others is a
+ * member path read off it, relative to that parameter (`['path']`,
+ * `['raw', 'url']`). At least one of `path` or `url`.
+ */
+export interface RequestAt {
+    param: number;
+    path?: string[];
+    url?: string[];
+    method?: string[];
+}
 /** The closed role list; the role alone picks the checks a claim needs. */
 export type LibraryRole = 'http_client' | 'graphql_client' | 'broker' | 'in_process_bus' | 'socket' | 'server_framework' | 'none';
 /** What an `op` claim does on the wire. */
@@ -467,6 +479,15 @@ export type LibraryClaim = {
     key_labels?: Record<string, KeyLabel>;
     name_scope?: NameScope;
     picker?: string;
+    /**
+     * Route fields (#2474 R0): the member runs the function here and hands
+     * it, as `yields` says, an instance bound under `name`. Comes with
+     * `yields`.
+     */
+    runs?: ClaimSlot;
+    yields?: Yields;
+    /** Route fields (#2474 R0): the instance handed here is served under `name`. */
+    mounts?: ClaimSlot;
 } | {
     kind: 'op';
     op: LibraryOp;
@@ -502,6 +523,8 @@ export type LibraryClaim = {
     runs?: RunsSlot;
     /** Label v2, `receive` only: what the handler is handed. */
     yields?: Yields;
+    /** Route fields (#2474 R0), `receive` only: where the handler's request holds its path and method. */
+    request?: RequestAt;
 } | {
     /** A name the library emits itself, spelled in one of `member`'s parameters. */
     kind: 'reserved';
@@ -538,6 +561,8 @@ export interface LibraryCheck {
 export interface VerifyLibraryClaimsRequest extends BaseRequest {
     action: 'verify_library_claims';
     from_dir: string;
+    /** The scanned repo's root, as on `init`: a verdict's `declarations` are named from it, as position rows are. */
+    scan_root?: string;
     checks: LibraryCheck[];
     /** Checks not reached in time come back `unchecked` with reason `budget`; null or absent is the default. */
     budget_ms?: number | null;
@@ -765,8 +790,6 @@ 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. */
@@ -827,6 +850,11 @@ export interface RetypeCheckResponse extends BaseResponse {
     outcomes?: RetypeOutcome[];
     errors?: string[];
 }
+/** Where a verified op's member is declared on its receiver, as a position row's `decl_file` and `decl_line`. */
+export interface SemanticsDeclaration {
+    decl_file: string;
+    decl_line: number;
+}
 /**
  * The verdict on one `(claim_id, receiver)` pair.
  *
@@ -840,6 +868,8 @@ export interface SemanticsResult {
     verdict: 'verified' | 'failed' | 'unchecked';
     /** Absent exactly when verified. */
     reason?: string;
+    /** Verified op verdicts only: the declarations its member resolves to on the receiver. */
+    declarations?: SemanticsDeclaration[];
 }
 /** How one package of the request resolved, for logs. */
 export interface SemanticsModule {