@cplieger/deadset-ts 8.0.0-dev.7 → 8.0.0-dev.9

package/dist/src/scope.js

@@ -1,149 +1,73 @@
-import { ConfigError } from "./config.js";
+import { SCOPE_SCHEMA } from "./contract/config.generated.js";
+import { dotted, locatedFault, placeIn, readStrict, StrictJSONError } from "./json-document.js";
 import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.js";
-import { checkDocument } from "./schema.js";
-import { isRecord } from "./json-document.js";
+import { MARKERS } from "./load/discover.js";
+import { failureExit } from "./failure.js";
 import { message } from "./product.js";
-/** The roles a scope document declares for a module. */
-const ROLE_TARGET = "target";
-const ROLE_CONSUMER = "consumer";
+import { firstRefusal } from "./schema.js";
+import { UsageError } from "./usage.js";
 /**
  * A scope document above this length is refused rather than decoded. It names one
  * target and its consumers, so a larger file is not one.
  */
 const MAX_DOCUMENT_LENGTH = 1 << 20;
 /**
- * A scope document that cannot be read as one. It ends the run with the failure
- * code: the run could not learn what to analyze, so it produced no answer.
+ * The bytes read of a scope document. A UTF-16 unit decodes from at most three bytes,
+ * so a document past the bound is past it within these.
  */
-export class ScopeError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "ScopeError";
-    }
+const MAX_DOCUMENT_BYTES = 3 * (MAX_DOCUMENT_LENGTH + 1);
+function refusal(file, place, reason) {
+    return new UsageError(`scope: ${file}: ${place === "" ? "" : `${place}: `}${reason}`);
 }
