@cplieger/deadset-ts 8.0.0-dev.16 → 8.0.0-dev.18

package/src/contextual-uses.ts

@@ -56,16 +56,12 @@ interface ContextualUse {
   readonly ids: readonly string[];
 }
 
-/** What the contextual types of one project's literals and values use, and what asking cost. */
+/** What the contextual types of one project's literals and values use. */
 interface ContextualUses {
   /** Each literal property that writes a member, by the property's node. */
   readonly writes: readonly ContextualUse[];
   /** Each value whose members a position typed by another object type reads. */
   readonly reads: readonly ContextualUse[];
-  /** The batched lookups: contextual types and value types, one per capped run. */
-  readonly batches: number;
-  /** The per-type lookups: each distinct type's constituents, properties and declaring symbol. */
-  readonly lookups: number;
 }
 
 /**
@@ -169,9 +165,6 @@ export function contextualUses<Brand>(
       .filter((symbol) => symbol.visibility === "private-name")
       .map((symbol) => symbol.id),
   );
-  let batches = 0;
-  let lookups = 0;
-  const batchesOf = (count: number): number => Math.ceil(count / cap);
 
   const parts = new Map<number, readonly Type[]>();
   /** The object types one type is: itself, or its constituents at any depth. */
@@ -182,7 +175,6 @@ export function contextualUses<Brand>(
     }
     let found: readonly Type[] = [];
     if (type.isUnionType() || type.isIntersectionType()) {
-      lookups += 1;
       const constituents = queries.constituents(type);
       found = isAnswered(constituents) ? constituents.flatMap(partsOf) : [];
     } else if (type.isObjectType()) {
@@ -201,7 +193,6 @@ export function contextualUses<Brand>(
     }
     const table = new Map<string, Member>();
     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
@@ -222,7 +213,6 @@ export function contextualUses<Brand>(
   };
 
   const writes: ContextualUse[] = [];
-  batches += batchesOf(literals.length);
   const contexts = queries.contextualTypes(
     literals.map((one) => one.literal),
     cap,
@@ -238,7 +228,6 @@ export function contextualUses<Brand>(
           return name !== undefined && name.text === undefined ? [name.node] : [];
         }),
   );
-  batches += batchesOf(computed.length);
   const keys = new Map<Node, string>();
   (computed.length === 0
     ? []
@@ -272,7 +261,6 @@ export function contextualUses<Brand>(
   });
 
   const carried = flows.filter((flow) => !isObjectLiteralExpression(flow.value));
-  batches += batchesOf(carried.length);
   const types = queries.typesAt(
     carried.map((flow) => flow.value),
     cap,
@@ -327,11 +315,9 @@ export function contextualUses<Brand>(
     if (elements.has(type.id)) {
       return elements.get(type.id);
     }
-    lookups += 1;
     const isArray = queries.isArray(type);
     let element: Type | undefined;
     if (isAnswered(isArray) && isArray) {
-      lookups += 1;
       const held = queries.typeArguments(type);
       element = isAnswered(held) ? held[0] : undefined;
     }
@@ -346,7 +332,6 @@ export function contextualUses<Brand>(
     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);
@@ -363,11 +348,9 @@ export function contextualUses<Brand>(
     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);
     }
@@ -376,7 +359,6 @@ export function contextualUses<Brand>(
         queries.parameterType(signature, index),
       );
       const result = queries.returnTypeOf(signature);
-      lookups += parameters.length + 1;
       return {
         kind,
         parameters: parameters.map((one) => (isAnswered(one) ? one : undefined)),
@@ -474,7 +456,6 @@ export function contextualUses<Brand>(
     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,
@@ -556,7 +537,6 @@ export function contextualUses<Brand>(
       isSpreadAssignment(property) ? [{ value: property.expression, from }] : [],
     ),
   );
-  batches += batchesOf(spreads.length);
   const spreadTypes = queries.typesAt(
     spreads.map((one) => one.value),
     cap,
@@ -583,5 +563,5 @@ export function contextualUses<Brand>(
       reads.push({ at: value, from, ids });
     }
   });
-  return { writes, reads, batches, lookups };
+  return { writes, reads };
 }

package/src/contract/config.generated.ts

@@ -501,7 +501,10 @@ export const SETTINGS: readonly SettingRow[] = [
     key: "provenance",
     role: "ignored",
     read: true,
-    value: { type: "string", pattern: "^(default|(repository|central|flag): [^\\r\\n]+)$" },
+    value: {
+      type: "string",
+      pattern: "^(default|(repository|central|flag): ([^\\r\\n]|[\\r\\n])+)$",
+    },
     keyPattern: "^[a-z][a-z_]*(\\.[A-Za-z0-9_]+)*$",
   },
 ];

