@tsplc/compiler 0.0.0-stage → 0.1.0

package/src/frontend/elaborate/model.ts

@@ -0,0 +1,177 @@
+import ts from "typescript";
+import type { CapturedGraph, CapturedNode, CapturedValue } from "./graph.ts";
+
+/** One step from an owner to the object it holds. */
+export type Step = { kind: "field"; name: string } | { kind: "index"; index: number };
+
+/** Where a captured object is stored: a root binding and the steps to it. */
+export interface Owner {
+  root: Root;
+  steps: readonly Step[];
+}
+
+export interface Root {
+  file: string;
+  name: string;
+  declaration: ts.VariableDeclaration;
+  exported: boolean;
+}
+
+export interface ModelNode {
+  id: number;
+  captured: CapturedNode;
+  /** The declared type where the object is stored; undefined for functions and services. */
+  type?: ts.Type;
+  /** The first place setup reached it. Every other place holding it refers to this one. */
+  owner?: Owner;
+}
+
+/** The captured setup graph with each object's owner and declared type. */
+export class Model {
+  readonly nodes: ModelNode[];
+  readonly roots: Root[] = [];
+  readonly rootValues = new Map<Root, CapturedValue>();
+
+  constructor(
+    readonly graph: CapturedGraph,
+    readonly checker: ts.TypeChecker,
+    readonly program: ts.Program,
+    entry: string,
+  ) {
+    this.nodes = graph.nodes.map((captured, id) => ({ id, captured }));
+    // Dependencies own what they build before the entry module's instances refer to it.
+    const ordered = [
+      ...graph.bindings.filter((binding) => binding.file !== entry),
+      ...graph.bindings.filter((binding) => binding.file === entry),
+    ];
+    for (const binding of ordered) {
+      const declaration = this.binding(binding.file, binding.name);
+      const root: Root = {
+        file: binding.file,
+        name: binding.name,
+        declaration,
+        exported: Boolean(ts.getCombinedModifierFlags(declaration) & ts.ModifierFlags.Export),
+      };
+      this.roots.push(root);
+      this.rootValues.set(root, binding.value);
+      this.own(binding.value, { root, steps: [] }, checker.getTypeAtLocation(declaration.name));
+    }
+  }
+
+  node(value: CapturedValue): ModelNode | undefined {
+    return value.kind === "node" ? this.nodes[value.id] : undefined;
+  }
+
+  private binding(file: string, name: string): ts.VariableDeclaration {
+    const source = this.program.getSourceFile(file);
+    for (const statement of source?.statements ?? [])
+      if (ts.isVariableStatement(statement))
+        for (const declaration of statement.declarationList.declarations)
+          if (ts.isIdentifier(declaration.name) && declaration.name.text === name)
+            return declaration;
+    throw new Error(`${file}: no module binding ${name}.`);
+  }
+
+  /** The class a captured instance belongs to. */
+  classOf(node: ModelNode): ts.ClassDeclaration {
+    const captured = node.captured;
+    if (captured.kind !== "instance") throw new Error("Not a class instance.");
+    const source = this.program.getSourceFile(captured.file);
+    const found = source?.statements.find(
+      (statement): statement is ts.ClassDeclaration =>
+        ts.isClassDeclaration(statement) && statement.name?.text === captured.name,
+    );
+    if (!found) throw new Error(`${captured.file}: no class ${captured.name}.`);
+    return found;
+  }
+
+  /** A class field's declaration: a property, or a constructor parameter property. */
+  member(
+    declaration: ts.ClassDeclaration,
+    name: string,
+  ): ts.PropertyDeclaration | ts.ParameterDeclaration | undefined {
+    for (const member of declaration.members) {
+      if (ts.isPropertyDeclaration(member) && member.name.getText() === name) return member;
+      if (ts.isConstructorDeclaration(member))
+        for (const parameter of member.parameters)
+          if (
+            ts.isParameterPropertyDeclaration(parameter, member) &&
+            parameter.name.getText() === name
+          )
+            return parameter;
+    }
+    return undefined;
+  }
+
+  /** The declared type of a field of `type` holding `value`, choosing the union member it matches. */
+  fieldType(type: ts.Type, name: string, holder: CapturedNode): ts.Type | undefined {
+    const variant = this.variant(type, holder);
+    const property = variant.getProperty(name) ?? this.checker.getPropertyOfType(variant, name);
+    return property && this.checker.getTypeOfSymbol(property);
+  }
+
+  /** The member of a union of object types that a captured object is, by its literal fields. */
+  variant(type: ts.Type, value: CapturedNode): ts.Type {
+    const candidates = (type.isUnion() ? type.types : [type]).filter(
+      (member) => !(member.flags & ts.TypeFlags.Undefined),
+    );
+    if (candidates.length === 1 || value.kind !== "object") return candidates[0] ?? type;
+    return (
+      candidates.find((candidate) =>
+        Object.entries(value.fields).every(([name, field]) => {
+          const property = candidate.getProperty(name);
+          if (!property) return false;
+          const fieldType = this.checker.getTypeOfSymbol(property);
+          return (
+            !fieldType.isLiteral() || field.kind !== "string" || fieldType.value === field.value
+          );
+        }),
+      ) ?? candidates[0]!
+    );
+  }
+
+  elementType(type: ts.Type): ts.Type | undefined {
+    const target = this.checker.getNonNullableType(type);
+    return (
+      this.checker.getIndexTypeOfType(target, ts.IndexKind.Number) ??
+      (this.checker.isTupleType(target)
+        ? this.checker.getTypeArguments(target as ts.TypeReference)[0]
+        : undefined)
+    );
+  }
+
+  private own(value: CapturedValue, owner: Owner, type: ts.Type | undefined): void {
+    const node = this.node(value);
+    if (!node || node.owner) return;
+    node.owner = owner;
+    node.type = type;
+    const captured = node.captured;
+    if (captured.kind === "array") {
+      const element = type && this.elementType(type);
+      captured.items.forEach((item, index) =>
+        this.own(
+          item,
+          { root: owner.root, steps: [...owner.steps, { kind: "index", index }] },
+          element,
+        ),
+      );
+    } else if (captured.kind === "object") {
+      for (const [name, field] of Object.entries(captured.fields))
+        this.own(
+          field,
+          { root: owner.root, steps: [...owner.steps, { kind: "field", name }] },
+          type && this.fieldType(type, name, captured),
+        );
+    } else if (captured.kind === "instance") {
+      const declaration = this.classOf(node);
+      for (const [name, field] of Object.entries(captured.fields)) {
+        const member = this.member(declaration, name);
+        this.own(
+          field,
+          { root: owner.root, steps: [...owner.steps, { kind: "field", name }] },
+          member && this.checker.getTypeAtLocation(member.name),
+        );
+      }
+    }
+  }
+}