-const MODULE = {
-    kind: "section",
-    members: { id: { kind: "leaf" }, role: { kind: "leaf" }, path: { kind: "leaf" } },
-};
-/** The closed key list of the scope document, compared as bytes. */
-const SCOPE_ROOT = {
-    kind: "section",
-    members: {
-        target: MODULE,
-        workspace: { kind: "leaf" },
-        consumers: { kind: "list", members: MODULE.members ?? {} },
-    },
-};
 /**
- * One string member, or undefined where the document omits it. A member the
- * document writes is a string holding at least one character, so `null` and `""`
- * are refused rather than read as absent.
- */
-function stringMember(parent, name, at) {
-    if (!Object.hasOwn(parent, name)) {
-        return undefined;
-    }
-    const value = parent[name];
-    if (typeof value !== "string") {
-        throw new ScopeError(`scope: ${at === "" ? name : `${at}.${name}`} is not a string`);
-    }
-    if (value === "") {
-        throw new ScopeError(`scope: ${at === "" ? name : `${at}.${name}`} names nothing`);
-    }
-    return value;
-}
-function readModule(value, at, role, documentDir) {
-    if (!isRecord(value)) {
-        throw new ScopeError(`scope: ${at} is not an object`);
-    }
-    const declared = stringMember(value, "role", at);
-    if (declared !== undefined && declared !== role) {
-        throw new ScopeError(`scope: ${at}.role is ${JSON.stringify(declared)}, want ${JSON.stringify(role)}`);
-    }
-    const path = stringMember(value, "path", at);
-    if (path === undefined) {
-        throw new ScopeError(`scope: ${at}.path names nothing`);
-    }
-    return {
-        id: stringMember(value, "id", at) ?? "",
-        path: isAbsolutePath(path) ? path : joinPath(documentDir, path),
-    };
-}
-/**
- * Walks the document's text against the closed key list, refusing a key the list
- * does not declare, compared as bytes, and a key one object writes twice, which a
- * parse cannot report because it keeps the last value.
- */
-function checkKeys(text, file) {
-    try {
-        checkDocument(text, SCOPE_ROOT, `scope: ${file}`);
-    }
-    catch (error) {
-        if (error instanceof ConfigError) {
-            // The configuration's refusal names the nearest configuration key, which a
-            // scope document does not have.
-            throw new ScopeError(error.kind === "unimplemented-key"
-                ? `scope: ${file}: ${error.key} is not a declared key`
-                : error.message);
-        }
-        throw error;
-    }
-}
-/**
- * Decodes the scope document at `file`. Decoding is strict: an undeclared key, a
- * key written twice in one object, and a value of a type the document does not
- * admit, `null` included, are errors, and a relative path inside the document
- * resolves against the document's own directory.
- *
- * The `workspace` key the format declares is checked and carries nothing here: it
- * names the file a Go consumer resolves the target through, and a TypeScript
- * project resolves one through its own compiler configuration.
+ * Decodes the scope document at `file`, held to the Contract's scope schema, a relative
+ * path resolved against the document's own directory. A document that cannot be read or is
+ * refused is a usage error, as any document the invocation names. `workspace` is read by Go consumers
+ * alone: a TypeScript project resolves the target through its own compiler configuration.
  */
 export function readScope(host, file) {
     const absolute = resolvePath(host.workingDirectory(), file);
     let text;
     try {
-        text = host.readFile(absolute);
+        text = host.readFile(absolute, MAX_DOCUMENT_BYTES);
     }
     catch (error) {
-        throw new ScopeError(`scope: ${file}: ${message(error)}`);
+        throw new UsageError(`scope: ${file}: ${message(error)}`);
     }
     if (text.length > MAX_DOCUMENT_LENGTH) {
-        throw new ScopeError(`scope: ${file} is longer than ${String(MAX_DOCUMENT_LENGTH)} characters`);
+        throw new UsageError(`scope: ${file} is longer than ${String(MAX_DOCUMENT_LENGTH)} characters`);
     }
     let value;
     try {
-        value = JSON.parse(text);
+        value = readStrict(text).value;
     }
     catch (error) {
-        throw new ScopeError(`scope: ${file}: ${message(error)}`);
+        if (!(error instanceof StrictJSONError)) {
+            throw error;
+        }
+        throw refusal(file, dotted(error.place), locatedFault(text, error));
     }
-    if (!isRecord(value)) {
-        throw new ScopeError(`scope: ${file} is not one JSON object`);
+    const refused = firstRefusal(SCOPE_SCHEMA, value);
+    if (refused !== undefined) {
+        throw refusal(file, dotted(placeIn(value, refused.pointer, refused.member)), refused.reason);
     }
-    checkKeys(text, file);
-    stringMember(value, "workspace", "");
+    const declared = value;
     const documentDir = dirnamePath(absolute);
-    if (!Object.hasOwn(value, "target")) {
-        throw new ScopeError(`scope: ${file} names no target`);
-    }
-    const target = readModule(value["target"], "target", ROLE_TARGET, documentDir);
-    const listed = Object.hasOwn(value, "consumers") ? value["consumers"] : [];
-    if (!Array.isArray(listed)) {
-        throw new ScopeError(`scope: ${file}: consumers is not an array`);
-    }
-    const consumers = listed.map((entry, index) => readModule(entry, `consumers[${String(index)}]`, ROLE_CONSUMER, documentDir));
-    return { target, consumers };
+    const moduleOf = (module) => ({
+        id: module.id ?? "",
+        path: isAbsolutePath(module.path) ? module.path : joinPath(documentDir, module.path),
+    });
+    return { target: moduleOf(declared.target), consumers: (declared.consumers ?? []).map(moduleOf) };
 }
-/** The single-package scope one directory is, when no scope document is given. */
+/**
+ * The single-package scope one directory is, when no scope document is given. A target that is
+ * no directory holds no program.
+ */
 export function scopeForDir(host, dir) {
     const path = resolvePath(host.workingDirectory(), dir);
     const kind = host.kindOf(path);
-    if (kind === "absent") {
-        throw new ScopeError(`scope: ${path} does not exist`);
-    }
     if (kind !== "directory") {
-        throw new ScopeError(`scope: ${path} is not a directory`);
+        throw failureExit("no-program", `the target ${path} ${kind === "absent" ? "does not exist" : "is not a directory"}, so it holds no compiler configuration, no file named ${MARKERS.join(", ")}: name the directory that holds one`);
     }
     return { target: { id: "", path }, consumers: [] };
 }

package/dist/src/serialization-contract.js

@@ -19,7 +19,7 @@ import { must, Unanswerable } from "./query.js";
 import { erasedStores } from "./erased-stores.js";
 import { checkedTypes, CONVERSION_MEMBERS, valueReach } from "./value-reach.js";
 /** The serializer every run reads, whatever the configuration names. */
-const JSON_STRINGIFY = { shape: "global", global: "JSON.stringify" };
+const JSON_STRINGIFY = { global: "JSON.stringify" };
 /** The methods a serializer and a formatter resolve by name on a value that left the analysis. */
 const CONVERSIONS = new Set(["toJSON", "toString"]);
 /** The method a serializer calls on a value that carries one, wherever the value goes. */

package/dist/src/session.js

@@ -1,6 +1,5 @@
 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";
@@ -253,14 +252,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 = [];
@@ -282,30 +280,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();
@@ -315,3 +296,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,7 +3,7 @@
  * 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";
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";

package/dist/src/suppress-file.js

@@ -5,9 +5,9 @@
  * 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 { isRecord, positionAt, walkDocument } from "./json-document.js";
+import { isRecord, positionAt, readStrict, StrictJSONError } from "./json-document.js";
 import { declarationKey } from "./ref.js";
 import { CODE_FORM, SuppressionError, blankReason, isEntryPath, isPartKind, isSymbolRef, siteText, } from "./suppress.js";
 import { message } from "./product.js";
@@ -130,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}: ${message(error)}`);
+        if (!(error instanceof StrictJSONError)) {
+            throw error;
+        }
+        return malformed(error.message, positionAt(text, shape.file, error.offset));
     }
+    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`);
@@ -166,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);
@@ -278,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.js

