carrick 0.3.109 → 0.3.111

package/sidecar/dist/src/capture/installed-package-directory.js

@@ -0,0 +1,30 @@
+/**
+ * Where an installed package sits on disk, by path alone, for capture's
+ * resolution walk. It mirrors `DeclarationReader.installedPackage` in
+ * library-claims.ts: the capture seam (pinned decision 11a) lets neither side
+ * import the other, so a change to what counts as installed changes both.
+ *
+ * Seam: node builtins only.
+ */
+import * as path from 'node:path';
+/**
+ * The installed package directory a real path lies in, by path alone: the
+ * directory after the path's last `node_modules` segment (two segments for a
+ * scope), taken relative to `root`, and the name it is installed as. A source
+ * file in a directory named `node_modules` above `root`, or a checkout under a
+ * `node_modules` ancestor, is not installed; an install hoisted above `root`
+ * (`../../node_modules/pkg`) and a pnpm store
+ * (`node_modules/.pnpm/pkg@1/node_modules/pkg`) are. The caller reads the
+ * package.json there: without one, nothing is installed.
+ */
+export function installedPackageDirectory(root, realPath) {
+    const segments = path.relative(root, realPath).split(path.sep);
+    const last = segments.lastIndexOf('node_modules');
+    if (last < 0)
+        return undefined;
+    const width = segments[last + 1]?.startsWith('@') ? 2 : 1;
+    return {
+        directory: path.resolve(root, ...segments.slice(0, last + 1 + width)),
+        name: segments.slice(last + 1, last + 1 + width).join('/'),
+    };
+}

package/sidecar/dist/src/capture/resolution-edges.d.ts

@@ -0,0 +1,36 @@
+/**
+ * How the scanned repo's installed tree resolved the packages a stub pins
+ * (carrick#2091).
+ *
+ * A stub pins only the externals its declarations import. The check
+ * workspace has no lockfile, so without this record every package those pins
+ * depend on resolves fresh from the registry: the check can install a version
+ * the repo never ran, or fail on one the registry lists but cannot serve.
+ *
+ * The walk reads the installed tree the way Node's lookup does, so one reader
+ * covers npm, pnpm (isolated store and hoisted), yarn's node-modules linker
+ * and bun. Starting at each pin installed at the pinned version, it follows
+ * `dependencies` and `optionalDependencies` breadth first and records
+ * `<parent>@<version> -> <child>: <version>` for every child installed as a
+ * published package of that name. Workspace members, `link:` targets and npm
+ * aliases are left out: the registry cannot serve them by that name. An edge
+ * whose parent version is installed twice with different children is left
+ * out, since no one answer is the repo's.
+ *
+ * The walk only reads. Seam: node builtins and this bundle only.
+ */
+/** The stub file the check reads to pin transitive edges. */
+export declare const RESOLUTION_FILE = "carrick-resolution.json";
+/** `<parent>@<version>` -> child name -> child version. */
+export type ResolutionEdges = Record<string, Record<string, string>>;
+export interface InstalledResolution {
+    /** Key-sorted at both levels; byte-stable for one tree. */
+    edges: ResolutionEdges;
+    /** Dependencies of walked packages that no edge records: the check resolves these from the registry. */
+    unrecorded: number;
+}
+/**
+ * The edges the installed tree under `serviceRoot` resolved, from the stub's
+ * pins outward. A pin not installed at its pinned version starts no walk.
+ */
+export declare function installedResolutionEdges(serviceRoot: string, pins: Record<string, string>): InstalledResolution;

package/sidecar/dist/src/capture/resolution-edges.js

