carrick 0.3.125 → 0.3.126

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

@@ -190,6 +190,18 @@ const SERIALISED_BODY_UNREAD_DETAIL = {
 };
 /** `any` or `unknown` as a type in printed type text, not as a member name or a string. */
 const TOP_TYPE_TOKEN = /(?<![\w$'"`])(?:any|unknown)(?![\w$'"`?:])/;
+/**
+ * The type an assertion states, or undefined when it states none. A const
+ * assertion (`x as const`, `<const>x`) narrows its operand's own type and
+ * names no type: its type node prints as `const`, a name nothing declares
+ * (carrick#2590). The walk stops there rather than reaching for an assertion
+ * further out, which describes a larger value than the read.
+ */
+function statedAssertionType(typeNode) {
+    if (!typeNode || ts.isConstTypeReference(typeNode.compilerNode))
+        return undefined;
+    return typeNode;
+}
 /**
  * The items whose whitespace-collapsed texts differ, first of each kept, in
  * order: how a joined union drops a member it already has.
@@ -2553,7 +2565,24 @@ export class TypeInferrer {
         // is its response, and a config's type is the config, so either one read
         // as the body publishes the wrong contract. Follow the call's signature to
         // the argument it sends as the body.
-        const inCall = this.requestBodyInCall(unwrapped);
+        let inCall = this.requestBodyInCall(unwrapped);
+        if (inCall.kind === 'none') {
+            // carrick#2628: the argument goes into a function that builds the body
+            // itself. An abstain here is a decision: capture's own re-read of the
+            // locator would publish the argument as the body.
+            const built = this.bodyBuiltByCallee(unwrapped);
+            if (built.kind === 'abstain') {
+                this.log(`Request locator at ${request.file_path}:${request.line_number}: ${built.why}; ` +
+                    'the argument is not the body');
+                return this.decidedAbstain(request, this.getNodeLocation(unwrapped), {
+                    path: '',
+                    kind: 'unknown',
+                    reason: 'body_built_by_callee',
+                    detail: `the located argument is not the request body: ${built.why}`,
+                });
+            }
+            inCall = built;
+        }
         if (inCall.kind === 'body') {
             this.log(`Request locator at ${request.file_path}:${request.line_number} names ${inCall.from}; ` +
                 'reading the body argument its signature declares');
@@ -2736,9 +2765,14 @@ export class TypeInferrer {
         // (res) => resolve(…)) })`): what the caller receives is what that
         // promise settles with, and the call made in the executor produces it.
         const nearestReturn = callExpr.getFirstAncestorByKind(SyntaxKind.ReturnStatement);
+        // A return whose value is an object or array literal built around the
+        // call (`return { ok: true, count: countOf(await client.add(…)) }`) hands
+        // back the caller's own value, which holds the result as one part: it
+        // answers for the call no more than a command table does (carrick#2628).
         const returnStmt = nearestReturn &&
             (this.findContainingFunctionForNode(nearestReturn) === func ||
-                this.callIsInReturnedPromiseExecutor(nearestReturn, func))
+                this.callIsInReturnedPromiseExecutor(nearestReturn, func)) &&
+            !this.callIsPartOfReturnedLiteral(callExpr, nearestReturn)
             ? nearestReturn
             : undefined;
         if (returnStmt) {
@@ -2752,8 +2786,9 @@ export class TypeInferrer {
         // the response, so the walk below has nothing to follow, and the call
         // itself would stand as the terminal and publish the transport object.
         // The read is the terminal, as it is when the walk finds it on a binding,
-        // and a call that takes the read and states what it returns says more
-        // than the read does (carrick#1382).
+        // and a call that takes the read and states it (a schema, or a function
+        // that returns it unchanged) says more than the read does (carrick#1382,
+        // carrick#2595).
         const inPlaceRead = this.bodyReadOnCallValue(callExpr);
         if (inPlaceRead) {
             return {
@@ -2771,8 +2806,11 @@ export class TypeInferrer {
             /** The value itself was read: returned, passed, aliased, or body-read. */
             let sawWholeRead = false;
             // Where the call's own value states no type, a call that takes it whole
-            // is the first place the source states one, and the walk follows it
-            // (`parse(raw)` after `const raw = await readRaw()`, carrick#1375).
+            // and states it (a schema, or a function that returns it unchanged) is
+            // the first place the source states one, and the walk follows it
+            // (`parse(raw)` after `const raw = await readRaw()`, carrick#1375). A
+            // converter, or a declaration whose body cannot be read, states nothing
+            // about the value (carrick#2595).
             const callValue = this.unwrapPromiseType(callExpr.getType());
             const callValueIsUntyped = callValue.isAny() || callValue.isUnknown();
             // A transport response handed whole to a helper is a body read through
@@ -2871,7 +2909,7 @@ export class TypeInferrer {
                 // body, and answers as it did.
                 if (this.expressionUsesNames(expr, currentNames) &&
                     !this.usesNamesOnlyByProjection(expr, currentNames)) {
-                    if (callValueIsUntyped ||
+                    if ((callValueIsUntyped && this.statesTrackedValue(expr, currentNames)) ||
                         this.restatesTrackedValue(expr, currentNames) ||
                         this.holdsBinaryBodyRead(expr, currentNames) ||
                         (callValueIsTransport && this.handsTrackedValueToACall(expr, currentNames))) {
@@ -2907,18 +2945,51 @@ export class TypeInferrer {
         }
         return callExpr;
     }
+    /**
+     * Between `callExpr` and the return statement around it there is an object
+     * or array literal: the call's result is one part of a value the function
+     * builds and returns.
+     */
+    callIsPartOfReturnedLiteral(callExpr, returnStmt) {
+        const ancestors = callExpr.getAncestors();
+        return ancestors
+            .slice(0, ancestors.indexOf(returnStmt))
+            .some((a) => Node.isObjectLiteralExpression(a) || Node.isArrayLiteralExpression(a));
+    }
     /**
      * `expr` declares a name for what a call returns when it is handed a
      * tracked name whole (`const data: T = await parseJson(response, 'op')`).
      */
     handsTrackedValueToACall(expr, names) {
-        if (!Node.isVariableDeclaration(expr))
-            return false;
-        const init = this.unwrapExpressionNode(expr.getInitializer());
-        return (Node.isCallExpression(init) &&
-            init
-                .getArguments()
-                .some((argument) => this.isIdentifierUsage(this.unwrapExpressionNode(argument), names)));
+        return Node.isVariableDeclaration(expr) && this.callTakingTrackedValue(expr, names) !== undefined;
+    }
+    /**
+     * The call whose result `expr` declares or assigns a name for, and the
+     * index of its argument that is a tracked name whole, or undefined.
+     */
+    callTakingTrackedValue(expr, names) {
+        const value = Node.isVariableDeclaration(expr)
+            ? expr.getInitializer()
+            : Node.isBinaryExpression(expr) && expr.getOperatorToken().getKind() === SyntaxKind.EqualsToken
+                ? expr.getRight()
+                : undefined;
+        const init = this.unwrapExpressionNode(value);
+        if (!Node.isCallExpression(init))
+            return undefined;
+        const index = init
+            .getArguments()
+            .findIndex((argument) => this.isIdentifierUsage(this.unwrapExpressionNode(argument), names));
+        return index >= 0 ? { call: init, index } : undefined;
+    }
+    /**
+     * `expr` names the result of a call that states the tracked value it takes
+     * (`callStatesItsArgument`): a schema validates it, or the callee returns it
+     * unchanged. A converter's result describes what it built from the value,
+     * not the value (carrick#2595).
+     */
+    statesTrackedValue(expr, names) {
+        const taking = this.callTakingTrackedValue(expr, names);
+        return !!taking && this.callStatesItsArgument(taking.call, taking.index);
     }
     /** `expr` holds a binary whole-body read taken on a tracked name. */
     holdsBinaryBodyRead(expr, names) {
@@ -3505,12 +3576,18 @@ export class TypeInferrer {
      *    serialiser answering `string` describes what the caller did with the
      *    body, not what the body is, and publishing it would be a
      *    concrete-but-wrong contract where the honest `any` of the read is
-     *    merely unresolved.
+     *    merely unresolved;
+     *  - the call states its argument (`callStatesItsArgument`): a schema
+     *    validates it, or the callee returns it unchanged. A converter's
+     *    object result describes what it built, not the body (carrick#2595).
      */
     statedPayloadAroundBodyRead(bodyRead) {
         return this.receivingCallOf(bodyRead, (candidate) => Node.isCallExpression(candidate) &&
             this.callResultIsBound(candidate) &&
-            this.isObjectShape(this.unwrapPromiseType(candidate.getType())));
+            this.isObjectShape(this.unwrapPromiseType(candidate.getType())) &&
+            this.callStatesItsArgument(candidate, candidate
+                .getArguments()
+                .findIndex((argument) => argument.getStart() <= bodyRead.getStart() && bodyRead.getEnd() <= argument.getEnd())));
     }
     /**
      * The source keeps this call's result: it initializes a declaration, is
@@ -4515,22 +4592,14 @@ export class TypeInferrer {
         const asExpr = Node.isAsExpression(node)
             ? node
             : node.getFirstAncestorByKind(SyntaxKind.AsExpression);
-        if (asExpr) {
-            const typeNode = asExpr.getTypeNode();
-            if (typeNode) {
-                return typeNode;
-            }
+        const asType = statedAssertionType(asExpr?.getTypeNode());
+        if (asType) {
+            return asType;
         }
         const typeAssertion = Node.isTypeAssertion(node)
             ? node
             : node.getFirstAncestorByKind(SyntaxKind.TypeAssertionExpression);
-        if (typeAssertion) {
-            const typeNode = typeAssertion.getTypeNode();
-            if (typeNode) {
-                return typeNode;
-            }
-        }
-        return undefined;
+        return statedAssertionType(typeAssertion?.getTypeNode());
     }
     /**
      * Render an explicit annotation (`as T`, `<T>`, or a typed binding) as
@@ -6951,6 +7020,231 @@ export class TypeInferrer {
         }
         return { kind: 'none' };
     }
+    /**
+     * carrick#2628: the located node is an argument of a call into a function
+     * whose body the program holds (an in-repo client method,
+     * `client.addTags(project, unique(tags))`), at a parameter that is not a
+     * body slot. What the call sends is decided inside that function, so the
+     * argument is the body only when the function sends it unchanged. One
+     * level, read off each use of the parameter in the function's body:
+     *
+     *  - the use IS the value of a body-named member (`body: tags`,
+     *    `body: JSON.stringify(tags)`) or of a body slot of a call: the
+     *    argument is the body, and its own type stands (`none`);
+     *  - the use sits inside such a value (`body: { tags }`,
+     *    `body: (event ?? {}) as never`): the body is that value, read at the
+     *    function without the casts around it;
+     *  - the use sits inside an object or array literal that is no body value
+     *    (`send(project, [labels])`): the body cannot be told, abstain.
+     *
+     * Uses that disagree abstain. A generic function's body may be typed by
+     * its type parameters, so it abstains too. A library's declaration
+     * (`fetch`, an installed client) has no body to read and is left alone,
+     * and so is an untyped argument (a handler's `request.body` handed to a
+     * helper): it states no contract to mistake, and the untyped-read path
+     * below reads it.
+     */
+    bodyBuiltByCallee(node) {
+        const own = node.getType();
+        if (own.isAny() || own.isUnknown())
+            return { kind: 'none' };
+        const call = this.receivingCallOf(node, (candidate) => Node.isCallExpression(candidate));
+        if (!call || !Node.isCallExpression(call))
+            return { kind: 'none' };
+        const index = call
+            .getArguments()
+            .findIndex((a) => a.getPos() <= node.getPos() && node.getEnd() <= a.getEnd());
+        if (index < 0)
+            return { kind: 'none' };
+        if (this.requestBodySlots(call)[index])
+            return { kind: 'none' };
+        const callee = this.project.getTypeChecker().getResolvedSignature(call)?.getDeclaration();
+        if (!callee ||
+            !(Node.isFunctionDeclaration(callee) ||
+                Node.isMethodDeclaration(callee) ||
+                Node.isArrowFunction(callee) ||
+                Node.isFunctionExpression(callee))) {
+            return { kind: 'none' };
+        }
+        const body = callee.getBody();
+        if (!body)
+            return { kind: 'none' };
+        const program = this.project.getProgram().compilerObject;
+        if (isExternalOrigin(program, callee.getSourceFile().compilerNode, this.repoRoot, externalImportsOf(this.project))) {
+            return { kind: 'none' };
+        }
+        const param = callee.getParameters()[index];
+        if (!param || param.isRestParameter())
+            return { kind: 'none' };
+        const paramName = param.getNameNode();
+        if (!Node.isIdentifier(paramName))
+            return { kind: 'none' };
+        const paramSymbol = paramName.getSymbol()?.compilerSymbol;
+        if (!paramSymbol)
+            return { kind: 'none' };
+        const checker = this.project.getTypeChecker().compilerObject;
+        const uses = body.getDescendantsOfKind(SyntaxKind.Identifier).filter((id) => {
+            const parent = id.getParent();
+            const symbol = parent && Node.isShorthandPropertyAssignment(parent)
+                ? checker.getShorthandAssignmentValueSymbol(parent.compilerNode)
+                : id.getSymbol()?.compilerSymbol;
+            return symbol === paramSymbol;
+        });
+        const from = 'a call into a function that builds the request body inside itself';
+        let passedThrough = false;
+        const built = [];
+        for (const use of uses) {
+            // carrick#2668: `data ? JSON.stringify(data) : undefined` tests the
+            // argument before it sends it; the test is no body.
+            if (this.inSendNothingTest(use, body))
+                continue;
+            const value = this.bodyValueAround(use, body);
+            if (value === use) {
+                passedThrough = true;
+                continue;
+            }
+            if (value) {
+                built.push(value);
+                continue;
+            }
+            const ancestors = use.getAncestors();
+            const insideLiteral = ancestors
+                .slice(0, ancestors.indexOf(body))
+                .some((a) => Node.isObjectLiteralExpression(a) || Node.isArrayLiteralExpression(a));
+            if (insideLiteral) {
+                return {
+                    kind: 'abstain',
+                    why: `the located argument goes into a value the called function builds and does not send as a body (${from})`,
+                };
+            }
+        }
+        if (built.length === 0)
+            return { kind: 'none' };
+        if (passedThrough) {
+            return { kind: 'abstain', why: `the called function both sends the argument and builds a body from it (${from})` };
+        }
+        if (callee.getTypeParameters().length > 0) {
+            return { kind: 'abstain', why: `the called function is generic, so the body it builds may be typed by its type parameters (${from})` };
+        }
+        const types = built.map((value) => this.sentValue(value));
+        const texts = new Set(types.map((value) => typeText(value.getType(), value)));
+        if (texts.size !== 1) {
+            return { kind: 'abstain', why: `the called function builds more than one body from the argument (${from})` };
+        }
+        const at = types[0];
+        const type = at.getType();
+        if (type.isTypeParameter() || printedTypeHoldsTopType([...texts][0])) {
+            return { kind: 'abstain', why: `the body the called function builds is not fully typed (${from})` };
+        }
+        return { kind: 'body_type', type, at, from };
+    }
+    /**
+     * The request body value `use` is part of, inside `scope`: the value of a
+     * body-named object member, or the argument at a body slot of a call,
+     * looking through parentheses, casts, `await` and a `JSON.stringify`
+     * around it. `use` itself when it is that value whole.
+     */
+    bodyValueAround(use, scope) {
+        let current = use;
+        while (current !== scope) {
+            const parent = current.getParent();
+            if (!parent)
+                return undefined;
+            if (Node.isShorthandPropertyAssignment(parent) &&
+                current === use &&
+                BODY_MEMBER_NAMES.has(parent.getName())) {
+                return use;
+            }
+            if (Node.isPropertyAssignment(parent) &&
+                parent.getInitializer() === current &&
+                BODY_MEMBER_NAMES.has(parent.getName())) {
+                return this.isSameValue(current, use) ? use : current;
+            }
+            if (Node.isCallExpression(parent)) {
+                const index = parent.getArguments().indexOf(current);
+                if (index >= 0 && this.requestBodySlots(parent)[index]?.kind === 'body') {
+                    return this.isSameValue(current, use) ? use : current;
+                }
+            }
+            current = parent;
+        }
+        return undefined;
+    }
+    /** `value` is `use` behind what `sentValue` sees through. */
+    isSameValue(value, use) {
+        return this.sentValue(value) === use;
+    }
+    /**
+     * The value a body slot sends when it sends anything, behind parentheses,
+     * casts, `await`, a `JSON.stringify`, and (carrick#2668) a choice whose
+     * other side sends nothing: `x ? JSON.stringify(x) : undefined`,
+     * `x || null`, `x ?? undefined`. A `?? {}` sends `{}`, so it is a body the
+     * function builds and is not seen through.
+     */
+    sentValue(value) {
+        let current = value;
+        for (;;) {
+            let inner = this.unwrapJsonStringifyArg(this.unwrapExpressionNode(current));
+            if (Node.isConditionalExpression(inner)) {
+                inner = this.sendingBranch(inner) ?? inner;
+            }
+            else if (Node.isBinaryExpression(inner)) {
+                const operator = inner.getOperatorToken().getKind();
+                if ((operator === SyntaxKind.BarBarToken || operator === SyntaxKind.QuestionQuestionToken) &&
+                    this.sendsNothing(inner.getRight(), false)) {
+                    inner = inner.getLeft();
+                }
+            }
+            if (inner === current)
+                return current;
+            current = inner;
+        }
+    }
+    /**
+     * The branch of `choice` that sends something, when its other branch sends
+     * nothing (`undefined`, `null`, `void 0`, or `{}` spread into a request).
+     */
+    sendingBranch(choice) {
+        const whenTrue = choice.getWhenTrue();
+        const whenFalse = choice.getWhenFalse();
+        if (this.sendsNothing(whenFalse, true) && !this.sendsNothing(whenTrue, true))
+            return whenTrue;
+        if (this.sendsNothing(whenTrue, true) && !this.sendsNothing(whenFalse, true))
+            return whenFalse;
+        return undefined;
+    }
+    /** `undefined`, `null`, `void 0`, or (where `emptyObject`) `{}`. */
+    sendsNothing(node, emptyObject) {
+        const value = this.unwrapExpressionNode(node);
+        if (Node.isNullLiteral(value) || Node.isVoidExpression(value))
+            return true;
+        if (Node.isIdentifier(value) && value.getText() === 'undefined')
+            return true;
+        return (emptyObject &&
+            Node.isObjectLiteralExpression(value) &&
+            value.getProperties().length === 0);
+    }
+    /**
+     * carrick#2668, #2664: `use` sits in the test of a choice whose other side
+     * sends nothing (`body ? JSON.stringify(body) : null`,
+     * `...(body === undefined ? {} : { body: JSON.stringify(body) })`). The
+     * test only decides whether the argument is sent.
+     */
+    inSendNothingTest(use, scope) {
+        let current = use;
+        while (current !== scope) {
+            const parent = current.getParent();
+            if (!parent)
+                return false;
+            if (Node.isConditionalExpression(parent) &&
+                parent.getCondition() === current &&
+                this.sendingBranch(parent)) {
+                return true;
+            }
+            current = parent;
+        }
+        return false;
+    }
     /** A string, a string literal, a template literal, or a union of strings. */
     isStringLikeType(type) {
         return (type.isString() ||
@@ -7480,25 +7774,10 @@ export class TypeInferrer {
      * `reads.parameters`, the parameter's own type (rank 4).
      */
     stateAtReceivingCall(call, index, reads, found, stateNode) {
-        const schemaCandidates = [];
-        const callee = call.getExpression();
-        if (Node.isPropertyAccessExpression(callee))
-            schemaCandidates.push(callee.getExpression());
-        call.getArguments().forEach((argument, at) => {
-            if (at !== index)
-                schemaCandidates.push(this.unwrapExpressionNode(argument));
-        });
-        for (const candidate of schemaCandidates) {
-            const candidateType = candidate.getType();
-            if (!this.schemaOutputType(candidateType, candidate) &&
-                !this.schemaInputType(candidateType, candidate)) {
-                continue;
-            }
-            const contract = this.schemaContract(candidate, 'input');
-            if (contract) {
-                found.push({ rank: 1, text: contract.text, provenance: contract.provenance, at: call, how: 'a schema it is handed to' });
-                return;
-            }
+        const contract = this.schemaHandedArgument(call, index);
+        if (contract) {
+            found.push({ rank: 1, text: contract.text, provenance: contract.provenance, at: call, how: 'a schema it is handed to' });
+            return;
         }
         const passThrough = this.passThroughFunction(call, index);
         if (passThrough) {
@@ -7527,6 +7806,44 @@ export class TypeInferrer {
             return;
         found.push({ rank: 4, text, at: call, how: 'the parameter of a call it is handed to' });
     }
+    /**
+     * The input contract of a schema `call` validates its argument at `index`
+     * with: its receiver (`Schema.safeParse(body)`) or one of its other
+     * arguments (`parse(Schema, body)`), or null. A candidate counts only when
+     * it declares schema types, so no method or library name is matched
+     * (carrick#1166).
+     */
+    schemaHandedArgument(call, index) {
+        const candidates = [];
+        const callee = call.getExpression();
+        if (Node.isPropertyAccessExpression(callee))
+            candidates.push(callee.getExpression());
+        call.getArguments().forEach((argument, at) => {
+            if (at !== index)
+                candidates.push(this.unwrapExpressionNode(argument));
+        });
+        for (const candidate of candidates) {
+            const candidateType = candidate.getType();
+            if (!this.schemaOutputType(candidateType, candidate) &&
+                !this.schemaInputType(candidateType, candidate)) {
+                continue;
+            }
+            const contract = this.schemaContract(candidate, 'input');
+            if (contract)
+                return contract;
+        }
+        return null;
+    }
+    /**
+     * `call`'s result describes the value it takes at argument `index`: it
+     * validates it with a schema, or its callee returns it unchanged
+     * (`passThroughFunction`). Any other call builds something new from the
+     * value, and its result describes what it built, never the value it was
+     * handed (carrick#2595).
+     */
+    callStatesItsArgument(call, index) {
+        return index >= 0 && (!!this.schemaHandedArgument(call, index) || !!this.passThroughFunction(call, index));
+    }
     /**
      * The project function `call` invokes, when every value it returns is its
      * argument at `index` as it was handed in (through parentheses, casts,

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

@@ -271,6 +271,43 @@ export interface PositionRowsRequest extends BaseRequest {
     /** The service the rows are for, written in the header. */
     service: string;
 }
+/**
+ * The implementations of the bodyless declarations some calls go through
+ * (carrick#2432 slice B), asked of the analysis process: one batch per
+ * service.
+ */
+export interface ImplementationsRequest extends BaseRequest {
+    action: 'implementations';
+    /** One question per call, each the span of its `call` (or `member`) position row. */
+    queries: ImplementationsQuery[];
+    /** The scanned repo's root: every name in an answer is relative to it. */
+    scan_root: string;
+}
+export interface ImplementationsQuery {
+    /** Absolute path of the file holding the call. */
+    file: string;
+    /** The row's span: UTF-16 code units from the start of the file. */
+    start: number;
+    end: number;
+}
+/** A declaration as a position row names one. */
+export interface NamedDeclaration {
+    symbol: string | null;
+    decl_file: string | null;
+    decl_line: number | null;
+    decl_package: string | null;
+}
+/** Why an answer names no implementation, where it is not because there is none. */
+export type ImplementationsReason = 'not_in_program' | 'no_call' | 'no_symbol' | 'no_declaration' | 'has_body' | 'checker_threw';
+export interface ImplementationsAnswer {
+    /** The declaration the call goes through, as its row names it. */
+    declaration: NamedDeclaration | null;
+    /** By file, then position; empty when `too_many`. */
+    implementations: NamedDeclaration[];
+    /** More than the cap (16) were found, and none is listed. */
+    too_many: boolean;
+    reason?: ImplementationsReason;
+}
 /**
  * Request to resolve type definitions from a v2 capture stub package.
  * Returns both the original declaration and the compiler-expanded form for
@@ -585,7 +622,7 @@ export interface ListLibrarySurfaceRequest extends BaseRequest {
 /**
  * Union type for all possible sidecar requests
  */
-export type SidecarRequest = RetypeCheckRequest | VerifyClientSemanticsRequest | VerifyLibraryClaimsRequest | ListLibrarySurfaceRequest | InitRequest | BundleRequest | CaptureV2Request | CheckV2Request | InferRequest | ResolveDefinitionsRequest | HealthRequest | ShutdownRequest | ListProgramFilesRequest | AddProgramFilesRequest | PositionRowsRequest;
+export type SidecarRequest = RetypeCheckRequest | VerifyClientSemanticsRequest | VerifyLibraryClaimsRequest | ListLibrarySurfaceRequest | InitRequest | BundleRequest | CaptureV2Request | CheckV2Request | InferRequest | ResolveDefinitionsRequest | HealthRequest | ShutdownRequest | ListProgramFilesRequest | AddProgramFilesRequest | PositionRowsRequest | ImplementationsRequest;
 /**
  * Request for a specific symbol to be bundled
  */
@@ -775,6 +812,13 @@ export interface HealthResponse extends BaseResponse {
 export interface ShutdownResponse extends BaseResponse {
     status: 'success';
 }
+/** Response for implementations: one answer per question, in request order. */
+export interface ImplementationsResponse extends BaseResponse {
+    result?: {
+        answers: ImplementationsAnswer[];
+    };
+    errors?: string[];
+}
 /** Response for position_rows: what was written, counted. */
 export interface PositionRowsResponse extends BaseResponse {
     result?: PositionRowsCounts;
@@ -962,7 +1006,7 @@ export interface ListLibrarySurfaceResponse extends BaseResponse {
 /**
  * Union type for all possible sidecar responses
  */
-export type SidecarResponse = RetypeCheckResponse | VerifyClientSemanticsResponse | VerifyLibraryClaimsResponse | ListLibrarySurfaceResponse | InitResponse | BundleResponse | CaptureV2Response | CheckV2Response | InferResponse | ResolveDefinitionsResponse | HealthResponse | ShutdownResponse | ListProgramFilesResponse | AddProgramFilesResponse | PositionRowsResponse | ErrorResponse;
+export type SidecarResponse = RetypeCheckResponse | VerifyClientSemanticsResponse | VerifyLibraryClaimsResponse | ListLibrarySurfaceResponse | InitResponse | BundleResponse | CaptureV2Response | CheckV2Response | InferResponse | ResolveDefinitionsResponse | HealthResponse | ShutdownResponse | ListProgramFilesResponse | AddProgramFilesResponse | PositionRowsResponse | ImplementationsResponse | ErrorResponse;
 /**
  * An entry in the type manifest
  */

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

@@ -848,6 +848,43 @@ export declare const PositionRowsRequestSchema: z.ZodObject<{
     scan_root: string;
     out_path: string;
 }>;
+export declare const ImplementationsRequestSchema: z.ZodObject<{
+    request_id: z.ZodString;
+} & {
+    action: z.ZodLiteral<"implementations">;
+    queries: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        file: string;
+        end: number;
+        start: number;
+    }, {
+        file: string;
+        end: number;
+        start: number;
+    }>, "many">;
+    scan_root: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    queries: {
+        file: string;
+        end: number;
+        start: number;
+    }[];
+    request_id: string;
+    action: "implementations";
+    scan_root: string;
+}, {
+    queries: {
+        file: string;
+        end: number;
+        start: number;
+    }[];
+    request_id: string;
+    action: "implementations";
+    scan_root: string;
+}>;
 export declare const ResolveDefinitionsRequestSchema: z.ZodObject<{
     request_id: z.ZodString;
 } & {
@@ -4506,6 +4543,42 @@ export declare const SidecarRequestSchema: z.ZodDiscriminatedUnion<"action", [z.
     action: "position_rows";
     scan_root: string;
     out_path: string;
+}>, z.ZodObject<{
+    request_id: z.ZodString;
+} & {
+    action: z.ZodLiteral<"implementations">;
+    queries: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        file: string;
+        end: number;
+        start: number;
+    }, {
+        file: string;
+        end: number;
+        start: number;
+    }>, "many">;
+    scan_root: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    queries: {
+        file: string;
+        end: number;
+        start: number;
+    }[];
+    request_id: string;
+    action: "implementations";
+    scan_root: string;
+}, {
+    queries: {
+        file: string;
+        end: number;
+        start: number;
+    }[];
+    request_id: string;
+    action: "implementations";
+    scan_root: string;
 }>]>;
 /**
  * Result type for parseRequest