package/src/contract/contract.generated.ts

@@ -423,7 +423,7 @@ export const KIND_ROWS = [
     holdsLive: true,
     rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
     precondition:
-      "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the package references that function or method, because the caller holds values of the type, and unexporting it would leave an exported signature naming a type its callers cannot name. A package-level declaration whose name a string literal spells carries the class grammar/analysis/confidence.md gives it.",
+      "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type is not reported when a reference from outside the package reaches its values through its own package's exported declarations: a reference to an exported function or method whose parameters or results name the type, to an exported variable or constant whose type names it, to an exported field or property whose type names it, an embedded field included, or to an exported member of the type itself, a field promoted through an embedding included. A type a reference from outside the package names, or whose values such a reference reaches, passes the reach on to each type its definition names other than through an unexported member, whether it is exported or not, so an unexported type an exported function returns passes it to the types its exported fields name. A type names another through every composite that spells it: a pointer, an array, a slice, a map key or value, a channel, a function signature and a type argument. The referencing code holds values of the type, so unexporting it would leave an exported declaration naming a type its users cannot name. A package-level declaration whose name a string literal spells carries the class grammar/analysis/confidence.md gives it.",
     details: { narrower_visibility: "required", name_literal: "optional" },
     defaultEnabled: true,
     defaultSeverity: "warn",
@@ -439,7 +439,7 @@ export const KIND_ROWS = [
     holdsLive: true,
     rule: "An exported symbol of a non-internal package whose every reference is inside the target module, reported as a candidate for relocation behind an internal boundary. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
     precondition:
-      "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the target module references that function or method, because the caller holds values of the type, and moving it behind an internal boundary would leave an exported signature naming a type its callers cannot name.",
+      "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type is not reported when a reference from outside the target module reaches its values through its own package's exported declarations, as DS1501 defines that reach, because the referencing code holds values of the type, and moving it behind an internal boundary would leave an exported declaration naming a type its users cannot name.",
     details: { narrower_visibility: "required", name_literal: "optional" },
     defaultEnabled: true,
     defaultSeverity: "warn",

package/src/contract/report.generated.ts

@@ -408,6 +408,11 @@ export const REPORT_SCHEMAS = {
         },
         else: { properties: { configurations: { minItems: 1 }, target: { required: ["kind"] } } },
       },
+      {
+        if: { required: ["merged_from"], properties: { merged_from: { maxItems: 0 } } },
+        then: { properties: { analyzer: { properties: { languages: { maxItems: 0 } } } } },
+        else: { properties: { analyzer: { properties: { languages: { minItems: 1 } } } } },
+      },
     ],
     properties: {
       schema_version: { type: "string", pattern: "^[0-9]+\\.[0-9]+\\.[0-9]+$" },
@@ -424,7 +429,6 @@ export const REPORT_SCHEMAS = {
           },
           languages: {
             type: "array",
-            minItems: 1,
             uniqueItems: true,
             items: { type: "string", enum: ["go", "ts", "proto"] },
           },
@@ -460,7 +464,7 @@ export const REPORT_SCHEMAS = {
               pattern: "^[0-9]+\\.[0-9]+\\.[0-9]+(-[0-9A-Za-z.-]+)?(\\+[0-9A-Za-z.-]+)?$",
             },
             digest: { type: "string", pattern: "^sha256:[0-9a-f]{64}$" },
-            languages: { $ref: "#/properties/analyzer/properties/languages" },
+            languages: { $ref: "#/properties/analyzer/properties/languages", minItems: 1 },
             totals: { $ref: "#/properties/totals" },
           },
         },

package/src/dependencies.ts

