@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/dist/src/session.js

@@ -1,8 +1,18 @@
 import { API, SymbolFlags } from "@typescript/native/sync";
 import { componentLayer, mapperManifest } from "./component-layer.js";
-import { DiscoveryError } from "./discover.js";
 import { joinPath } from "./paths.js";
 import { queriesOf, UnansweredLog, } from "./query.js";
+import { MANIFEST } from "./fs/manifest.js";
+/** The most questions one round trip carries. */
+const BATCH = 2048;
+/** Asks one question of every item, in round trips of at most {@link BATCH}, answers in order. */
+export function batched(engine, items, question) {
+    const answers = [];
+    for (let at = 0; at < items.length; at += BATCH) {
+        answers.push(...engine.batch(items.slice(at, at + BATCH).map(question)));
+    }
+    return answers;
+}
 /**
  * Opens the compiler client the analysis reads through.
  *
@@ -16,7 +26,7 @@ export function openEngine(options) {
     if (components !== undefined && components.extensions.length > 0) {
         const made = components.host.temporaryDirectory();
         try {
-            components.host.writeDocument(joinPath(made.path, "package.json"), [
+            components.host.writeDocument(joinPath(made.path, MANIFEST), [
                 mapperManifest(components.host.componentMapperCommand()),
             ]);
         }
@@ -128,6 +138,9 @@ function viewOf(project, configFile, engine, log) {
             ownKeys ??= new Set(ownSourceFiles().map((file) => file.path));
             return ownKeys;
         },
+        resolvedFileNames: (specifiers) => batched(engine, specifiers, (node) => project.program.getResolvedModuleFromModuleSpecifier.gen(node, node.getSourceFile().fileName)).map((resolved) => resolved === undefined || resolved.resolvedFileName === ""
+            ? undefined
+            : resolved.resolvedFileName),
         handle: (node) => ({ node }),
         symbolsAt: (handles, cap) => queries.symbolsAt(handles.map(({ node }) => node), cap),
         resolvedSymbolAt: ({ node }) => queries.resolvedSymbol(node),
@@ -252,14 +265,13 @@ function projectsOf(snapshot, built, written) {
     return opened;
 }
 /**
- * Runs `visit` over every project the compiler configurations name, inside one never updated
- * snapshot of one client, and answers in their order. A configuration `programs` describes is
- * built as that program, or opened from the configuration it writes. One the snapshot holds
- * nothing for ends the run under `"refuse"` and is named in the result under `"record"`.
- * `first` runs over every opened project before the first visit and `last` after the last,
- * both while the client answers; the snapshot and the client are then released.
+ * Opens every project the compiler configurations name in one never updated snapshot of one
+ * client, and hands them to `use` while the client answers; the snapshot and the client are
+ * then released. A configuration `options.programs` describes is built as that program, or
+ * opened from the configuration it writes. One the snapshot holds nothing for has no view.
  */
