@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.10

package/src/configured-declarations.ts

@@ -19,7 +19,7 @@ import {
 import { SymbolFlags, type NodeHandle, type Symbol as TSSymbol } from "@typescript/native/sync";
 import type { AliasChains } from "./alias-chain.ts";
 import { resolvedTargets } from "./calls.ts";
-import type { Config, DeclarationEntry } from "./config.ts";
+import type { DeclarationEntry, ResolvedConfig } from "./config.ts";
 import { declaredComponent, type Inventory } from "./inventory.ts";
 import { must, Unanswerable } from "./query.ts";
 import { nameComponent } from "./ref.ts";
@@ -252,21 +252,21 @@ export function resolveEntries<Brand>(
   }
   const modules = modulesNamed(
     project,
-    new Set(entries.flatMap((entry) => (entry.shape === "module" ? [entry.module] : []))),
+    new Set(entries.flatMap((entry) => ("module" in entry ? [entry.module] : []))),
   );
   return entries.map((entry) => {
-    if (entry.shape === "symbol") {
+    if ("symbol" in entry) {
       return { entry, handles: new Set<string>(), ids: new Set(byRef.get(entry.symbol) ?? []) };
     }
     const { components, static: isStatic } = componentsOf(
-      entry.shape === "module" ? entry.name : entry.global,
+      "module" in entry ? entry.name : entry.global,
     );
     const [first = "", ...rest] = components;
     let start: TSSymbol | undefined;
     if (isStatic && rest.length === 0) {
       // Only a member is static, and a path of one component names no member.
       start = undefined;
-    } else if (entry.shape === "module") {
+    } else if ("module" in entry) {
       const module = modules.get(entry.module);
       start = module === undefined ? undefined : memberOf(project, module, first, false);
     } else if (nameComponent(first) === first) {
@@ -329,14 +329,10 @@ export function entriesAt<Brand>(
  * program the display name the inventory gives it.
  */
 export function spelledEntry(entry: DeclarationEntry, held: Inventory): string {
-  switch (entry.shape) {
-    case "symbol":
-      return held.symbols.find((symbol) => symbol.ref === entry.symbol)?.name ?? entry.symbol;
-    case "module":
-      return entry.name;
-    case "global":
-      return entry.global;
+  if ("symbol" in entry) {
+    return held.symbols.find((symbol) => symbol.ref === entry.symbol)?.name ?? entry.symbol;
   }
+  return "module" in entry ? entry.name : entry.global;
 }
 
 /** One entry of a configuration key that names a declaration, and the key's dotted path. */
@@ -353,14 +349,17 @@ const LIFECYCLE_KEY = "ts.lifecycle_contracts";
  * the injection registrations, each lifecycle contract's components and then its bases,
  * and the serializers.
  */
-export function configuredDeclarations(config: Config): readonly ConfiguredDeclaration[] {
+export function configuredDeclarations(config: ResolvedConfig): readonly ConfiguredDeclaration[] {
   return [
-    ...config.ts.injectionRegistrations.map((entry) => ({
+    ...config.ts.injection_registrations.map((entry) => ({
       key: "ts.injection_registrations",
       entry,
     })),
-    ...config.ts.lifecycleContracts.flatMap((contract) =>
-      [...contract.components, ...contract.bases].map((entry) => ({ key: LIFECYCLE_KEY, entry })),
+    ...config.ts.lifecycle_contracts.flatMap((contract) =>
+      [...(contract.components ?? []), ...(contract.bases ?? [])].map((entry) => ({
+        key: LIFECYCLE_KEY,
+        entry,
+      })),
     ),
     ...config.ts.serializers.map((entry) => ({ key: "ts.serializers", entry })),
   ];
@@ -396,12 +395,8 @@ export function declarationsNamed<Brand>(
  * sign and its name, and a global entry's path after a number sign.
  */
 export function configuredRef(entry: DeclarationEntry): string {
-  switch (entry.shape) {
-    case "symbol":
-      return entry.symbol;
-    case "module":
-      return `${entry.module}#${entry.name}`;
-    case "global":
-      return `#${entry.global}`;
+  if ("symbol" in entry) {
+    return entry.symbol;
   }
+  return "module" in entry ? `${entry.module}#${entry.name}` : `#${entry.global}`;
 }

package/src/conformance-record.ts

@@ -4,7 +4,7 @@ export const RECORD = {
   conformance: {
     corpusVersion: "6.0.0",
     result: "pass",
-    digest: "sha256:76c07ac14bda6e302444918d832b01844bac6f29b6f22a742d538804480c0769",
+    digest: "sha256:0d33564807a356fd3e2760ddaa0645d758bdb9a96ee74a392675e444343bbf20",
   },
   gaps: [],
 } as const;

package/src/consumers.ts

@@ -1,60 +1,9 @@
-/**
- * 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 type { Config } from "./config.ts";
-import { consumerProjects } from "./discover.ts";
+import type { PartialConfig } from "./config.ts";
 import type { Host } from "./host.ts";
-import { inventory, packageScope } from "./inventory.ts";
+import { inventory } from "./inventory.ts";
 import { relativePath } from "./paths.ts";
 import { references, type ConsumerSide, type Reference } from "./references.ts";
-import type { Module, Scope } from "./scope.ts";
-import { narrowedTo, type Engine, type ProjectView } from "./session.ts";
-
-/** One consumer the run loaded. */
-export interface LoadedConsumer {
-  /** The name the consumer publishes itself under, which every finding names it by. */
-  readonly id: string;
-  /** The consumer's directory, absolute. */
-  readonly path: string;
-}
-
-/** One declared consumer and the compiler configurations it opens as. */
-interface ConsumerLoad {
-  readonly consumer: LoadedConsumer;
-  /** The configuration files, absolute, in discovery order, none a target project's. */
-  readonly configFiles: readonly string[];
-}
-
-/** The name one module publishes itself under: the scope's, else its manifest's. */
-export function moduleIdentity(host: Host, module: Module): string {
-  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: Engine,
-  host: Host,
-  scope: Scope,
-  targetConfigFiles: readonly string[],
-): readonly ConsumerLoad[] {
-  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 { narrowedTo, type ProjectView } from "./session.ts";
 
 /**
  * Every reference one consumer project's own files make to a declaration of the target.
@@ -68,7 +17,7 @@ export function consumerReferences<Brand>(
   host: Host,
   targetRoot: string,
   consumer: ConsumerSide,
-  config: Config,
+  config: PartialConfig,
 ): readonly Reference[] {
   const held = inventory(
     narrowedTo(project, (file) => relativePath(targetRoot, file.fileName) !== undefined),
@@ -76,10 +25,10 @@ export function consumerReferences<Brand>(
     targetRoot,
   );
   const found = references(project, held, targetRoot, {
-    testFiles: config.ts.testFiles,
+    testFiles: config.ts.test_files,
     consumer,
   }).references;
-  if (config.analysis.consumerTests !== "production") {
+  if (config.analysis.consumer_tests !== "production") {
     return found;
   }
   return found.map((reference) => (reference.test ? { ...reference, test: false } : reference));

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 {
@@ -109,10 +110,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. */
@@ -287,6 +290,37 @@ 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 => {
@@ -379,9 +413,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 +459,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);
@@ -444,6 +480,8 @@ export function contextualUses<Brand>(
     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 +490,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)) {