@@ -29,6 +29,7 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
+import { amdLoadOf, amdPlatform } from "./amd.ts";
 import { automaticTypes, type AutomaticTypes } from "./automatic-types.ts";
 import {
   declaredIn as declaredBeside,
@@ -41,12 +42,13 @@ import {
 } from "./entries/configuration-files.ts";
 import type { FindingPosition } from "./finding.ts";
 import type { Host } from "./host.ts";
+import { declarationBindings } from "./import-bindings.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
 import { packageScope } from "./load/package-scope.ts";
 import {
   ancestors,
+  cannotStartPackageName,
   dirnamePath,
-  isAbsolutePath,
   joinPath,
   relativePath,
   resolvePath,
@@ -302,7 +304,7 @@ function configurationPackages(
     }
     seen.add(file);
     for (const entry of extendsOf(host, file, parse)) {
-      if (entry.startsWith(".") || isAbsolutePath(entry)) {
+      if (cannotStartPackageName(entry)) {
         const local = resolvePath(dirnamePath(file), entry);
         pending.push(local.endsWith(".json") ? local : `${local}.json`);
       } else {
@@ -332,26 +334,9 @@ function importOf(specifier: Node): Node | undefined {
 
 /** The local names one import declaration binds. */
 function bindingsOf(node: Node | undefined): readonly Texted[] {
-  if (node === undefined) {
-    return [];
-  }
-  if (isImportEqualsDeclaration(node)) {
-    return [node.name];
-  }
-  if (!isImportDeclaration(node) || node.importClause === undefined) {
-    return [];
-  }
-  const clause = node.importClause;
-  const names: Texted[] = clause.name === undefined ? [] : [clause.name];
-  const bindings = clause.namedBindings;
-  if (bindings !== undefined) {
-    if (bindings.kind === SyntaxKind.NamespaceImport) {
-      names.push(bindings.name);
-    } else {
-      names.push(...bindings.elements.map((element) => element.name));
-    }
-  }
-  return names;
+  return node !== undefined && (isImportDeclaration(node) || isImportEqualsDeclaration(node))
+    ? declarationBindings(node).map((binding) => binding.name)
+    : [];
 }
 
 /**
@@ -653,6 +638,7 @@ function fileNeeds<Brand>(
   }
   const loads = runtimeLoads(file);
   const callees = loads.flatMap((load) => load.callees);
+  const amdCallees = new Set(loads.flatMap((load) => (load.amd ? load.callees : [])));
 
   const asked = [
     ...specifiers,
@@ -748,11 +734,13 @@ function fileNeeds<Brand>(
       unansweredCallees.add(callee);
       return;
     }
-    // The decision reads the callee's symbol and its written name, and nothing else of it.
-    const key = symbol === undefined ? undefined : `${symbol.id}\u0000${callee.text}`;
+    // The decision reads the callee's symbol, its written name and its platform name, and nothing else.
+    const platform = amdCallees.has(callee) ? amdPlatform(callee) : "require";
+    const key =
+      symbol === undefined ? undefined : `${symbol.id}\u0000${platform}\u0000${callee.text}`;
     const answer =
       (key === undefined ? undefined : decided.get(key)) ??
-      callsPlatform(project, "require", callee, symbol, () => undefined);
+      callsPlatform(project, platform, callee, symbol);
     if (key !== undefined) {
       decided.set(key, answer);
     }
@@ -779,6 +767,8 @@ interface RuntimeLoad {
   readonly specifier: Texted;
   readonly named: string;
   readonly callees: readonly Identifier[];
+  /** Whether the specifier is an id of an AMD call's dependency list, its callee AMD's `define` or `require`. */
+  readonly amd: boolean;
 }
 
 /**
@@ -786,12 +776,21 @@ interface RuntimeLoad {
  * argument is literal text naming a package: a `require()` call, which the compiler lists among
  * a file's imports only in a JavaScript file and only through the bare name; a `.resolve` of
  * another name, which needs it where that name is a `require`; and `import.meta.resolve` or
- * a `.resolve` of the name `require`, whatever it names, a use where it stands.
+ * a `.resolve` of the name `require`, whatever it names, a use where it stands; and each id of
+ * an AMD dependency list (references-ts.37), which needs it where the call is AMD's.
  */
 function runtimeLoads(file: SourceFile): readonly RuntimeLoad[] {
   const found: RuntimeLoad[] = [];
   const visit = (node: Node): void => {
-    if (isCallExpression(node)) {
+    const amd = amdLoadOf(node);
+    if (amd !== undefined) {
+      for (const { id } of amd.ids) {
+        const named = packageOfSpecifier(id.text);
+        if (named !== undefined) {
+          found.push({ specifier: id, named, callees: [amd.callee], amd: true });
+        }
+      }
+    } else if (isCallExpression(node)) {
       const [argument] = node.arguments;
       if (argument !== undefined && isLiteralText(argument)) {
         const named = packageOfSpecifier(argument.text);
@@ -811,7 +810,7 @@ function runtimeLoads(file: SourceFile): readonly RuntimeLoad[] {
               receiver === undefined ? undefined : writtenName(receiver),
             ].filter((one) => one !== undefined);
         if (named !== undefined && (stands || callees.length > 0)) {
-          found.push({ specifier: argument, named, callees });
+          found.push({ specifier: argument, named, callees, amd: false });
         }
       }
     }

package/src/destructuring.ts

@@ -213,17 +213,6 @@ function sourceOf(target: Node): Source | undefined {
   }
 }
 
-/** What resolving one project's property reads cost at the client boundary. */
-interface DestructuringCost {
-  /** Batched type lookups, one per capped run of a file's patterns and assigned values. */
-  readonly patternBatches: number;
-  /**
-   * Per-type lookups: one property table per distinct destructured type, and each step
-   * an assignment target takes into its assigned value.
-   */
-  readonly patternLookups: number;
-}
-
 /** Resolves property reads to the symbols the destructured values' types declare. */
 interface Destructuring {
   /**
@@ -232,7 +221,6 @@ interface Destructuring {
    * {@link UNANSWERED} where a question about the value's type went unanswered.
    */
   resolve(reads: readonly PropertyRead[]): readonly Answer<TSSymbol | undefined>[];
-  readonly cost: DestructuringCost;
 }
 
 /** A type along a destructuring, or the mark that a question about it went unanswered. */
@@ -250,8 +238,6 @@ export function destructuring<Brand>(
 ): Destructuring {
   const queries = project.queries;
   const tables = new Map<number, Answer<ReadonlyMap<string, TSSymbol>>>();
-  let patternBatches = 0;
-  let patternLookups = 0;
 
   const tableOf = (type: Type): Answer<ReadonlyMap<string, TSSymbol>> => {
     const known = tables.get(type.id);
@@ -261,7 +247,6 @@ export function destructuring<Brand>(
     let table: Answer<ReadonlyMap<string, TSSymbol>> = new Map<string, TSSymbol>();
     if ((type.flags & TypeFlags.AnyOrUnknown) === 0) {
       const read = properties.of(type);
-      patternLookups += read.asked ? 1 : 0;
       table = isAnswered(read.properties)
         ? new Map(read.properties.map((property) => [property.name, property]))
         : UNANSWERED;
@@ -274,7 +259,6 @@ export function destructuring<Brand>(
     if ((type.flags & TypeFlags.Union) === 0) {
       return type;
     }
-    patternLookups += 1;
     return queries.nonNullable(type);
   };
 
@@ -290,11 +274,9 @@ export function destructuring<Brand>(
       if (index === undefined) {
         return undefined;
       }
-      patternLookups += 1;
       const elements = queries.typeArguments(type);
       return isAnswered(elements) ? elements[index] : UNANSWERED;
     }
-    patternLookups += 1;
     const array = queries.isArray(type);
     if (!isAnswered(array)) {
       return UNANSWERED;
@@ -302,7 +284,6 @@ export function destructuring<Brand>(
     if (!array) {
       return undefined;
     }
-    patternLookups += 1;
     const elements = queries.typeArguments(type);
     return isAnswered(elements) ? elements[0] : UNANSWERED;
   };
@@ -320,7 +301,6 @@ export function destructuring<Brand>(
     if (more.length > 0) {
       return UNANSWERED;
     }
-    patternLookups += 1;
     return queries.typeOfSymbol(property);
   };
 
@@ -328,7 +308,6 @@ export function destructuring<Brand>(
     if (callee === undefined || callee === UNANSWERED) {
       return callee;
     }
-    patternLookups += 1;
     const signatures = queries.signaturesOf(callee, SignatureKind.Call);
     if (!isAnswered(signatures)) {
       return UNANSWERED;
@@ -337,7 +316,6 @@ export function destructuring<Brand>(
     if (signature === undefined) {
       return undefined;
     }
-    patternLookups += 1;
     return queries.returnTypeOf(signature);
   };
 
@@ -369,7 +347,6 @@ export function destructuring<Brand>(
     if (result !== undefined && result !== UNANSWERED) {
       let parts: Answer<readonly Type[]> = [result];
       if (result.isUnionType()) {
-        patternLookups += 1;
         parts = queries.constituents(result);
       }
       const values: readonly Found[] = isAnswered(parts)
@@ -403,7 +380,6 @@ export function destructuring<Brand>(
       if (property === undefined) {
         return undefined;
       }
-      patternLookups += 1;
       return queries.typeOfSymbol(property);
     }
     return elementOf(defined, next.index);
@@ -425,7 +401,6 @@ export function destructuring<Brand>(
       }
     }
     const asked = [...asking];
-    patternBatches += Math.ceil(asked.length / cap);
     const answered = new Map<Node, Found>();
     queries.typesAt(asked, cap).forEach((type, index) => {
       const node = asked[index];
@@ -456,10 +431,5 @@ export function destructuring<Brand>(
     });
   };
 
-  return {
-    resolve,
-    get cost() {
-      return { patternBatches, patternLookups };
-    },
-  };
+  return { resolve };
 }