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

package/dist/src/component-files.js

@@ -5,6 +5,7 @@
  * of the module is the same position of the file. A default export and the imports a `src`
  * attribute names are appended past the file's end.
  */
+import { isPathRelativeURL, startsRelativePath } from "./paths.js";
 const LANGUAGES = new Map([
     ["ts", "ts"],
     ["tsx", "tsx"],
@@ -346,10 +347,10 @@ function actionOf(text) {
 /** Whether a `src` value names a file: no scheme, no root-relative path, not empty. */
 function specifierOf(value) {
     const trimmed = value.trim();
-    if (trimmed === "" || trimmed.startsWith("/") || /^[A-Za-z][A-Za-z0-9+.-]*:/u.test(trimmed)) {
+    if (!isPathRelativeURL(trimmed)) {
         return undefined;
     }
-    return trimmed.startsWith("./") || trimmed.startsWith("../") ? trimmed : `./${trimmed}`;
+    return startsRelativePath(trimmed) ? trimmed : `./${trimmed}`;
 }
 /** The line-start `<script` tags one block's content holds. */
 function scriptsInside(text, from, to) {

package/dist/src/component-layer.js

@@ -5,9 +5,11 @@
  * member wins over one it extends. The mapper resolves as a package linked into the
  * `node_modules` beside each configuration, to a directory holding only its manifest.
  */
+import { INSTALLED_PACKAGES } from "./fs/manifest.js";
 import { dirnamePath, joinPath } from "./paths.js";
+import { PRODUCT } from "./product.js";
 /** The name the mapper's manifest declares and every configuration's entry names. */
-const MAPPER_PACKAGE = "deadset-ts-component-files";
+const MAPPER_PACKAGE = `${PRODUCT}-component-files`;
 /** The manifest of the mapper's package, which runs `command`. */
 export function mapperManifest(command) {
     return `${JSON.stringify({
@@ -122,7 +124,7 @@ export function componentLayer(host, configFiles, mapper, written = new Map()) {
     for (const configFile of configFiles) {
         files[configFile] = withContentMappers(written.get(configFile) ?? host.readFile(configFile), mappers);
         if (mapper !== undefined) {
-            symlinks[joinPath(dirnamePath(configFile), "node_modules", MAPPER_PACKAGE)] = {
+            symlinks[joinPath(dirnamePath(configFile), INSTALLED_PACKAGES, MAPPER_PACKAGE)] = {
                 target: mapper.packageDirectory,
                 host: true,
             };

package/dist/src/config.js

@@ -1,74 +1,18 @@
-import { CONTRACT_VERSION } from "./version.js";
+import { SEVERITIES } from "./contract/contract.generated.js";
+import { LANGUAGE } from "./product.js";
 /**
  * The name of the repository configuration at the target root, which is also the
  * document a finding about the configuration names where no document of the
  * target supplied the setting it is about.
  */
 export const REPOSITORY_DOCUMENT = "deadset.json";
-/** The kind a target kind setting gives one language's declarations. */
-export function kindOf(setting, language) {
-    return typeof setting === "string" ? setting : setting[language];
+/** The kind a target kind setting gives this analyzer's declarations. */
+export function kindOf(kind) {
+    return typeof kind === "string" ? kind : kind[LANGUAGE];
 }
-/** The severities ranked, the strongest highest. */
-const SEVERITY_RANK = { allow: 0, warn: 1, deny: 2 };
 /** Whether a finding at one severity fails a run under the failing severity. */
 export function fails(severity, failOn) {
-    return SEVERITY_RANK[severity] >= SEVERITY_RANK[failOn];
-}
-/**
- * The configuration every documented default states. `targetKind` is empty: the
- * field has no default and is never inferred.
- */
-export function defaultConfig() {
-    return {
-        contractVersion: CONTRACT_VERSION,
-        targetKind: "",
-        analysis: {
-            languages: [],
-            minConfidence: "probable",
-            generatedFiles: "exclude",
-            consumerTests: "test",
-            configurations: [],
-            matrixComplete: false,
-            templateDirs: [],
-            templateDelimiters: { left: "{{", right: "}}" },
-        },
-        consumersComplete: false,
-        rootPatterns: [],
-        severity: new Map(),
-        exemptionsDisabled: [],
-        reporters: {
-            formats: ["text"],
-            sort: "position",
-            cascade: "roots",
-            maxFindings: 0,
-            failOn: "deny",
-        },
-        providers: {
-            analyzers: [
-                { shape: "installed", name: "deadset-go", languages: ["go"], command: "deadset-go" },
-                { shape: "installed", name: "deadset-ts", languages: ["ts"], command: "deadset-ts" },
-            ],
-        },
-        ts: {
-            testFiles: [
-                "**/*.test.{ts,tsx,mts,cts}",
-                "**/*.test-d.{ts,tsx,mts,cts}",
-                "**/*.spec-d.{ts,tsx,mts,cts}",
-                "**/*.spec.*",
-                "**/__tests__/**",
-                "**/__mocks__/**",
-                "**/test-d/**",
-            ],
-            entryFiles: [],
-            componentExtensions: [".vue", ".svelte", ".astro"],
-            disabledConventions: [],
-            injectionRegistrations: [],
-            lifecycleContracts: [],
-            serializers: [],
-            rootsComplete: false,
-        },
-    };
+    return SEVERITIES.indexOf(severity) >= SEVERITIES.indexOf(failOn);
 }
 /**
  * Renders the origin as the provenance value the Contract declares: `default`,
@@ -77,23 +21,3 @@ export function defaultConfig() {
 export function renderOrigin(origin) {
     return origin.source === "default" ? "default" : `${origin.source}: ${origin.label}`;
 }
-/**
- * Every refusal configuration resolution makes. Each maps to the usage exit
- * code, and each is thrown rather than returned: a refusal ends the run, and the
- * one caller that turns it into an exit code is the command line.
- */
-export class ConfigError extends Error {
-    /** Which refusal this is. */
-    kind;
-    /**
-     * The key or field the message names, spelled as the document spells it. It is
-     * empty when the refusal names none.
-     */
-    key;
-    constructor(kind, key, message) {
-        super(message);
-        this.name = "ConfigError";
-        this.kind = kind;
-        this.key = key;
-    }
-}

package/dist/src/conformance-record.js

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "6.0.0",
+        corpusVersion: "6.1.0",
         result: "pass",
-        digest: "sha256:d65daae4b7c95050c07896b166d0250d233cca71f97de75a6086c1d80fe76232",
+        digest: "sha256:352b870acbc05213d4869bc18611137d0782cc0c9a8379e7a998a3d9cea2d966",
     },
     gaps: [],
 };

package/dist/src/consumers.js

@@ -1,49 +1,21 @@
-/**
- * The consumers a scope declares, loaded beside the target: each a directory on the
- * local filesystem whose compiler configurations open as projects of the run's one
- * snapshot, and whose references to the target's declarations count against them.
- */
-import { consumerProjects } from "./discover.js";
-import { inventory, packageScope } from "./inventory.js";
+import { runDirectories } from "./entries/run-directories.js";
+import { inventory } from "./inventory/enumerate.js";
 import { relativePath } from "./paths.js";
 import { references } from "./references.js";
 import { narrowedTo } from "./session.js";
-/** The name one module publishes itself under: the scope's, else its manifest's. */
-export function moduleIdentity(host, module) {
-    return module.id === "" ? packageScope(host, module.path)("index.ts").package : module.id;
-}
-/**
- * Every consumer the scope declares, in its order, with the projects it opens as. A
- * configuration that is also one of the target's projects, or an earlier consumer's, is
- * that project's alone. A consumer whose directory is absent, is no directory or holds
- * no configuration ends the run naming it, before any project opens.
- */
-export function consumerLoads(engine, host, scope, targetConfigFiles) {
-    const opened = new Set(targetConfigFiles);
-    return scope.consumers.map((module) => {
-        const configFiles = consumerProjects(engine, host, module.path).filter((configFile) => {
-            const fresh = !opened.has(configFile);
-            opened.add(configFile);
-            return fresh;
-        });
-        return { consumer: { id: moduleIdentity(host, module), path: module.path }, configFiles };
-    });
-}
+import { patternTestFile } from "./tests/file-class.js";
 /**
  * Every reference one consumer project's own files make to a declaration of the target.
  * The target's declarations are enumerated over the target's files the consumer's
  * program holds, against the target root, so each carries the identifier the target's
- * own projects give it. A reference from a consumer's test file is a test reference
- * unless the configuration counts it as a production one.
+ * own projects give it. A reference from a consumer's test file is a test reference;
+ * whether the run counts it as a production one is the sweep's mode.
  */
-export function consumerReferences(project, host, targetRoot, consumer, config) {
+export function consumerReferences(project, host, targetRoot, consumer, config, parse) {
     const held = inventory(narrowedTo(project, (file) => relativePath(targetRoot, file.fileName) !== undefined), host, targetRoot);
-    const found = references(project, held, targetRoot, {
-        testFiles: config.ts.testFiles,
+    return references(project, held, targetRoot, {
+        testFile: patternTestFile(config.ts.test_files, consumer.root),
         consumer,
-    }).references;
-    if (config.analysis.consumerTests !== "production") {
-        return found;
-    }
-    return found.map((reference) => (reference.test ? { ...reference, test: false } : reference));
+        directories: runDirectories(host, consumer.root, parse),
+    });
 }

package/dist/src/contextual-uses.js

@@ -1,10 +1,11 @@
 /**
  * The uses contextual types make of the target's members, which no name node resolves to.
  * An object-literal property writes the member of its name on each constituent of the
- * literal's contextual type that declares one. A value reaching a position typed by another
- * object type reads each of its members that type declares, through array elements and
- * the parameters and results of functions and constructors too; a class instance there is
- * the interface-satisfaction class's evidence instead.
+ * literal's contextual type that declares one, and so does a property of a literal whose
+ * type is inferred, where a value of that type reaches such a position. A value reaching a
+ * position typed by another object type reads each of its members that type declares,
+ * through array elements and the parameters and results of functions and constructors
+ * too; a class instance there is the interface-satisfaction class's evidence instead.
  */
 import { isClassDeclaration, isClassExpression, isComputedPropertyName, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isMethodSignatureDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isPropertyAssignment, isSetAccessorDeclaration, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, } from "@typescript/native/ast";
 import { SignatureKind } from "@typescript/native/sync";
@@ -62,9 +63,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
     const privateNames = new Set(held.symbols
         .filter((symbol) => symbol.visibility === "private-name")
         .map((symbol) => symbol.id));
-    let batches = 0;
-    let lookups = 0;
-    const batchesOf = (count) => Math.ceil(count / cap);
     const parts = new Map();
     /** The object types one type is: itself, or its constituents at any depth. */
     const partsOf = (type) => {
@@ -74,7 +72,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         }
         let found = [];
         if (type.isUnionType() || type.isIntersectionType()) {
-            lookups += 1;
             const constituents = queries.constituents(type);
             found = isAnswered(constituents) ? constituents.flatMap(partsOf) : [];
         }
@@ -93,7 +90,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         }
         const table = new Map();
         const read = properties.of(type);
-        lookups += read.asked ? 1 : 0;
         for (const property of isAnswered(read.properties) ? read.properties : []) {
             table.set(property.name, {
                 ids: chains
@@ -111,7 +107,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         return table;
     };
     const writes = [];
-    batches += batchesOf(literals.length);
     const contexts = queries.contextualTypes(literals.map((one) => one.literal), cap);
     // A computed name that is not literal text names the property the literal declares
     // under the checker's own key, which is how a type declares a member a unique symbol
@@ -122,7 +117,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             const name = propertyName(property);
             return name !== undefined && name.text === undefined ? [name.node] : [];
         }));
-    batches += batchesOf(computed.length);
     const keys = new Map();
     (computed.length === 0
         ? []
@@ -151,7 +145,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         }
     });
     const carried = flows.filter((flow) => !isObjectLiteralExpression(flow.value));
-    batches += batchesOf(carried.length);
     const types = queries.typesAt(carried.map((flow) => flow.value), cap);
     /** The members a position may read structurally: those of object types, not of classes. */
     const readable = (member) => [
@@ -164,17 +157,42 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         const members = [...membersOf(part).values()];
         return members.length > 0 && members.every((member) => !member.own);
     };
+    const literalTypes = new Map();
+    /**
+     * Whether an object type is an object literal's own, inferred where no contextual type
+     * names it: every member a property an object literal of the target writes.
+     */
+    const literalTyped = (part) => {
+        let known = literalTypes.get(part.id);
+        if (known === undefined) {
+            const members = [...membersOf(part).values()];
+            known =
+                members.length > 0 &&
+                    members.every((member) => member.ids.length === 0 &&
+                        member.declarations.length > 0 &&
+                        member.declarations.every((handle) => literalProperty(handle) !== undefined));
+            literalTypes.set(part.id, known);
+        }
+        return known;
+    };
+    /** The name node of the object literal property one declaration handle names, if it is one. */
+    const literalProperty = (handle) => {
+        const node = project.declarationAt(handle)?.node;
+        return node !== undefined &&
+            (isPropertyAssignment(node) || isShorthandPropertyAssignment(node)) &&
+            isObjectLiteralExpression(node.parent)
+            ? node.name
+            : undefined;
+    };
     const elements = new Map();
     /** The element type of an array type, read once per type. */
     const elementOf = (type) => {
         if (elements.has(type.id)) {
             return elements.get(type.id);
         }
-        lookups += 1;
         const isArray = queries.isArray(type);
         let element;
         if (isAnswered(isArray) && isArray) {
-            lookups += 1;
             const held = queries.typeArguments(type);
             element = isAnswered(held) ? held[0] : undefined;
         }
@@ -188,7 +206,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         if (known !== undefined) {
             return known;
         }
-        lookups += type.isTypeReference() ? 1 : 0;
         const held = queries.typeArguments(type);
         const found = isAnswered(held) ? held : [];
         argumentsOf.set(type.id, found);
@@ -204,18 +221,15 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         if (known !== undefined) {
             return known;
         }
-        lookups += 1;
         let kind = SignatureKind.Call;
         let signatures = queries.signaturesOf(type, kind);
         if (isAnswered(signatures) && signatures.length === 0) {
-            lookups += 1;
             kind = SignatureKind.Construct;
             signatures = queries.signaturesOf(type, kind);
         }
         const called = (isAnswered(signatures) ? signatures : []).map((signature) => {
             const parameters = signature.parameters.map((_parameter, index) => queries.parameterType(signature, index));
             const result = queries.returnTypeOf(signature);
-            lookups += parameters.length + 1;
             return {
                 kind,
                 parameters: parameters.map((one) => (isAnswered(one) ? one : undefined)),
@@ -246,10 +260,13 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         const sources = partsOf(source).filter((one) => !targets.some((part) => part.id === one.id));
         for (const one of sources) {
             if (carries(one)) {
-                into.push({ source: one, targets, outside: false });
+                into.push({ source: one, targets, sourceKind: "members" });
             }
             else if (outside(one)) {
-                into.push({ source: one, targets, outside: true });
+                into.push({ source: one, targets, sourceKind: "outside" });
+            }
+            else if (literalTyped(one)) {
+                into.push({ source: one, targets, sourceKind: "literal" });
             }
             const element = elementOf(one);
             const called = element === undefined ? callsOf(one) : [];
@@ -290,7 +307,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         }
         seen.add(type.id);
         return partsOf(type).some((part) => {
-            if (carries(part) || outside(part)) {
+            if (carries(part) || outside(part) || literalTyped(part)) {
                 return true;
             }
             const element = elementOf(part);
@@ -304,9 +321,10 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         const type = types[index];
         return type === undefined || !isAnswered(type) || !mayCarry(type) ? [] : [{ flow, type }];
     });
-    batches += batchesOf(sourced.length);
     const positions = queries.contextualTypes(sourced.map((one) => one.flow.value), cap);
     const reads = [];
+    // A literal property writes a position's members once, however many values carry it there.
+    const carriedWrites = new Set();
     sourced.forEach(({ flow, type }, index) => {
         const position = positions[index];
         if (position === undefined || !isAnswered(position)) {
@@ -315,10 +333,24 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         const checked = [];
         compared(type, position, checked, new Set());
         const ids = new Set();
-        for (const { source, targets, outside: held } of checked) {
+        for (const { source, targets, sourceKind } of checked) {
             const tables = targets.map(membersOf);
             const sourceMembers = membersOf(source);
-            if (held) {
+            if (sourceKind === "literal") {
+                for (const [name, member] of sourceMembers) {
+                    const written = [...new Set(tables.flatMap((table) => table.get(name)?.ids ?? []))];
+                    for (const at of written.length === 0 ? [] : member.declarations) {
+                        const node = literalProperty(at);
+                        const key = `${at.path}#${String(at.index)}>${written.join(",")}`;
+                        if (node !== undefined && !carriedWrites.has(key)) {
+                            carriedWrites.add(key);
+                            writes.push({ at: node, from: flow.from, ids: written });
+                        }
+                    }
+                }
+                continue;
+            }
+            if (sourceKind === "outside") {
                 for (const table of tables) {
                     for (const [name, member] of table) {
                         if (sourceMembers.has(name)) {
@@ -361,7 +393,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         return known;
     };
     const spreads = literals.flatMap(({ literal, from }) => literal.properties.flatMap((property) => isSpreadAssignment(property) ? [{ value: property.expression, from }] : []));
-    batches += batchesOf(spreads.length);
     const spreadTypes = queries.typesAt(spreads.map((one) => one.value), cap);
     spreads.forEach(({ value, from }, index) => {
         const type = spreadTypes[index];
@@ -379,5 +410,5 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             reads.push({ at: value, from, ids });
         }
     });
-    return { writes, reads, batches, lookups };
+    return { writes, reads };
 }