@cplieger/deadset-ts 7.2.0-dev.3 → 8.0.0-dev.1

package/dist/src/namespace-objects.js

@@ -1,11 +1,12 @@
 /**
  * Module namespace objects: the binding of a namespace import, the value an `await` of a
  * dynamic `import()` produces, the first parameter of the first callback passed to `then`
- * on one, and a `const` binding initialized with one of these. A use reads the exports it
+ * on one, and a variable binding initialized with one of these. A use reads the exports it
  * names and no other: a property access by name or by a literal index, or a destructured
  * property, names one export, and any other use may read every export.
  */
-import { isArrowFunction, isAwaitExpression, isBindingElement, isCallExpression, isElementAccessExpression, isExpressionStatement, isFunctionExpression, isIdentifier, isImportDeclaration, isNamespaceImport, isNoSubstitutionTemplateLiteral, isObjectBindingPattern, isParenthesizedExpression, isPropertyAccessExpression, isQualifiedName, isStringLiteral, isVariableDeclaration, isVariableDeclarationList, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+import { isArrowFunction, isAwaitExpression, isCallExpression, isClassStaticBlockDeclaration, isElementAccessExpression, isExpressionStatement, isFunctionExpression, isFunctionLikeDeclaration, isIdentifier, isImportDeclaration, isModuleBlock, isNamespaceImport, isNoSubstitutionTemplateLiteral, isObjectBindingPattern, isParenthesizedExpression, isPropertyAccessExpression, isQualifiedName, isSourceFile, isStringLiteral, isVariableDeclaration, isVariableDeclarationList, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+import { spellsNoBinding } from "./spelled-names.js";
 function isLiteralText(node) {
     return isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node);
 }
@@ -25,21 +26,30 @@ function isLiteralImport(node) {
     const [argument] = node.arguments;
     return argument !== undefined && isLiteralText(argument);
 }
-/** The node a `const` binding's name is visible below: the block or file its statement is in. */
-function scopeOf(declaration) {
-    const statement = declaration.parent.parent;
-    return statement.parent;
+/**
+ * The node the binding one declaration list declares is visible below: for `let` and
+ * `const`, the loop whose head declares it, or else the block or file its statement is
+ * in; for `var`, the function, namespace body, static block or file that holds it.
+ */
+function scopeOf(list) {
+    if ((list.flags & (NodeFlags.Let | NodeFlags.Const | NodeFlags.Using)) !== 0) {
+        return isVariableStatement(list.parent) ? list.parent.parent : list.parent;
+    }
+    let at = list.parent;
+    while (!isSourceFile(at) &&
+        !isFunctionLikeDeclaration(at) &&
+        !isModuleBlock(at) &&
+        !isClassStaticBlockDeclaration(at)) {
+        at = at.parent;
+    }
+    return at;
 }
-/** Every identifier below `scope` that spells `name`, other than `declared` and a member's name. */
+/** Every identifier below `scope` that spells `name` as a reference, other than `declared`. */
 function occurrences(scope, name, declared) {
     const found = [];
     const visit = (node) => {
         if (isIdentifier(node)) {
-            const parent = node.parent;
-            const member = (isPropertyAccessExpression(parent) && parent.name === node) ||
-                (isQualifiedName(parent) && parent.right === node) ||
-                (isBindingElement(parent) && parent.propertyName === node);
-            if (node !== declared && node.text === name && !member) {
+            if (node !== declared && node.text === name && !spellsNoBinding(node)) {
                 found.push(node);
             }
             return;
@@ -52,8 +62,8 @@ function occurrences(scope, name, declared) {
 /**
  * Every use of the namespace objects one file holds, keyed by the node the use is written
  * at, that reads more than a name the checker resolves: an indexed read by a literal, and
- * any use that may read every export. A shadowing declaration of a binding's name inside
- * its scope is read as the binding, which can only keep an export live.
+ * any use that may read every export. A use of a shadowing declaration of a binding's
+ * name inside its scope is read as a use of the binding, which can only keep an export live.
  */
 export function namespaceUses(file) {
     const uses = new Map();
@@ -92,11 +102,11 @@ export function namespaceUses(file) {
                 }
                 return;
             }
+            // A binding that is not `const` is followed too: each assignment to it is an
+            // occurrence `value` cannot narrow, so a reassigned binding still reads every export.
             const list = parent.parent;
-            if (isIdentifier(pattern) &&
-                isVariableDeclarationList(list) &&
-                (list.flags & NodeFlags.Const) !== 0) {
-                binding(pattern, scopeOf(parent), specifier, seen);
+            if (isIdentifier(pattern) && isVariableDeclarationList(list)) {
+                binding(pattern, scopeOf(list), specifier, seen);
                 return;
             }
         }

package/dist/src/overrides.js

@@ -1,10 +1,9 @@
 /**
- * The overrides of the target's class members. A call through the base class names the
- * base's member and runs the override of whichever subclass the value is, so the base
- * member's declaration references every override. A method, an accessor or a property,
- * static or not, overriding a member of a class declared outside the target, at any depth
- * of its `extends` chain, is used by outside code holding the instance or the class
- * through that class, so its own class references it.
+ * The overrides of the target's class members. A call through the base class runs the
+ * override of whichever subclass the value is, so the base member references every
+ * override. A member, static or not, overriding one of a class declared outside the target
+ * at any depth of its `extends` chain, a library's interface-and-variable class such as
+ * `Error` included, is used by outside code holding the value, so its own class references it.
  */
 import { isClassDeclaration, isClassExpression, isExpressionWithTypeArguments, isPropertyAccessExpression, isQualifiedName, SyntaxKind, } from "@typescript/native/ast";
 import { memberComponent } from "./class-members.js";
@@ -12,6 +11,10 @@ import { nodeKey } from "./inventory.js";
 import { SymbolFlags } from "@typescript/native/sync";
 import { UNANSWERED } from "./query.js";
 import { nameComponent } from "./ref.js";
+const CLASS_DECLARATIONS = new Set([
+    SyntaxKind.ClassDeclaration,
+    SyntaxKind.ClassExpression,
+]);
 /** The member kinds a subclass overrides. */
 const OVERRIDABLE = new Set(["method", "class-member"]);
 /** The node naming the class one `extends` entry names. */
@@ -81,9 +84,12 @@ export function overrideReferences(project, held, chains, testFiles) {
             const declared = (symbol.flags & SymbolFlags.Alias) === 0 ? symbol : project.queries.aliased(symbol);
             if (inTarget.length === 0 &&
                 declared !== UNANSWERED &&
-                (declared.flags & SymbolFlags.Class) !== 0 &&
-                declared.declarations.length > 0 &&
-                declared.declarations.every((handle) => !own.has(handle.path))) {
+                (((declared.flags & SymbolFlags.Class) !== 0 &&
+                    // The target's augmentation of an outside class merges an interface into it,
+                    // so only a class declaration says where the class is.
+                    declared.declarations.some((handle) => CLASS_DECLARATIONS.has(handle.kind) && !own.has(handle.path))) ||
+                    ((declared.flags & SymbolFlags.Interface) !== 0 &&
+                        declared.declarations.some((handle) => handle.kind === SyntaxKind.VariableDeclaration && !own.has(handle.path))))) {
                 outsideBases.set(id, declared);
             }
         }
@@ -140,11 +146,13 @@ export function overrideReferences(project, held, chains, testFiles) {
  */
 function outsideMemberNames(project, bases, outsideBases) {
     const direct = new Map();
+    const error = errorType(project);
     for (const [classId, base] of outsideBases) {
         const instance = project.queries.declaredTypeOf(base);
         const statics = project.queries.typeOfSymbol(base);
         const components = [
             ...namesOf(project, instance === UNANSWERED ? undefined : instance).map(nameComponent),
+            ...(instance !== UNANSWERED && reaches(project, instance, error) ? ["toString"] : []),
             ...namesOf(project, statics === UNANSWERED ? undefined : statics).map((name) => `${nameComponent(name)}:static`),
         ];
         if (components.length > 0) {
@@ -170,6 +178,34 @@ function outsideMemberNames(project, bases, outsideBases) {
     }
     return names;
 }
+/** The global `Error` instance type's identifier, where the program's library declares one. */
+function errorType(project) {
+    const symbol = project.queries.resolveName("Error", SymbolFlags.Type, undefined, false);
+    if (symbol === UNANSWERED || symbol === undefined) {
+        return undefined;
+    }
+    const type = project.queries.declaredTypeOf(symbol);
+    return type === UNANSWERED ? undefined : type.id;
+}
+/**
+ * Whether one type is the `Error` instance type or extends it at any depth: the runtime
+ * prints an error through its `toString`, a member the library's `Error` interface omits.
+ */
+function reaches(project, type, target) {
+    const seen = new Set();
+    const pending = [type];
+    for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+        if (next.id === target) {
+            return true;
+        }
+        if (!seen.has(next.id)) {
+            seen.add(next.id);
+            const bases = project.queries.baseTypes(next);
+            pending.push(...(bases === UNANSWERED ? [] : bases));
+        }
+    }
+    return false;
+}
 /** The names of a type's properties; none where the type or its properties are unanswered. */
 function namesOf(project, type) {
     const properties = type === undefined ? UNANSWERED : project.queries.propertiesOf(type);

package/dist/src/paths.js

@@ -61,6 +61,15 @@ export function dirnamePath(path) {
     }
     return cut === 0 ? SEPARATOR : normalized.slice(0, cut);
 }
+/**
+ * The extension of one path's last segment, from its last full stop, or the empty string
+ * where it has none. A segment that only starts with a full stop has none.
+ */
+export function extensionOf(path) {
+    const name = path.slice(path.lastIndexOf(SEPARATOR) + 1);
+    const dot = name.lastIndexOf(".");
+    return dot <= 0 ? "" : name.slice(dot);
+}
 /** One path resolved against a directory, absolute where that directory is. */
 export function resolvePath(against, path) {
     return isAbsolutePath(path) ? normalizePath(path) : joinPath(against, path);

package/dist/src/print.js

@@ -73,6 +73,7 @@ export function printConfig(config, provenance) {
                 members: entry.members,
             })),
             serializers: config.ts.serializers.map(declarationOf),
+            roots_complete: config.ts.rootsComplete,
         },
         provenance: Object.fromEntries([...provenance]
             .sort(([a], [b]) => (a < b ? -1 : 1))

package/dist/src/ref.js

@@ -45,9 +45,11 @@ export const REF_EXPRESSIONS = [
     `^${SCOPE}#$`,
     `^${SCOPE}#${TS_HEAD}$`,
     `^${SCOPE}#(?:${TS_QUOTED}\\.)?${TS_HEAD}:alias$`,
+    `^${SCOPE}#${TS_HEAD}:import$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+:static$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?<${TS_IDENT}>$`,
+    `^${SCOPE}#(?:${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?)?\\(${TS_IDENT}\\)$`,
     `^${MANIFEST_SCOPE}#${TS_PACKAGE}:(?:dependency|dev-dependency|peer-dependency)$`,
 ];
 const REF_FORMS = REF_EXPRESSIONS.map((expression) => new RegExp(expression, "u"));
@@ -86,6 +88,14 @@ function quoted(name) {
 export function computedComponent(text) {
     return `[${text.replaceAll(ASCII_WHITESPACE, "")}]`;
 }
+/** The reference of an import binding, read against the reference of the module that holds it. */
+export function importRef(moduleRef, name) {
+    return `${moduleRef}${nameComponent(name)}:import`;
+}
+/** The reference of a parameter, read against the reference of the declaration that holds it. */
+export function parameterRef(holderRef, name) {
+    return `${holderRef}(${name})`;
+}
 /** The fragment of an export alias, inside the `declare module` block named, if one is. */
 export function aliasFragment(name, block) {
     const head = block === undefined ? "" : `${quoted(block)}.`;

package/dist/src/references.js

@@ -16,8 +16,9 @@ import { overrideReferences } from "./overrides.js";
 import { dirnamePath, queriedModulePath, relativePath, resolvePath } from "./paths.js";
 import { byPosition, isComponentFile, renderPosition } from "./position.js";
 import { DEFAULT_BATCH_CAP, propertyTables, UNANSWERED } from "./query.js";
+import { typeParameterReads } from "./type-parameter-reads.js";
 import { typeQueryAliases } from "./type-query-alias.js";
-import { computedKeyNames, keyNameOf, keyedUses } from "./symbol-keys.js";
+import { computedKeyNames, iterationReferences, keyNameOf, keyedUses, } from "./symbol-keys.js";
 import { handedOn, valuesOf } from "./value-flow.js";
 /**
  * The operators whose left side one assignment stores into. A compound assignment is
@@ -661,19 +662,29 @@ export function references(project, held, targetRoot, options) {
             relativePath(targetRoot, file.fileName) === undefined);
     const ownPaths = project.ownPaths();
     const fileIds = new Set(held.symbols.filter((symbol) => symbol.kind === "file").map((symbol) => symbol.id));
-    let topLevel;
-    /** The declarations one file's top level holds. */
-    const declaredIn = (fileId) => {
-        if (topLevel === undefined) {
-            const byParent = new Map();
+    let moduleBodies;
+    /**
+     * The declarations one module holds directly: a file's top level, or the body of a
+     * `declare module` whose name is a string. Any other declaration holds none here.
+     */
+    const declaredIn = (moduleId) => {
+        if (moduleBodies === undefined) {
+            const byModule = new Map();
             for (const symbol of held.symbols) {
-                if (fileIds.has(symbol.parent)) {
-                    byParent.set(symbol.parent, [...(byParent.get(symbol.parent) ?? []), symbol]);
+                if (!fileIds.has(symbol.parent) && !held.modules.has(symbol.parent)) {
+                    continue;
+                }
+                const siblings = byModule.get(symbol.parent);
+                if (siblings === undefined) {
+                    byModule.set(symbol.parent, [symbol]);
+                }
+                else {
+                    siblings.push(symbol);
                 }
             }
-            topLevel = byParent;
+            moduleBodies = byModule;
         }
-        return topLevel.get(fileId) ?? [];
+        return moduleBodies.get(moduleId) ?? [];
     };
     const exportsCache = new Map();
     /**
@@ -975,8 +986,11 @@ export function references(project, held, targetRoot, options) {
         }
         for (const url of urls) {
             const constructor = url.constructor === undefined ? undefined : answered.get(url.constructor);
+            // An augmentation of the global `URL` merges into it, which keeps the
+            // library's declaration; a `URL` the target declares has no other.
             if (typeof constructor === "object" &&
-                constructor.declarations.some((handle) => ownPaths.has(handle.path))) {
+                constructor.declarations.length > 0 &&
+                constructor.declarations.every((handle) => ownPaths.has(handle.path))) {
                 continue;
             }
             const loaded = specifierCandidates(dirnamePath(file.fileName), url.specifier)
@@ -1133,14 +1147,16 @@ export function references(project, held, targetRoot, options) {
     }
     let typedLookups = 0;
     if (consumer === undefined) {
-        found.push(...overrideReferences(project, held, chains, new Set(tests)));
         const before = options.requestCount?.() ?? 0;
+        found.push(...overrideReferences(project, held, chains, new Set(tests)));
         found.push(...indexedAccessReferences(project, held, chains, root, new Set(tests)));
         found.push(...elementAccessReferences(project, held, chains, root, new Set(tests)));
         found.push(...keyofComparisonReferences(project, held, chains, root, new Set(tests)));
+        found.push(...iterationReferences(project, held, chains, root, new Set(tests)));
+        found.push(...typeParameterReads(project, held, chains, root, new Set(tests)));
         found.push(...unimplementedCalleeReads(project, held, chains, root, new Set(tests)));
-        typedLookups = (options.requestCount?.() ?? 0) - before;
         found.push(...moduleDeclarationReferences(project, held, root, new Set(tests)));
+        typedLookups = (options.requestCount?.() ?? 0) - before;
     }
     const scripts = new Set(walked.filter((one) => one.file.externalModuleIndicator === undefined).map((one) => one.fileId));
     found.push(...augmentationReferences(held, found, scripts));

package/dist/src/reflective-lookup.js

@@ -90,8 +90,9 @@ export function reflectiveLookup(input) {
     if (lookups.length === 0) {
         return [];
     }
-    // Whether each written `Reflect` is the global one, asked in one batch: a
-    // declaration of that name in one of the project's own files shadows it.
+    // Whether each written `Reflect` is the global one, asked in one batch: a name
+    // declared only in the project's own files shadows it, and an augmentation of the
+    // global merges into it, which keeps the library's declaration.
     const ownFiles = project.ownPaths();
     const reflects = lookups.flatMap((lookup) => lookup.reflect === undefined ? [] : [lookup.reflect]);
     const global = new Set();
@@ -99,10 +100,11 @@ export function reflectiveLookup(input) {
         project.symbolsAt(reflects.map((node) => project.handle(node))).forEach((symbol, index) => {
             const node = reflects[index];
             // A name the checker did not answer for is read as the global, which retains.
-            const declaredHere = symbol === UNANSWERED
-                ? false
-                : symbol?.declarations.some((declaration) => ownFiles.has(declaration.path));
-            if (node !== undefined && declaredHere === false) {
+            const isGlobal = symbol === UNANSWERED ||
+                (symbol !== undefined &&
+                    (symbol.declarations.length === 0 ||
+                        symbol.declarations.some((declaration) => !ownFiles.has(declaration.path))));
+            if (node !== undefined && isGlobal) {
                 global.add(node);
             }
         });

package/dist/src/report.js

@@ -4,7 +4,7 @@
  * renders this document, so no two renderings disagree about which findings exist.
  */
 /** The version of the report schema this analyzer writes a report to. */
-const SCHEMA_VERSION = "8.2.0";
+const SCHEMA_VERSION = "9.0.0";
 /** Every report schema version this analyzer reads: the one the Contract it implements admits. */
 export const SCHEMA_VERSIONS_ACCEPTED = [SCHEMA_VERSION];
 /** The name this analyzer writes every document under and mints every identifier with. */
@@ -247,7 +247,9 @@ export function buildReport(input) {
         ]
             .sort(([a, x], [b, y]) => compare(x.path, y.path) || x.line - y.line || compare(a, b))
             .map(([, skip]) => skip),
-        notes: [],
+        notes: [...new Map((input.notes ?? []).map((one) => [JSON.stringify(one), one])).entries()]
+            .sort(([a, x], [b, y]) => compare(x.kind, y.kind) || compare(x.path, y.path) || compare(a, b))
+            .map(([, note]) => note),
         unanswered_questions: [...input.unanswered]
             .sort((a, b) => compare(a.configuration, b.configuration) ||
             compare(JSON.stringify(a), JSON.stringify(b)))

package/dist/src/reporters/template.js

@@ -793,7 +793,7 @@ class Execution {
             case "lit":
                 return arg.value;
             case "pipe":
-                return this.pipeline(arg.pipe, dot, false);
+                return this.pipeline(arg.pipe, dot);
             case "field":
                 return this.field(arg.recv === undefined ? dot : this.arg(arg.recv, dot), arg.names);
             case "func":
@@ -837,19 +837,18 @@ class Execution {
         }
         return call(head.name, operands());
     }
-    pipeline(pipe, dot, declares) {
+    pipeline(pipe, dot) {
         let value;
         for (const command of pipe.commands) {
             value = this.command(command, dot, value);
         }
         const result = value ?? null;
-        const [only] = pipe.vars;
-        if (only !== undefined && (declares || pipe.assign)) {
+        for (const name of pipe.vars) {
             if (pipe.assign) {
-                this.assign(only, result);
+                this.assign(name, result);
             }
             else {
-                this.scopes.at(-1)?.set(only, result);
+                this.scopes.at(-1)?.set(name, result);
             }
         }
         return result;
@@ -861,7 +860,7 @@ class Execution {
                     this.write(node.text);
                     break;
                 case "action": {
-                    const value = this.pipeline(node.pipe, dot, true);
+                    const value = this.pipeline(node.pipe, dot);
                     if (node.pipe.vars.length === 0) {
                         this.write(formatted(value, false));
                     }
@@ -874,7 +873,7 @@ class Execution {
                 case "with": {
                     this.scopes.push(new Map());
                     try {
-                        const value = this.pipeline(node.pipe, dot, true);
+                        const value = this.pipeline(node.pipe, dot);
                         const taken = truthy(value);
                         this.run(taken ? node.list : node.otherwise, taken && node.k === "with" ? value : dot);
                     }
@@ -892,7 +891,9 @@ class Execution {
     range(node, dot) {
         this.scopes.push(new Map());
         try {
-            const value = this.pipeline({ ...node.pipe, vars: [] }, dot, false);
+            // Go's `evalPipeline` gives every variable the range declares or assigns the whole value first:
+            // https://github.com/golang/go/blob/go1.27.2/src/text/template/exec.go#L525
+            const value = this.pipeline(node.pipe, dot);
             let entries;
             if (value === null) {
                 entries = [];
@@ -913,14 +914,22 @@ class Execution {
                 return;
             }
             const [first, second] = node.pipe.vars;
+            const scope = this.scopes.at(-1);
+            const bind = (name, held) => {
+                if (node.pipe.assign) {
+                    this.assign(name, held);
+                }
+                else {
+                    scope?.set(name, held);
+                }
+            };
             for (const [key, element] of entries) {
-                const scope = this.scopes.at(-1);
                 if (second !== undefined && first !== undefined) {
-                    scope?.set(first, key);
-                    scope?.set(second, element);
+                    bind(first, key);
+                    bind(second, element);
                 }
                 else if (first !== undefined) {
-                    scope?.set(first, element);
+                    bind(first, element);
                 }
                 try {
                     this.run(node.list, element);

package/dist/src/resolve.js

@@ -567,6 +567,7 @@ function readDoc(value, label) {
         injectionRegistrations: readDeclarations(ts, "injection_registrations", "ts.injection_registrations", label),
         lifecycleContracts: readLifecycleContracts(ts, label),
         serializers: readDeclarations(ts, "serializers", "ts.serializers", label),
+        rootsComplete: readBoolean(ts, "roots_complete", "ts.roots_complete", label),
     };
 }
 /** Parses one document's text and walks it against the closed key list. */
@@ -776,6 +777,7 @@ function settleAll(inputs) {
             injectionRegistrations: at("ts.injection_registrations", defaults.ts.injectionRegistrations, (doc) => doc.injectionRegistrations),
             lifecycleContracts: at("ts.lifecycle_contracts", defaults.ts.lifecycleContracts, (doc) => doc.lifecycleContracts),
             serializers: at("ts.serializers", defaults.ts.serializers, (doc) => doc.serializers),
+            rootsComplete: at("ts.roots_complete", defaults.ts.rootsComplete, (doc) => doc.rootsComplete),
         },
     };
     return { config, provenance };