carrick 0.3.123 → 0.3.125

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

@@ -107,5 +107,49 @@ export interface PositionRowsOptions {
  * a directory inside the scanned trees anywhere but beneath `.carrick`.
  */
 export declare function writePositionRows(options: PositionRowsOptions): PositionRowsCounts;
+/** What a declaration's file is written as in a row's `decl_file`: `lib:<name>` for the default library, else `PathNames`'. */
+export declare function declaringFileName(program: ts.Program, paths: PathNames, file: ts.SourceFile): string | null;
+/**
+ * Names for the files rows point at, never an absolute path: relative to the
+ * scanned repo's root when inside it (its real path too, so a root reached
+ * through a link still contains its files), `lib:<name>` for the compiler's
+ * default library, `pkg:<name>/<path>` for an installed package outside the
+ * root, and nothing otherwise.
+ */
+export declare class PathNames {
+    private readonly roots;
+    private readonly packageNames;
+    /**
+     * Answers by declaring file: a service's rows name a few thousand files
+     * hundreds of thousands of times, and the module graph's answer is a scan
+     * of its packages (on a Deno service it was 40% of the walk).
+     */
+    private readonly declaringFiles;
+    private readonly declaringPackages;
+    constructor(scanRoot: string);
+    /** The root `file` lies under, and its path from there; `undefined` outside every root. */
+    private inside;
+    /** A request file's name: relative to the root, which every file the scanner sends is inside. */
+    relative(file: string): string;
+    /** What a declaring file is written as, or `null` when nothing names it. */
+    declaringFile(fileName: string): string | null;
+    private nameDeclaringFile;
+    /**
+     * The package a declaring file belongs to: the module graph's or the path's
+     * answer (`installedPackageOf`), else, for a file inside the root, the
+     * `name` of the nearest package.json at or above it, up to the root.
+     */
+    declaringPackage(fileName: string, packageOf: (filePath: string) => string | undefined): string | null;
+    private nameDeclaringPackage;
+    private packageNameIn;
+    /**
+     * `import("/abs/path")` in a printed type, written with the declaring
+     * file's name instead. The print has no enclosing node, so it names every
+     * module by the file that declares it and one type reads the same from
+     * every file; it also skips the accessibility search an enclosing node
+     * costs (40% of the walk on a 600-file service).
+     */
+    scrubType(text: string): string;
+}
 /** The kind of row a node gives, if any (exported for the editor-parity test, carrick#2418). */
 export declare function kindOf(node: ts.Node): NodeKind | undefined;

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

@@ -242,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);
@@ -253,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();
     /**
@@ -466,9 +470,7 @@ 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 };

package/sidecar/dist/src/project-loader.d.ts

@@ -80,6 +80,16 @@ export declare class ProjectLoader {
     private denoProject;
     /** The tsconfig the service names, when the project is built from one. */
     private namedTsconfigPath;
+    /**
+     * Set when the service has no config at or above its root: each file is then
+     * typed under the nearest `tsconfig.json`/`jsconfig.json` on its way up to
+     * the service root (carrick#1604), and the default project holds the rest.
+     */
+    private inferredService;
+    /** The per-directory answers of `fileConfigPath` for this service. */
+    private readonly fileConfigs;
+    /** The reference owner rule of each config a file was found under. */
+    private readonly ownerRules;
     /** Each file's owning config (carrick#1604), resolved on first use. */
     private configPathFor;
     /** Programs built for owning projects other than the named tsconfig. */