-export function runSession(engine, configFiles, visit, unopened = "refuse", programs = new Map(), last = () => undefined, first = () => undefined) {
+export function openSession(engine, configFiles, options, use) {
+    const programs = options.programs ?? new Map();
     try {
         const built = [];
         const params = [];
@@ -281,30 +293,13 @@ export function runSession(engine, configFiles, visit, unopened = "refuse", prog
             const opened = projectsOf(snapshot, built, written);
             const log = new UnansweredLog();
             const views = [];
-            const missing = [];
             for (const configFile of configFiles) {
                 const project = opened.get(configFile);
-                if (project === undefined) {
-                    if (unopened === "refuse") {
-                        throw new DiscoveryError(`${configFile} opened no project`, []);
-                    }
-                    missing.push(configFile);
-                    continue;
+                if (project !== undefined) {
+                    views.push(viewOf(project, configFile, engine, log));
                 }
-                views.push(viewOf(project, configFile, engine, log));
             }
-            first(views.map((view) => ({
-                configFile: view.configFile,
-                fileNames: () => view.ownSourceFiles().map((file) => file.fileName),
-            })));
-            const projects = views.map((view) => visit(view));
-            last();
-            return {
-                projects,
-                unopened: missing,
-                timing: engine.getTimingInfo(),
-                unanswered: log.questions,
-            };
+            return use({ views }, () => log.questions);
         }
         finally {
             snapshot.dispose();
@@ -314,3 +309,16 @@ export function runSession(engine, configFiles, visit, unopened = "refuse", prog
         engine.close();
     }
 }
+/**
+ * Runs `visit` over the project {@link openSession} opens for each configuration, and answers
+ * in their order; a configuration the snapshot opens nothing for throws before any visit.
+ */
+export function runSession(engine, configFiles, visit) {
+    return openSession(engine, configFiles, {}, (opened) => {
+        const unopened = configFiles.find((configFile) => !opened.views.some((view) => view.configFile === configFile));
+        if (unopened !== undefined) {
+            throw new Error(`${unopened} opened no project`);
+        }
+        return { projects: opened.views.map((view) => visit(view)), timing: engine.getTimingInfo() };
+    });
+}

package/dist/src/source-files.js

@@ -3,14 +3,13 @@
  * in a document or a string names one: as the file itself, or as a file the
  * compiler emits from it.
  */
-import { commonDirectory, emittedFrom } from "./emit-map.js";
+import { commonDirectory, emittedFrom } from "./load/emit-map.js";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { OUTPUT_EXTENSIONS } from "./extensions.js";
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";
 /** The extension a source file's name drops when the project writes it out. */
 const SOURCE_EXTENSION = /\.[cm]?[jt]sx?$/u;
-/** The extensions the project may write a source file's output under. */
-const OUTPUT_EXTENSIONS = [".js", ".mjs", ".cjs", ".jsx", ".d.ts", ".d.mts", ".d.cts"];
 /**
  * Whether one path is what a subpath pattern stands for: the text before the
  * wildcard, any run of characters including the solidus, then the text after it.
@@ -43,13 +42,10 @@ function layoutOf(project, fileNames) {
     };
 }
 /**
- * The lookups over one project's own files.
- *
- * A path that names an emitted file is read back to the source the project would
- * emit it from through the project's own emit mapping and nothing else: the
- * extension is one the compiler emits from a source extension, and a path below the
- * output directory is read below the directory the compiler emits from, which the
- * configuration declares or which is the directory every input file shares.
+ * The lookups over one project's own files. A path naming an emitted file is read back to its
+ * source through the project's own emit mapping alone: the extension is one the compiler emits
+ * from a source extension, and a path below the output directory is read below the directory
+ * the compiler emits from, which the configuration declares or every input file shares.
  */
 export function sourceFilesOf(project, targetRoot) {
     const byName = new Map();

package/dist/src/stores.js

@@ -5,6 +5,7 @@
  */
 import { isGetAccessorDeclaration, isSetAccessorDeclaration, } from "@typescript/native/ast";
 import { nodeKey } from "./inventory.js";
+import { classedAsTest, madeByTestCode, withheldBy } from "./tests/file-class.js";
 /** The class members one project's own files declare by a getter or a setter. */
 export function accessorsOf(project, held) {
     const found = [];
@@ -25,9 +26,10 @@ export function accessorsOf(project, held) {
 /** The run's stores, from what each configuration contributed, the records and the mode. */
 export function storesOf(per, exempt, mode) {
     return {
-        references: per.flatMap((one) => one.references.filter((reference) => !mode.production || !reference.test)),
+        references: per.flatMap((one) => one.references.filter((reference) => !withheldBy(mode, reference, one.support))),
         readInTests: new Set(per.flatMap((one) => one.references
-            .filter((reference) => reference.test && reference.use !== "write")
+            .filter((reference) => reference.use !== "write" &&
+            classedAsTest(madeByTestCode(reference, one.support), reference.consumer !== undefined, mode))
             .map((reference) => reference.to))),
         accessors: new Set(per.flatMap((one) => one.accessors)),
         exempt: new Set(exempt.map((record) => record.id)),

package/dist/src/suppress-file.js

@@ -4,11 +4,13 @@
  * one record shape, so one decoder and one matcher serve both, and a row moves into the
  * ignore file by gaining a maintainer's reason.
  */
+import { CODE } from "./contract/contract.generated.js";
+import { readTargetDocument } from "./fs/document.js";
 import { jsonChunks } from "./json-chunks.js";
-import { joinPath } from "./paths.js";
-import { positionAt, walkDocument } from "./json-document.js";
+import { isRecord, positionAt, readStrict, StrictJSONError } from "./json-document.js";
 import { declarationKey } from "./ref.js";
-import { CODE_FORM, SUPPRESSION_WITHOUT_REASON, SuppressionError, UNSCOPED_ENTRY, blankReason, isEntryPath, isPartKind, isSymbolRef, siteText, } from "./suppress.js";
+import { CODE_FORM, SuppressionError, blankReason, isEntryPath, isPartKind, isSymbolRef, siteText, } from "./suppress.js";
+import { message } from "./product.js";
 /** The name and the location the grammar fixes for the ignore file. */
 export const IGNORE_FILE = "deadset-ignore.json";
 /** The name and the location the grammar fixes for the baseline. */
@@ -42,9 +44,6 @@ const PATH_WANT = "a path relative to the target root, with the solidus as separ
 function documentSite(shape) {
     return { path: shape.file, line: 0, column: 0 };
 }
-function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 /**
  * Reads one entry or row: the records it binds, the refusals it carries, or the
  * malformed value that ends the run.
@@ -53,7 +52,7 @@ function readRecord(value, site, byReference, shape) {
     const refuse = (text, want) => {
         throw new SuppressionError(shape.mechanism, siteText(site), text, want);
     };
-    if (!isObject(value)) {
+    if (!isRecord(value)) {
         return refuse(JSON.stringify(value), shape.recordWant);
     }
     for (const [key, held] of Object.entries(value)) {
@@ -99,10 +98,10 @@ function readRecord(value, site, byReference, shape) {
     };
     const refusals = [];
     if (blankReason(reason)) {
-        refusals.push({ ...written, reported: SUPPRESSION_WITHOUT_REASON });
+        refusals.push({ ...written, reported: CODE.suppressionWithoutReason });
     }
     if (written.path === "") {
-        refusals.push({ ...written, reported: UNSCOPED_ENTRY });
+        refusals.push({ ...written, reported: CODE.unscopedIgnoreEntry });
     }
     if (refusals.length > 0) {
         return { records: [], refusals };
@@ -131,28 +130,27 @@ function byReferenceOf(symbols) {
 }
 /** Reads one document at the target root, binding each record against the run's declarations. */
 function readDocument(host, targetRoot, symbols, shape) {
-    const file = joinPath(targetRoot, shape.file);
-    if (host.kindOf(file) === "absent") {
+    const text = readTargetDocument(host, targetRoot, shape.file);
+    if (text === undefined) {
         return { records: [], refusals: [] };
     }
-    const text = host.readFile(file);
     const malformed = (detail, site = documentSite(shape)) => {
         throw new SuppressionError(shape.mechanism, siteText(site), detail, shape.documentWant);
     };
-    let parsed;
+    let document;
     try {
-        parsed = JSON.parse(text);
+        document = readStrict(text, shape.array);
     }
     catch (error) {
-        return malformed(`${shape.file}: ${error instanceof Error ? error.message : String(error)}`);
+        if (!(error instanceof StrictJSONError)) {
+            throw error;
+        }
+        return malformed(error.message, positionAt(text, shape.file, error.offset));
     }
-    if (!isObject(parsed)) {
+    const parsed = document.value;
+    if (!isRecord(parsed)) {
         return malformed(shape.file);
     }
-    const walk = walkDocument(text, shape.array);
-    if (walk.twice !== undefined) {
-        malformed(`the member ${JSON.stringify(walk.twice.name)} is written twice, so neither value is chosen`, positionAt(text, shape.file, walk.twice.offset));
-    }
     for (const key of Object.keys(parsed)) {
         if (key !== "description" && key !== shape.array) {
             malformed(`the member ${JSON.stringify(key)} is not one the grammar declares`);
@@ -167,7 +165,7 @@ function readDocument(host, targetRoot, symbols, shape) {
     const records = [];
     const refusals = [];
     held.forEach((value, index) => {
-        const offset = walk.starts[index];
+        const offset = document.starts.get(index);
         const site = offset === undefined ? documentSite(shape) : positionAt(text, shape.file, offset);
         const read = readRecord(value, site, byReference, shape);
         records.push(...read.records);
@@ -227,9 +225,9 @@ export function otherSchemeRows(text, own = OWN_SCHEME) {
         parsed = JSON.parse(text);
     }
     catch (error) {
-        return refuse(error instanceof Error ? error.message : String(error));
+        return refuse(message(error));
     }
-    const held = isObject(parsed) ? parsed[BASELINE_SHAPE.array] : undefined;
+    const held = isRecord(parsed) ? parsed[BASELINE_SHAPE.array] : undefined;
     if (!Array.isArray(held)) {
         return refuse(BASELINE_SHAPE.documentWant);
     }
@@ -238,7 +236,7 @@ export function otherSchemeRows(text, own = OWN_SCHEME) {
             readRecord(value, documentSite(BASELINE_SHAPE), new Map(), BASELINE_SHAPE);
         }
         catch (error) {
-            return refuse(error instanceof Error ? error.message : String(error));
+            return refuse(message(error));
         }
         // readRecord has checked every member is a string and the code and symbol are present.
         const { code, symbol, path, reason } = value;
@@ -279,10 +277,9 @@ function* separatorsEscaped(pieces) {
  * A baseline holding one row per finding, in the order given, which is the report's, and
  * the other language's rows `kept`, Go's rows ahead of TypeScript's and each scheme's in
  * the order given, so two analyzers writing one document in either order write the same
- * bytes, in the form grammar/suppression.md fixes. Every recorded row carries the
- * provenance as its reason. A finding
- * missing a value a row needs, and an identity missing its name or version, are refused
- * rather than written, because the grammar requires a reason on every row.
+ * bytes, in the form grammar/suppression.md fixes. Every row carries the provenance as
+ * its reason, so a finding missing a value a row needs, or an identity missing its name
+ * or version, is refused rather than written.
  */
 export function writeBaseline(findings, provenance, kept = []) {
     if (provenance.analyzer === "" || provenance.version === "") {

package/dist/src/suppress-inline.js

@@ -3,13 +3,14 @@
  * one or more codes and a reason, and binding to every declaration that begins on the line
  * below it, or on its own line where it trails a token there.
  */
-import { isConstructorDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { CODE } from "./contract/contract.generated.js";
+import { SyntaxKind } from "@typescript/native/ast";
 import { importBindings } from "./import-bindings.js";
-import { isParameterProperty, nodeKey } from "./inventory.js";
-import { byPosition, positionKey, renderPosition } from "./position.js";
+import { nodeKey } from "./inventory.js";
+import { relativePath } from "./paths.js";
+import { byPosition, lineEnd, positionKey, renderPosition, startLine, tokenStart, } from "./position.js";
 import { importRef } from "./ref.js";
-import { signatureOf } from "./signatures.js";
-import { isPartKind, SUPPRESSION_WITHOUT_REASON, SuppressionError, siteText, } from "./suppress.js";
+import { isPartKind, SuppressionError, siteText, } from "./suppress.js";
 /**
  * The three expressions the grammar applies to the text of each line comment, in this
  * order: a comment in the namespace, a well-formed directive, and a directive that lacks
@@ -54,43 +55,6 @@ const LITERALS = new Set([
     SyntaxKind.RegularExpressionLiteral,
     SyntaxKind.JsxText,
 ]);
-/** Whether one character ends a line, under the language's line terminators. */
-function endsLine(char) {
-    return char === "\n" || char === "\r" || char === "\u2028" || char === "\u2029";
-}
-/** The offset where the line holding `from` ends. */
-function lineEnd(text, from) {
-    let at = from;
-    while (at < text.length && !endsLine(text[at])) {
-        at += 1;
-    }
-    return at;
-}
-/**
- * The offset of the first token at or after `from`: whitespace, comments and a leading
- * hashbang are trivia.
- */
-export function tokenStart(text, from) {
-    let at = from;
-    if (at === 0 && text.startsWith("#!")) {
-        at = lineEnd(text, 0);
-    }
-    for (;;) {
-        if (/\s/u.test(text[at] ?? "")) {
-            at += 1;
-        }
-        else if (text.startsWith("//", at)) {
-            at = lineEnd(text, at);
-        }
-        else if (text.startsWith("/*", at)) {
-            const close = text.indexOf("*/", at + 2);
-            at = close < 0 ? text.length : close + 2;
-        }
-        else {
-            return at;
-        }
-    }
-}
 /**
  * Every `//` line comment of one file, in file order. The text between tokens is read as
  * the language reads it: a block comment holds no line comment, and the literal tokens the
@@ -139,55 +103,42 @@ function lineComments(file) {
 function bindingKey(one) {
     return `${one.declared?.id ?? ""}\u0000${one.part.id}`;
 }
+/** The placed declarations of a project by the path of the file each is in. */
+function placedByPath(held, symbols) {
+    const byPath = new Map();
+    for (const [id, placed] of held.placement) {
+        const one = symbols.get(id);
+        const holder = symbols.get(placed.holder);
+        if (one === undefined || holder === undefined) {
+            continue;
+        }
+        const at = byPath.get(one.position.path) ?? [];
+        at.push({ one, holder, startLines: placed.startLines, partLines: placed.partLines });
+        byPath.set(one.position.path, at);
+    }
+    return byPath;
+}
 /**
- * The declarations of one file by the line each begins on, the line of its first token: a
- * decorator, a modifier or the keyword. A variable's first token is its statement's
- * keyword, and a variable written on a later line of the statement also begins there. A
- * function also begins, for a directive, on the line of each of its parameters, and a
- * class, for a part kind, on the lines of its constructor and its constructor's parameters.
+ * The declarations of one file by the line a directive binds each on, as the inventory
+ * places them, and each import binding of the file on its statement's lines.
  */
-function declarationLines(file, held, symbols, targetRoot) {
+function declarationLines(file, placed, held, targetRoot) {
     const below = new Map();
-    const add = (offset, one) => {
-        const line = file.getLineAndCharacterOfPosition(tokenStart(file.text, offset)).line + 1;
+    const add = (line, one) => {
         const at = below.get(line) ?? [];
         if (!at.some((known) => bindingKey(known) === bindingKey(one))) {
             at.push(one);
         }
         below.set(line, at);
     };
-    const declaredAt = (node) => {
-        const id = held.declarations.get(nodeKey(file, node));
-        return id === undefined ? undefined : symbols.get(id);
-    };
-    const visit = (node) => {
-        const one = declaredAt(node);
-        const owner = isConstructorDeclaration(node) ? declaredAt(node.parent) : undefined;
-        if (owner !== undefined && isConstructorDeclaration(node)) {
-            for (const at of [node, ...node.parameters.filter((one) => !isParameterProperty(one))]) {
-                add(at.pos, { declared: undefined, part: owner });
-            }
-        }
-        const holder = one !== undefined && isParameterProperty(node) ? declaredAt(node.parent.parent) : one;
-        if (one !== undefined && holder !== undefined) {
-            add(node.pos, { declared: one, part: holder });
+    for (const { one, holder, startLines, partLines } of placed) {
+        for (const line of startLines) {
+            add(line, { declared: one, part: holder });
         }
-        if (one !== undefined) {
-            // A parameter on a later line of a wrapped signature takes its directive on the
-            // line above it, inside the parameter list, and the directive binds the function.
-            for (const parameter of signatureOf(node)?.parameters ?? []) {
-                add(parameter.pos, { declared: one, part: one });
-            }
-            const list = node.parent;
-            if (node.kind === SyntaxKind.VariableDeclaration &&
-                list.kind === SyntaxKind.VariableDeclarationList &&
-                list.parent.kind === SyntaxKind.VariableStatement) {
-                add(list.parent.pos, { declared: one, part: one });
-            }
+        for (const line of partLines) {
+            add(line, { declared: undefined, part: one });
         }
-        node.forEachChild(visit);
-    };
-    file.forEachChild(visit);
+    }
     // An import binding is a subject of its own, bound on its line as a declaration is.
     const fileId = held.declarations.get(nodeKey(file, file));
     const moduleRef = held.symbols.find((symbol) => symbol.id === fileId)?.ref ?? "";
@@ -199,7 +150,7 @@ function declarationLines(file, held, symbols, targetRoot) {
             statement = statement.parent;
         }
         for (const at of [statement.pos, name.getStart()]) {
-            add(at, { declared: one, part: one });
+            add(startLine(file, at), { declared: one, part: one });
         }
     }
     return below;
@@ -220,13 +171,15 @@ export function inlineDirectives(project, held, targetRoot) {
     const symbols = new Map(held.symbols
         .filter((symbol) => symbol.kind !== "file")
         .map((symbol) => [symbol.id, { id: symbol.id, ref: symbol.ref, position: symbol.position }]));
+    const placed = placedByPath(held, symbols);
     const found = [];
     for (const file of project.ownSourceFiles()) {
         const comments = lineComments(file).filter((comment) => CANDIDATE.test(comment.text));
         if (comments.length === 0) {
             continue;
         }
-        const below = declarationLines(file, held, symbols, targetRoot);
+        const path = relativePath(targetRoot, file.fileName) ?? "";
+        const below = declarationLines(file, placed.get(path) ?? [], held, targetRoot);
         for (const comment of comments) {
             const site = renderPosition(file, targetRoot, comment.offset);
             const target = trails(file, comment.offset) ? site.line : site.line + 1;
@@ -274,7 +227,7 @@ export function inlineSuppressions(perProject) {
             case "no-reason":
                 for (const code of directive.codes) {
                     refusals.push({
-                        reported: SUPPRESSION_WITHOUT_REASON,
+                        reported: CODE.suppressionWithoutReason,
                         code,
                         symbol: "",
                         path: site.path,