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

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/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 };
 }