@@ -128,6 +138,12 @@ export declare class ProjectLoader {
      * as before.
      */
     projectKeyFor(file?: string): string;
+    /**
+     * `projectKeyFor` for a service with no config at its root: the owner of the
+     * nearest config on the file's way up to the service root, or `''` (the
+     * default project, under the inferred options) for a file with none.
+     */
+    private inferredKeyFor;
     /**
      * The project behind a key from `projectKeyFor`, built on first use and
      * kept: a service whose files all belong to one project builds one.

package/sidecar/dist/src/project-loader.js

@@ -11,8 +11,9 @@
  */
 import { Project, getCompilerOptionsFromTsConfig } from 'ts-morph';
 import * as path from 'node:path';
+import ts from 'typescript';
 import * as fs from 'node:fs';
-import { DenoProject, findDenoConfig, findServiceTsconfig, referenceRedirectOf, serviceConfigPath, sidecarCompilerOptions, untrustedReadBound, } from './capture/index.js';
+import { DenoProject, findDenoConfig, fileConfigPath, findServiceTsconfig, referenceRedirectOf, serviceConfigPath, sidecarCompilerOptions, untrustedReadBound, } from './capture/index.js';
 import { moduleFormatResolutionHost } from './module-format.js';
 import { ExternalImports, registerExternalImports } from './origin.js';
 /**
@@ -92,6 +93,11 @@ const TARGET_MAP = {
     'ES2023': 10,
     'ESNext': 99,
 };
+/** Whether the config's own `compilerOptions` state `maxNodeModuleJsDepth`. */
+function statesJsDepth(configPath) {
+    const raw = ts.readConfigFile(configPath, ts.sys.readFile).config;
+    return raw?.compilerOptions?.maxNodeModuleJsDepth !== undefined;
+}
 /**
  * ProjectLoader - Manages ts-morph Project initialization and access
  *
@@ -126,6 +132,16 @@ export class ProjectLoader {
     denoProject;
     /** The tsconfig the service names, when the project is built from one. */
     namedTsconfigPath;
+    /**
+     * Set when the service has no config at or above its root: each file is then
+     * typed under the nearest `tsconfig.json`/`jsconfig.json` on its way up to
+     * the service root (carrick#1604), and the default project holds the rest.
+     */
+    inferredService = false;
+    /** The per-directory answers of `fileConfigPath` for this service. */
+    fileConfigs = new Map();
+    /** The reference owner rule of each config a file was found under. */
+    ownerRules = new Map();
     /** Each file's owning config (carrick#1604), resolved on first use. */
     configPathFor;
     /** Programs built for owning projects other than the named tsconfig. */
@@ -231,6 +247,7 @@ export class ProjectLoader {
                 }
                 else {
                     this.log('No tsconfig.json found, using default compiler options');
+                    this.inferredService = true;
                     this.buildProject = (kind) => {
                         const project = new Project({
                             ...this.fileSystemOption(),
@@ -239,7 +256,7 @@ export class ProjectLoader {
                         });
                         // Add source files from common locations
                         if (kind === 'listed')
-                            this.addDefaultSourceFiles(project);
+                            this.addDefaultSourceFiles(project, (file) => this.projectKeyFor(file) === '');
                         return project;
                     };
                 }
@@ -347,11 +364,18 @@ export class ProjectLoader {
      */
     projectFromConfig(configPath, kind = 'listed') {
         const imports = new ExternalImports();
+        const options = getCompilerOptionsFromTsConfig(configPath).options;
+        // TypeScript reads a `jsconfig.json` with an implicit depth of 2, which
+        // loads the JavaScript sources of installed packages; every other program
+        // here reads 0. A depth the config states is kept (carrick#1604).
+        if (this.inferredService && path.basename(configPath) === 'jsconfig.json' && !statesJsDepth(configPath)) {
+            options.maxNodeModuleJsDepth = 0;
+        }
         const project = new Project({
             ...this.fileSystemOption(),
             tsConfigFilePath: configPath,
             // Over the tsconfig's own options: ts-morph lays these on top.
-            compilerOptions: sidecarCompilerOptions(optionsFor(kind, getCompilerOptionsFromTsConfig(configPath).options)),
+            compilerOptions: sidecarCompilerOptions(optionsFor(kind, options)),
             skipAddingFilesFromTsConfig: kind === 'scripts',
             // Each import resolves in its file's own module format (carrick#1619),
             // a referenced project's unbuilt output reads as its source, under its
@@ -373,12 +397,33 @@ export class ProjectLoader {
      * as before.
      */
     projectKeyFor(file) {
+        if (this.inferredService)
+            return this.inferredKeyFor(file);
         if (!this.namedTsconfigPath || file === undefined)
             return '';
         this.configPathFor ??= serviceConfigPath(this.namedTsconfigPath, (d) => this.logError(d));
         const config = this.configPathFor(path.resolve(this.repoRoot, file));
         return config === this.namedTsconfigPath ? '' : config;
     }
+    /**
+     * `projectKeyFor` for a service with no config at its root: the owner of the
+     * nearest config on the file's way up to the service root, or `''` (the
+     * default project, under the inferred options) for a file with none.
+     */
+    inferredKeyFor(file) {
+        if (file === undefined)
+            return '';
+        const absolute = path.resolve(this.repoRoot, file);
+        const config = fileConfigPath(absolute, this.repoRoot, this.fileConfigs);
+        if (config === undefined)
+            return '';
+        let owner = this.ownerRules.get(config);
+        if (!owner) {
+            owner = serviceConfigPath(config, (d) => this.logError(d));
+            this.ownerRules.set(config, owner);
+        }
+        return owner(absolute);
+    }
     /**
      * The project behind a key from `projectKeyFor`, built on first use and
      * kept: a service whose files all belong to one project builds one.
@@ -512,7 +557,7 @@ export class ProjectLoader {
      * dependencies installed it cost 40 s and added nothing the compiler needs
      * (carrick#749).
      */
-    addDefaultSourceFiles(project) {
+    addDefaultSourceFiles(project, keep = () => true) {
         const globs = DEFAULT_SOURCE_PATTERNS.map((pattern) => path.join(this.repoRoot, pattern));
         // Negated last so it applies to every pattern above it.
         globs.push(`!${path.join(this.repoRoot, '**/node_modules/**')}`);
@@ -525,6 +570,8 @@ export class ProjectLoader {
             return;
         }
         for (const filePath of filePaths) {
+            if (!keep(filePath))
+                continue;
             try {
                 project.addSourceFileAtPath(filePath);
             }

package/sidecar/dist/src/type-inferrer.d.ts

@@ -1800,8 +1800,10 @@ export declare class TypeInferrer {
      *  - a cast on it: `(await request.json()) as NewWidget`;
      *  - the annotation of the binding it initialises:
      *    `const input: NewWidget = await request.json()`;
-     *  - a schema the read, or the binding that holds it, is handed to
-     *    (`schemaConsumingRead`): the schema's input is what a caller may send.
+     *  - a type the handler states for the read further on
+     *    (`statedInFunction`): a schema it is handed to, the annotation of a
+     *    name it is assigned to, a pass-through function, a cast of the whole
+     *    value.
      *
      * The first two are `typeNodeStatedAtRead`, the reading a consumer's
      * response read already gets. An annotation further out is not one of them:
@@ -2030,19 +2032,58 @@ export declare class TypeInferrer {
      */
     private middlewareBodySchemaValues;
     /**
-     * The contract of the schema a handler validates an untyped body read with
-     * (carrick#1166), or null.
-     *
-     * `read` is the located expression: the read call, or the binding that holds
-     * it. Every call in the enclosing function that takes that value as an
-     * argument is a candidate, and the schema is the call's receiver
-     * (`Schema.safeParse(body)`) or one of its other arguments
-     * (`parse(Schema, body)`). A candidate counts only when it declares schema
-     * types (`schemaOutputType` / `schemaInputType`), so a logger or a service
-     * call the body is also handed to is never read as a contract. No method or
-     * library name is matched.
-     */
-    private schemaConsumingRead;
+     * The type the function a value is made in states for it, where the
+     * compiler types the value itself `any` or `unknown` (carrick#2594), or
+     * null.
+     *
+     * `value` is the located expression: a body read, or a call whose result is
+     * untyped. The value is followed through the names that hold it: a
+     * declaration it initialises, and a name it is assigned to later
+     * (`let body: unknown; body = await read()`). At each place the value or
+     * one of those names is used whole, the source can state a type:
+     *
+     *  0. the annotation of the name that holds it (`let body: Upload`), or the
+     *     declared return type of the function that returns it unchanged (only
+     *     with `reads.returned`);
+     *  1. a schema it is handed to (`Schema.safeParse(body ?? {})`,
+     *     `parse(Schema, body)`): the schema's input is what a sender may send
+     *     (carrick#1166). A candidate counts only when it declares schema types,
+     *     so no method or library name is matched;
+     *  2. a function of the project it is handed to that returns that argument
+     *     unchanged (through casts) or an empty default: its declared return
+     *     type. A function that builds a new value from its argument is a
+     *     converter, and its return type describes what it built, never the
+     *     value it was handed, so it states nothing here;
+     *  3. a cast of the whole value (`(body as { phone: string }).phone`);
+     *  4. the parameter of a call it is handed to (only with
+     *     `reads.parameters`), where that parameter's type is a body shape once
+     *     any callable member is dropped (a function never crosses the wire).
+     *
+     * The first rank with an answer decides. A placeholder (`unknown`,
+     * `Record<string, unknown>`, any type node with `any` or `unknown` written
+     * in it) states nothing, and two different statements in one rank decide
+     * nothing: the answer is null.
+     */
+    private statedInFunction;
+    /**
+     * What a call that takes the value at argument `index` states for it:
+     * a schema among its receiver and other arguments (rank 1), a callee of the
+     * project that returns that argument unchanged (rank 2), or, with
+     * `reads.parameters`, the parameter's own type (rank 4).
+     */
+    private stateAtReceivingCall;
+    /**
+     * The project function `call` invokes, when every value it returns is its
+     * argument at `index` as it was handed in (through parentheses, casts,
+     * `satisfies` and `!`) or an empty default (`{}`, `[]`, `null`,
+     * `undefined`), and at least one return is that argument. Such a function
+     * narrows its argument, so its declared return type describes the value it
+     * was handed. Any other function builds something new from it, and is not
+     * this.
+     */
+    private passThroughFunction;
+    /** `{}`, `[]`, `null` or `undefined`: a default that states no member. */
+    private isEmptyDefault;
     /**
      * The part a validated read names when that part is not a body, or
      * `undefined` (carrick#1166).