@@ -0,0 +1,150 @@
+/**
+ * How the scanned repo's installed tree resolved the packages a stub pins
+ * (carrick#2091).
+ *
+ * A stub pins only the externals its declarations import. The check
+ * workspace has no lockfile, so without this record every package those pins
+ * depend on resolves fresh from the registry: the check can install a version
+ * the repo never ran, or fail on one the registry lists but cannot serve.
+ *
+ * The walk reads the installed tree the way Node's lookup does, so one reader
+ * covers npm, pnpm (isolated store and hoisted), yarn's node-modules linker
+ * and bun. Starting at each pin installed at the pinned version, it follows
+ * `dependencies` and `optionalDependencies` breadth first and records
+ * `<parent>@<version> -> <child>: <version>` for every child installed as a
+ * published package of that name. Workspace members, `link:` targets and npm
+ * aliases are left out: the registry cannot serve them by that name. An edge
+ * whose parent version is installed twice with different children is left
+ * out, since no one answer is the repo's.
+ *
+ * The walk only reads. Seam: node builtins and this bundle only.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { installedPackageDirectory } from './installed-package-directory.js';
+import { isPublishedSemver } from './lockfile.js';
+/** The stub file the check reads to pin transitive edges. */
+export const RESOLUTION_FILE = 'carrick-resolution.json';
+function validName(name) {
+    return !name.split('/').some((s) => s === '' || s === '.' || s === '..');
+}
+/**
+ * Node's lookup of `name` from `fromDir`: `<dir>/node_modules/<name>` at each
+ * ancestor, skipping an ancestor that is itself a `node_modules` directory.
+ * That skip is how a pnpm store package finds its sibling links.
+ */
+function lookup(fromDir, name) {
+    let dir = fromDir;
+    for (;;) {
+        if (path.basename(dir) !== 'node_modules') {
+            const candidate = path.join(dir, 'node_modules', ...name.split('/'));
+            if (fs.existsSync(path.join(candidate, 'package.json')))
+                return candidate;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+/**
+ * The package `name` installed as Node would find it from `fromDir`: a
+ * directory `installedPackageDirectory` accepts, holding a package.json of
+ * that name with a published version.
+ */
+function installedFrom(root, fromDir, name) {
+    if (!validName(name))
+        return undefined;
+    const found = lookup(fromDir, name);
+    if (found === undefined)
+        return undefined;
+    try {
+        const dir = fs.realpathSync(found);
+        const installed = installedPackageDirectory(root, dir);
+        if (installed === undefined || installed.directory !== dir || installed.name !== name) {
+            return undefined;
+        }
+        const manifest = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        if (manifest?.name !== name || typeof manifest.version !== 'string')
+            return undefined;
+        if (!isPublishedSemver(manifest.version))
+            return undefined;
+        const names = new Set();
+        for (const field of [manifest.dependencies, manifest.optionalDependencies]) {
+            if (field && typeof field === 'object')
+                for (const dep of Object.keys(field))
+                    names.add(dep);
+        }
+        return { dir, name, version: manifest.version, dependencies: [...names].sort() };
+    }
+    catch {
+        // Dangling link, unreadable or corrupt manifest: nothing installed here.
+        return undefined;
+    }
+}
+function sorted(record) {
+    return Object.fromEntries(Object.keys(record)
+        .sort()
+        .map((k) => [k, record[k]]));
+}
+/**
+ * The edges the installed tree under `serviceRoot` resolved, from the stub's
+ * pins outward. A pin not installed at its pinned version starts no walk.
+ */
+export function installedResolutionEdges(serviceRoot, pins) {
+    let root;
+    try {
+        root = fs.realpathSync(path.resolve(serviceRoot));
+    }
+    catch {
+        return { edges: {}, unrecorded: 0 };
+    }
+    const queue = [];
+    const visited = new Set();
+    for (const name of Object.keys(pins).sort()) {
+        const pkg = installedFrom(root, root, name);
+        if (pkg === undefined || pkg.version !== pins[name] || visited.has(pkg.dir))
+            continue;
+        visited.add(pkg.dir);
+        queue.push(pkg);
+    }
+    // parent key -> child -> every version a copy of that parent resolved.
+    const seen = new Map();
+    // Each (parent key, child) a walked package declares, recorded or not.
+    const declared = new Set();
+    for (let i = 0; i < queue.length; i++) {
+        const parent = queue[i];
+        const key = `${parent.name}@${parent.version}`;
+        let children = seen.get(key);
+        if (children === undefined)
+            seen.set(key, (children = new Map()));
+        for (const name of parent.dependencies) {
+            declared.add(`${key}>${name}`);
+            const child = installedFrom(root, parent.dir, name);
+            if (child === undefined)
+                continue;
+            let versions = children.get(name);
+            if (versions === undefined)
+                children.set(name, (versions = new Set()));
+            versions.add(child.version);
+            if (!visited.has(child.dir)) {
+                visited.add(child.dir);
+                queue.push(child);
+            }
+        }
+    }
+    const edges = {};
+    let recorded = 0;
+    for (const [key, children] of seen) {
+        const kept = {};
+        for (const [name, versions] of children) {
+            if (versions.size === 1)
+                kept[name] = [...versions][0];
+        }
+        if (Object.keys(kept).length === 0)
+            continue;
+        edges[key] = sorted(kept);
+        recorded += Object.keys(kept).length;
+    }
+    return { edges: sorted(edges), unrecorded: declared.size - recorded };
+}

package/sidecar/dist/src/capture/status-table.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Response tables keyed by HTTP status code (carrick#1841).
+ *
+ * An object type whose every key is a status code (`{ 200: Item; 404: Problem
+ * }`, or a range key such as `2XX`) is not a body: it is a table of the bodies
+ * each status carries. What a caller receives on success is the union of its
+ * 2xx values. The producer side reads the same rule off a schema object
+ * literal (`successStatusEntry` in the inferrer); this module reads it off a
+ * TYPE, through the compiler's own API, so the inferrer, the v1 bundle and
+ * the capture all decide a table the same way.
+ *
+ * Nothing here names a library or a generator. The shape is the HTTP status
+ * vocabulary, which is the language of the wire, not of any one client.
+ */
+import ts from 'typescript';
+/** `value` when it is an integer in the HTTP status range, else `undefined`. */
+export declare function httpStatus(value: unknown): number | undefined;
+/** One verdict for a set of status codes, or `mixed` when they disagree. */
+export declare function classifyStatusCodes(codes: number[]): 'success' | 'error' | 'redirect' | 'mixed';
+/**
+ * The status code a response-table KEY names: `200`, or a range key (`2XX`,
+ * `2xx`) read as the bottom of its range. Quotes around the key are ignored.
+ * `undefined` for any other key.
+ */
+export declare function statusKeyCode(name: string): number | undefined;
+/** One row of a response table: the key as written and the status it names. */
+export interface StatusTableEntry {
+    symbol: ts.Symbol;
+    /** The key as the type declares it (`200`, `2XX`). */
+    key: string;
+    code: number;
+}
+/**
+ * The rows of `type` when it is a response table: a plain object type with at
+ * least one property, every key a status code, no index signature and no call
+ * or construct signature. `undefined` for anything else, so a payload that
+ * happens to hold one numeric key among others is never read as a table.
+ */
+export declare function statusTableOf(checker: ts.TypeChecker, type: ts.Type): StatusTableEntry[] | undefined;
+/** The rows of a table that answer a success: 2xx, in the order declared. */
+export declare function successEntries(entries: StatusTableEntry[]): StatusTableEntry[];
+/**
+ * Whether a body type states nothing: `void`, `undefined`, `never`, or a union
+ * made only of them. A `204: void` row is such a body.
+ */
+export declare function statesNoBody(type: ts.Type): boolean;
+/**
+ * What a response table's success rows carry, read for a consumer:
+ *  - `body`: the 2xx rows' value types, at least one of which states a body;
+ *  - `no_body`: the table has no 2xx row, or every 2xx row states nothing.
+ * `undefined` when `type` is not a response table.
+ */
+export declare function statusTableBody(checker: ts.TypeChecker, type: ts.Type, at: ts.Node): {
+    kind: 'body';
+    entries: StatusTableEntry[];
+    types: ts.Type[];
+} | {
+    kind: 'no_body';
+    entries: StatusTableEntry[];
+} | undefined;
+/** The members of a union, or the type itself: what a set comparison reads. */
+export declare function constituents(type: ts.Type): ts.Type[];

package/sidecar/dist/src/capture/status-table.js

@@ -0,0 +1,104 @@
+/**
+ * Response tables keyed by HTTP status code (carrick#1841).
+ *
+ * An object type whose every key is a status code (`{ 200: Item; 404: Problem
+ * }`, or a range key such as `2XX`) is not a body: it is a table of the bodies
+ * each status carries. What a caller receives on success is the union of its
+ * 2xx values. The producer side reads the same rule off a schema object
+ * literal (`successStatusEntry` in the inferrer); this module reads it off a
+ * TYPE, through the compiler's own API, so the inferrer, the v1 bundle and
+ * the capture all decide a table the same way.
+ *
+ * Nothing here names a library or a generator. The shape is the HTTP status
+ * vocabulary, which is the language of the wire, not of any one client.
+ */
+import ts from 'typescript';
+/** `value` when it is an integer in the HTTP status range, else `undefined`. */
+export function httpStatus(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 100 && value <= 599
+        ? value
+        : undefined;
+}
+/** One verdict for a set of status codes, or `mixed` when they disagree. */
+export function classifyStatusCodes(codes) {
+    if (codes.every((code) => code >= 400))
+        return 'error';
+    if (codes.every((code) => code >= 300 && code < 400))
+        return 'redirect';
+    if (codes.every((code) => code < 300))
+        return 'success';
+    return 'mixed';
+}
+/**
+ * The status code a response-table KEY names: `200`, or a range key (`2XX`,
+ * `2xx`) read as the bottom of its range. Quotes around the key are ignored.
+ * `undefined` for any other key.
+ */
+export function statusKeyCode(name) {
+    const key = name.replace(/['"`]/g, '').trim();
+    if (/^\d{3}$/.test(key))
+        return httpStatus(Number(key));
+    if (/^[1-5]xx$/i.test(key))
+        return Number(key[0]) * 100;
+    return undefined;
+}
+/**
+ * The rows of `type` when it is a response table: a plain object type with at
+ * least one property, every key a status code, no index signature and no call
+ * or construct signature. `undefined` for anything else, so a payload that
+ * happens to hold one numeric key among others is never read as a table.
+ */
+export function statusTableOf(checker, type) {
+    if (!(type.flags & ts.TypeFlags.Object))
+        return undefined;
+    if (type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0) {
+        return undefined;
+    }
+    if (checker.getIndexInfosOfType(type).length > 0)
+        return undefined;
+    const properties = checker.getPropertiesOfType(type);
+    if (properties.length === 0)
+        return undefined;
+    const entries = [];
+    for (const symbol of properties) {
+        const key = symbol.getName();
+        const code = statusKeyCode(key);
+        if (code === undefined)
+            return undefined;
+        entries.push({ symbol, key, code });
+    }
+    return entries;
+}
+/** The rows of a table that answer a success: 2xx, in the order declared. */
+export function successEntries(entries) {
+    return entries.filter((entry) => entry.code >= 200 && entry.code <= 299);
+}
+/**
+ * Whether a body type states nothing: `void`, `undefined`, `never`, or a union
+ * made only of them. A `204: void` row is such a body.
+ */
+export function statesNoBody(type) {
+    const members = type.isUnion() ? type.types : [type];
+    return members.every((member) => (member.flags & (ts.TypeFlags.Void | ts.TypeFlags.Undefined | ts.TypeFlags.Never)) !== 0);
+}
+/**
+ * What a response table's success rows carry, read for a consumer:
+ *  - `body`: the 2xx rows' value types, at least one of which states a body;
+ *  - `no_body`: the table has no 2xx row, or every 2xx row states nothing.
+ * `undefined` when `type` is not a response table.
+ */
+export function statusTableBody(checker, type, at) {
+    const entries = statusTableOf(checker, type);
+    if (!entries)
+        return undefined;
+    const success = successEntries(entries);
+    const types = success.map((entry) => checker.getTypeOfSymbolAtLocation(entry.symbol, at));
+    if (success.length === 0 || types.every((body) => statesNoBody(body))) {
+        return { kind: 'no_body', entries };
+    }
+    return { kind: 'body', entries: success, types };
+}
+/** The members of a union, or the type itself: what a set comparison reads. */
+export function constituents(type) {
+    return type.isUnion() ? type.types : [type];
+}

package/sidecar/dist/src/failure-path.d.ts

@@ -27,7 +27,7 @@
  * the other way round: after `if (res.status === 204) return null`, 200 still
  * gets through, and the json read that follows is the payload.
  */
-import { Node } from 'ts-morph';
+import { Node, type CaseOrDefaultClause, type SwitchStatement } from 'ts-morph';
 /** A set of HTTP statuses, as the predicate that admits them. */
 export type Statuses = (status: number) => boolean;
 /** The statuses `ok` is true for. */
@@ -60,8 +60,48 @@ export declare function reachedOnlyOnFailure(node: Node, boundary: Node, isRespo
  * an `if` or a conditional expression it sits in, or an earlier `if` in an
  * enclosing block one of whose branches cannot complete, which leaves the
  * rest of the block to the other side. A test that does not read the
- * response's `ok` or `status` is not listed.
+ * response's `ok` or `status` is not listed. A `switch` is not read here:
+ * `retype.ts` finds one by its own climb.
  */
 export declare function testsOnPath(node: Node, boundary: Node | undefined, isResponse: (node: Node) => boolean): SideTaken[];
+/**
+ * One test on the path to a node, as the side the node is on. `test` is the
+ * statement or expression that tests, so two nodes under the same test share
+ * it.
+ *
+ *  - `branch`: an `if` or a conditional expression, and whether the node is
+ *    on its true side: the branch the node sits in or, for an earlier `if` in
+ *    an enclosing block one of whose branches cannot complete, the side that
+ *    did not leave.
+ *  - `clause`: the node sits in this clause of a `switch`.
+ *  - `after-switch`: the node follows a `switch` in an enclosing block.
+ */
+export type PathStep = {
+    kind: 'branch';
+    test: Node;
+    condition: Node;
+    whenTrue: boolean;
+} | {
+    kind: 'clause';
+    test: SwitchStatement;
+    clause: CaseOrDefaultClause;
+} | {
+    kind: 'after-switch';
+    test: SwitchStatement;
+};
+/**
+ * Every test on the path from `node` up to `boundary` (the whole file when it
+ * is `undefined`), whatever it reads, innermost first. `testsOnPath` reads
+ * the branches as statuses; `response-modes.ts` reads branches and switches
+ * as values of a request field (carrick#2054).
+ */
+export declare function stepsOnPath(node: Node, boundary: Node | undefined): PathStep[];
 /** `node` reads the response's `ok` or `status`, itself or anywhere inside it. */
 export declare function readsResponseStatus(node: Node, isResponse: (node: Node) => boolean): boolean;
+/**
+ * A statement that never runs on into the statement after it: it returns,
+ * throws, breaks or continues, or every path through it does. A loop, a
+ * `switch` or a `try` is read as one that can complete, which only ever
+ * leaves a read on the path it was on.
+ */
+export declare function cannotComplete(statement: Node): boolean;

package/sidecar/dist/src/failure-path.js

@@ -64,30 +64,51 @@ export function reachedOnlyOnFailure(node, boundary, isResponse) {
  * an `if` or a conditional expression it sits in, or an earlier `if` in an
  * enclosing block one of whose branches cannot complete, which leaves the
  * rest of the block to the other side. A test that does not read the
- * response's `ok` or `status` is not listed.
+ * response's `ok` or `status` is not listed. A `switch` is not read here:
+ * `retype.ts` finds one by its own climb.
  */
 export function testsOnPath(node, boundary, isResponse) {
     const sides = [];
-    const take = (test, whenTrue) => {
+    for (const step of stepsOnPath(node, boundary)) {
+        if (step.kind !== 'branch')
+            continue;
+        const test = readTest(step.condition, isResponse);
         if (test === UNRELATED)
-            return;
-        sides.push({ admits: whenTrue ? test.whenTrue : test.whenFalse, inexact: test.inexact });
-    };
+            continue;
+        sides.push({ admits: step.whenTrue ? test.whenTrue : test.whenFalse, inexact: test.inexact });
+    }
+    return sides;
+}
+/**
+ * Every test on the path from `node` up to `boundary` (the whole file when it
+ * is `undefined`), whatever it reads, innermost first. `testsOnPath` reads
+ * the branches as statuses; `response-modes.ts` reads branches and switches
+ * as values of a request field (carrick#2054).
+ */
+export function stepsOnPath(node, boundary) {
+    const steps = [];
+    const branch = (test, condition, whenTrue) => steps.push({ kind: 'branch', test, condition, whenTrue });
     for (let child = node, parent = node.getParent(); parent && parent !== boundary; child = parent, parent = parent.getParent()) {
         if (Node.isIfStatement(parent)) {
             if (child === parent.getThenStatement()) {
-                take(readTest(parent.getExpression(), isResponse), true);
+                branch(parent, parent.getExpression(), true);
             }
             else if (child === parent.getElseStatement()) {
-                take(readTest(parent.getExpression(), isResponse), false);
+                branch(parent, parent.getExpression(), false);
             }
         }
         else if (Node.isConditionalExpression(parent)) {
             if (child === parent.getWhenTrue()) {
-                take(readTest(parent.getCondition(), isResponse), true);
+                branch(parent, parent.getCondition(), true);
             }
             else if (child === parent.getWhenFalse()) {
-                take(readTest(parent.getCondition(), isResponse), false);
+                branch(parent, parent.getCondition(), false);
+            }
+        }
+        else if (Node.isCaseClause(parent) || Node.isDefaultClause(parent)) {
+            const statement = parent.getParent()?.getParent();
+            if (statement && Node.isSwitchStatement(statement)) {
+                steps.push({ kind: 'clause', test: statement, clause: parent });
             }
         }
         if (Node.isBlock(parent) ||
@@ -97,21 +118,25 @@ export function testsOnPath(node, boundary, isResponse) {
             for (const statement of parent.getStatements()) {
                 if (statement === child)
                     break;
+                if (Node.isSwitchStatement(statement)) {
+                    steps.push({ kind: 'after-switch', test: statement });
+                    continue;
+                }
                 if (!Node.isIfStatement(statement))
                     continue;
                 const otherwise = statement.getElseStatement();
                 const thenLeaves = cannotComplete(statement.getThenStatement());
                 const elseLeaves = otherwise !== undefined && cannotComplete(otherwise);
                 if (thenLeaves && !elseLeaves) {
-                    take(readTest(statement.getExpression(), isResponse), false);
+                    branch(statement, statement.getExpression(), false);
                 }
                 else if (elseLeaves && !thenLeaves) {
-                    take(readTest(statement.getExpression(), isResponse), true);
+                    branch(statement, statement.getExpression(), true);
                 }
             }
         }
     }
-    return sides;
+    return steps;
 }
 /** The statuses `condition` lets through when it is true and when it is false. */
 function readTest(condition, isResponse) {
@@ -216,7 +241,7 @@ export function readsResponseStatus(node, isResponse) {
  * `switch` or a `try` is read as one that can complete, which only ever
  * leaves a read on the path it was on.
  */
-function cannotComplete(statement) {
+export function cannotComplete(statement) {
     if (Node.isReturnStatement(statement) ||
         Node.isThrowStatement(statement) ||
         Node.isBreakStatement(statement) ||

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

@@ -2584,6 +2584,8 @@ class DeclarationReader {
      * repository checked out under a `node_modules` ancestor, is not installed.
      * An install hoisted above the service root (`../../node_modules/pkg`) and
      * a pnpm store (`node_modules/.pnpm/pkg@1/node_modules/pkg`) are.
+     * Mirrored by `installedPackageDirectory` in capture/, which the capture
+     * seam keeps from being shared.
      */
     installedPackage(fileName) {
         const segments = path.relative(this.root, this.realpath(fileName)).split(path.sep);

package/sidecar/dist/src/line-index.d.ts

@@ -1,3 +1,4 @@
+import type { Node } from 'ts-morph';
 /**
  * The 1-based line of a position in a text, counted by line feeds alone: one
  * more than the `\n`s before the position. That is the count ts-morph's
@@ -7,3 +8,11 @@
  * The text is read once; each lookup after that is a binary search.
  */
 export declare function lineIndex(text: string): (pos: number) => number;
+/**
+ * `node.getStartLineNumber()` from a per-file index. ts-morph counts the
+ * file's line feeds from position 0 on every call, so a walk that asks of
+ * every node of a file pays the file's size once per node (carrick#1935).
+ */
+export declare function startLineOf(node: Node): number;
+/** `node.getEndLineNumber()` from the same per-file index. */
+export declare function endLineOf(node: Node): number;

package/sidecar/dist/src/line-index.js

@@ -24,3 +24,27 @@ export function lineIndex(text) {
         return lo + 1;
     };
 }
+const fileLineIndexes = new WeakMap();
+function lineAtIn(node, pos) {
+    // Keyed on the compiler node: a manipulation (`replaceWithText`, a retype)
+    // gives the file a new one, so the index is built again from the new text.
+    const key = node.getSourceFile().compilerNode;
+    let lineAt = fileLineIndexes.get(key);
+    if (!lineAt) {
+        lineAt = lineIndex(key.text);
+        fileLineIndexes.set(key, lineAt);
+    }
+    return lineAt(pos);
+}
+/**
+ * `node.getStartLineNumber()` from a per-file index. ts-morph counts the
+ * file's line feeds from position 0 on every call, so a walk that asks of
+ * every node of a file pays the file's size once per node (carrick#1935).
+ */
+export function startLineOf(node) {
+    return lineAtIn(node, node.getStart());
+}
+/** `node.getEndLineNumber()` from the same per-file index. */
+export function endLineOf(node) {
+    return lineAtIn(node, node.getEnd());
+}