@@ -7,7 +7,7 @@
  * withholds every such finding anyway, and stale otherwise.
  */
 import { KIND_ROWS, SYMBOL_SUBJECTS, } from "./contract/contract.generated.js";
-import { ConfigError } from "./config.js";
+import { UsageError } from "./usage.js";
 import { positionKey } from "./position.js";
 import { isRef } from "./ref.js";
 /**
@@ -15,9 +15,9 @@ import { isRef } from "./ref.js";
  * instruction the analysis cannot carry out. It is a malformed input, so the command line
  * answers it with the usage code.
  */
-export class SuppressionError extends ConfigError {
+export class SuppressionError extends UsageError {
     constructor(mechanism, at, text, want) {
-        super("malformed", at, `${mechanism} ${at}: ${text}: want ${want}`);
+        super(`${mechanism} ${at}: ${text}: want ${want}`);
         this.name = "SuppressionError";
     }
 }

package/dist/src/template-field.js

@@ -12,12 +12,12 @@
  * type, because nothing ties the name to a type.
  */
 import { readComponent } from "./component-files.js";
-import { ConfigError } from "./config.js";
 import { memberNames } from "./member-names.js";
 import { extensionOf, isAbsolutePath, joinPath, normalizePath, relativePath } from "./paths.js";
 import { isComponentFile } from "./position.js";
 import { bytewise } from "./text/compare.js";
 import { filesBelow } from "./fs/tree.js";
+import { UsageError } from "./usage.js";
 /** The kinds of declaration an action can name. */
 const READ_BY_A_TEMPLATE = new Set([
     "method",
@@ -51,18 +51,18 @@ export function readTemplates(host, targetRoot, analysis) {
             }
         }
     };
-    for (const configured of analysis.templateDirs) {
+    for (const configured of analysis.template_dirs) {
         const dir = normalizePath(configured);
         if (isAbsolutePath(dir) ||
             dir === ".." ||
             dir.startsWith("../") ||
             host.kindOf(joinPath(targetRoot, dir)) !== "directory") {
-            throw new ConfigError("malformed", "analysis.template_dirs", `analysis.template_dirs: ${JSON.stringify(configured)} is not a directory below the target root`);
+            throw new UsageError(`analysis.template_dirs: ${JSON.stringify(configured)} is not a directory below the target root`);
         }
         read(dir);
     }
     return {
-        delimiters: analysis.templateDelimiters,
+        delimiters: analysis.template_delimiters,
         files: [...files]
             .map(([path, text]) => ({ path, text }))
             .sort((a, b) => bytewise(a.path, b.path)),