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

package/src/contextual-uses.ts

@@ -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 {
@@ -55,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;
 }
 
 /**
@@ -109,10 +106,12 @@ interface Checked {
   readonly source: Type;
   readonly targets: readonly Type[];
   /**
-   * Whether the source is declared outside the target, so code the analysis does not
-   * hold reads the members of the target's types it declares.
+   * What the source is: a type whose members the target declares, which the position
+   * reads; one declared outside the target, so code the analysis does not hold reads the
+   * members of the target's types it declares; or an object literal's own type, whose
+   * properties write the position's members of their names.
    */
-  readonly outside: boolean;
+  readonly sourceKind: "members" | "outside" | "literal";
 }
 
 /** One member of an object type, by the inventory's declarations and the checker's declaration handles. */
@@ -166,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. */
@@ -179,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()) {
@@ -198,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
@@ -219,7 +213,6 @@ export function contextualUses<Brand>(
   };
 
   const writes: ContextualUse[] = [];
-  batches += batchesOf(literals.length);
   const contexts = queries.contextualTypes(
     literals.map((one) => one.literal),
     cap,
@@ -235,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
     ? []
@@ -269,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,
@@ -287,17 +278,46 @@ export function contextualUses<Brand>(
     return members.length > 0 && members.every((member) => !member.own);
   };
 
+  const literalTypes = new Map<number, boolean>();
+  /**
+   * 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: Type): boolean => {
+    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: NodeHandle): Node | undefined => {
+    const node = project.declarationAt(handle)?.node;
+    return node !== undefined &&
+      (isPropertyAssignment(node) || isShorthandPropertyAssignment(node)) &&
+      isObjectLiteralExpression(node.parent)
+      ? node.name
+      : undefined;
+  };
+
   const elements = new Map<number, Type | undefined>();
   /** The element type of an array type, read once per type. */
   const elementOf = (type: Type): Type | undefined => {
     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;
     }
@@ -312,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);
@@ -329,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);
     }
@@ -342,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)),
@@ -379,9 +395,11 @@ export function contextualUses<Brand>(
     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) : [];
@@ -423,7 +441,7 @@ export function contextualUses<Brand>(
     }
     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);
@@ -438,12 +456,13 @@ 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,
   );
   const reads: ContextualUse[] = [];
+  // A literal property writes a position's members once, however many values carry it there.
+  const carriedWrites = new Set<string>();
   sourced.forEach(({ flow, type }, index) => {
     const position = positions[index];
     if (position === undefined || !isAnswered(position)) {
@@ -452,10 +471,24 @@ export function contextualUses<Brand>(
     const checked: Checked[] = [];
     compared(type, position, checked, new Set());
     const ids = new Set<string>();
-    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)) {
@@ -504,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,
@@ -531,5 +563,5 @@ export function contextualUses<Brand>(
       reads.push({ at: value, from, ids });
     }
   });
-  return { writes, reads, batches, lookups };
+  return { writes, reads };
 }