@alloy-js/core 0.11.0 → 0.13.0

package/test/symbols.test.ts

@@ -8,6 +8,7 @@ import {
   OutputSymbolFlags,
 } from "../src/binder.js";
 import { Refkey, refkey } from "../src/refkey.js";
+import { flushJobs } from "../src/scheduler.js";
 
 it("works", () => {
   const binder = createOutputBinder();
@@ -22,10 +23,11 @@ it("works", () => {
     scope,
   });
 
+  flushJobs();
   expect([...scope.getSymbolNames()]).toEqual(["sym"]);
 
   symbol.name = "bar";
-
+  flushJobs();
   expect([...scope.getSymbolNames()]).toEqual(["bar"]);
 });
 
@@ -47,7 +49,16 @@ it("resolves symbol conflicts", () => {
     scope,
   });
 
+  const s3 = binder.createSymbol({
+    name: "sym",
+    scope,
+  });
+
+  flushJobs();
+
+  expect(_s1.name).toEqual("sym");
   expect(s2.name).toEqual("sym_2");
+  expect(s3.name).toEqual("sym_3");
 });
 
 type ScopeRecords = Record<string, ScopeDescriptor>;
@@ -299,8 +310,25 @@ describe("instance members", () => {
 });
 
 describe("instantiating members", () => {
-  it("instantiates static symbols", () => {
+  it("instantiates instance members", () => {
     const binder = createOutputBinder();
+
+    /**
+     * The following structure would match code like this:
+     * ```ts
+     * // A class with instance members
+     * class Source {
+     *   instance() {
+     *     print("instance");
+     *   }
+     * }
+     *
+     * // Instantiates into t
+     * var t = new Source();
+     *
+     * t.instance();
+     * ```
+     */
     const {
       symbols: { rootSymbol, instance, instantiation },
     } = createScopeTree(binder, {
@@ -310,7 +338,7 @@ describe("instantiating members", () => {
             flags: OutputSymbolFlags.InstanceMemberContainer,
             instanceMembers: {
               instance: {
-                flags: OutputSymbolFlags.StaticMember,
+                flags: OutputSymbolFlags.InstanceMember,
               },
             },
           },
@@ -321,20 +349,107 @@ describe("instantiating members", () => {
 
     binder.instantiateSymbolInto(rootSymbol, instantiation);
     expect(
-      instantiation.flags & OutputSymbolFlags.InstanceMemberContainer,
+      instantiation.flags & OutputSymbolFlags.StaticMemberContainer,
     ).toBeTruthy();
-    expect(instantiation.instanceMemberScope).toBeDefined();
+    expect(instantiation.staticMemberScope).toBeDefined();
     const expectedRefkey = refkey(
       instantiation.refkeys[0],
       instance.refkeys[0],
     );
     expect(
-      instantiation.instanceMemberScope!.symbolsByRefkey.get(expectedRefkey),
+      instantiation.staticMemberScope!.symbolsByRefkey.get(expectedRefkey),
     ).toBeDefined();
   });
 
-  it("instantiates static symbols that are added after the instantiation", () => {
+  it("doesn't duplicate symbols", () => {
+    const binder = createOutputBinder();
+
+    const {
+      symbols: { rootSymbol, instantiation },
+    } = createScopeTree(binder, {
+      rootScope: {
+        symbols: {
+          rootSymbol: {
+            flags: OutputSymbolFlags.InstanceMemberContainer,
+            instanceMembers: {
+              instance: {
+                flags: OutputSymbolFlags.InstanceMember,
+              },
+            },
+          },
+          instantiation: {},
+        },
+      },
+    });
+
+    binder.instantiateSymbolInto(rootSymbol, instantiation);
+    flushJobs();
+    expect(instantiation.staticMemberScope!.symbols.size).toBe(1);
+
+    const lateKey = refkey();
+    // now add a brand‐new static member to source
+    binder.createSymbol({
+      name: "lateChild",
+      scope: rootSymbol.instanceMemberScope!,
+      refkey: lateKey,
+      flags: OutputSymbolFlags.InstanceMember,
+    });
+
+    flushJobs();
+
+    expect(rootSymbol.instanceMemberScope!.symbols.size).toBe(2);
+    expect(instantiation.staticMemberScope!.symbols.size).toBe(2);
+  });
+
+  it("should remove members in instance when source deleted them", () => {
+    const binder = createOutputBinder();
+
+    const {
+      symbols: { rootSymbol, instantiation },
+    } = createScopeTree(binder, {
+      rootScope: {
+        symbols: {
+          rootSymbol: {
+            flags: OutputSymbolFlags.InstanceMemberContainer,
+            instanceMembers: {
+              instance: {
+                flags: OutputSymbolFlags.InstanceMember,
+              },
+            },
+          },
+          instantiation: {},
+        },
+      },
+    });
+
+    binder.instantiateSymbolInto(rootSymbol, instantiation);
+    expect(instantiation.staticMemberScope!.symbols.size).toBe(1);
+
+    const lateKey = refkey();
+    // now add a brand‐new static member to source
+    binder.createSymbol({
+      name: "lateChild",
+      scope: rootSymbol.instanceMemberScope!,
+      refkey: lateKey,
+      flags: OutputSymbolFlags.InstanceMember,
+    });
+
+    flushJobs();
+
+    expect(rootSymbol.instanceMemberScope!.symbols.size).toBe(2);
+    expect(instantiation.staticMemberScope!.symbols.size).toBe(2);
+
+    binder.deleteSymbol(
+      rootSymbol.instanceMemberScope!.symbols.values().next().value!,
+    );
+    flushJobs();
+    expect(rootSymbol.instanceMemberScope!.symbols.size).toBe(1);
+    expect(instantiation.staticMemberScope!.symbols.size).toBe(1);
+  });
+
+  it("instantiates instance members added after the instantiation", () => {
     const binder = createOutputBinder();
+
     const {
       symbols: { rootSymbol, instance, instantiation },
     } = createScopeTree(binder, {
@@ -344,7 +459,7 @@ describe("instantiating members", () => {
             flags: OutputSymbolFlags.InstanceMemberContainer,
             instanceMembers: {
               instance: {
-                flags: OutputSymbolFlags.StaticMember,
+                flags: OutputSymbolFlags.InstanceMember,
               },
             },
           },
@@ -354,16 +469,17 @@ describe("instantiating members", () => {
     });
 
     binder.instantiateSymbolInto(rootSymbol, instantiation);
+    flushJobs();
     expect(
-      instantiation.flags & OutputSymbolFlags.InstanceMemberContainer,
+      instantiation.flags & OutputSymbolFlags.StaticMemberContainer,
     ).toBeTruthy();
-    expect(instantiation.instanceMemberScope).toBeDefined();
+    expect(instantiation.staticMemberScope).toBeDefined();
     const expectedRefkey = refkey(
       instantiation.refkeys[0],
       instance.refkeys[0],
     );
     expect(
-      instantiation.instanceMemberScope!.symbolsByRefkey.get(expectedRefkey),
+      instantiation.staticMemberScope!.symbolsByRefkey.get(expectedRefkey),
     ).toBeDefined();
 
     const newInstanceMemberRefkey = refkey();
@@ -377,10 +493,280 @@ describe("instantiating members", () => {
       instantiation.refkeys[0],
       newInstanceMemberRefkey,
     );
+    flushJobs();
+    expect(
+      instantiation.staticMemberScope!.symbolsByRefkey.get(newExpectedRefkey),
+    ).toBeDefined();
+  });
+
+  it("instantiates static symbols for a static container source", () => {
+    const binder = createOutputBinder();
+
+    /**
+     * The following structure would match code like this:
+     * ```ts
+     * // A class with instance members
+     * class Source {
+     *   static child() {
+     *     print("child");
+     *   }
+     * }
+     *
+     *
+     * var printChild = Source.child;
+     *
+     * printChild();
+     * ```
+     */
+    const {
+      symbols: { source, child, target },
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          source: {
+            flags: OutputSymbolFlags.StaticMemberContainer,
+            staticMembers: {
+              child: { flags: OutputSymbolFlags.StaticMember },
+            },
+          },
+          target: {},
+        },
+      },
+    });
+
+    binder.instantiateSymbolInto(source, target);
+
+    // target must now be a StaticMemberContainer too
+    expect(target.flags & OutputSymbolFlags.StaticMemberContainer).toBeTruthy();
+    expect(target.staticMemberScope).toBeDefined();
+
+    const expectedKey = refkey(target.refkeys[0], child.refkeys[0]);
+    expect(
+      target.staticMemberScope!.symbolsByRefkey.get(expectedKey),
+    ).toBeDefined();
+  });
+
+  it("instantiates static symbols added after instantiation", () => {
+    const binder = createOutputBinder();
+    const lateKey = refkey();
+
+    const {
+      symbols: { source, target },
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          source: {
+            flags: OutputSymbolFlags.StaticMemberContainer,
+          },
+          target: {},
+        },
+      },
+    });
+
+    // hook up instantiation
+    binder.instantiateSymbolInto(source, target);
+
+    // now add a brand‐new static member to source
+    const late = binder.createSymbol({
+      name: "lateChild",
+      scope: source.staticMemberScope!,
+      refkey: lateKey,
+      flags: OutputSymbolFlags.StaticMember,
+    });
+
+    flushJobs();
+
+    // it should *automatically* show up on target.staticMemberScope
+    const expectedKey = refkey(target.refkeys[0], late.refkeys[0]);
     expect(
-      instantiation.instanceMemberScope!.symbolsByRefkey.get(newExpectedRefkey),
+      target.staticMemberScope!.symbolsByRefkey.get(expectedKey),
     ).toBeDefined();
   });
+
+  it("recursively instantiates nested static members", () => {
+    const binder = createOutputBinder();
+
+    /**
+     * The following structure would match code like this:
+     * ```ts
+     *   class Source {
+     *     static Level1 = class {
+     *       static level2() { print("deep"); }
+     *     }
+     *   }
+     *
+     *   var target = Source;
+     *
+     *   target.Level1.level2()
+     * ```
+     */
+    const {
+      symbols: { source, level1, level2, target },
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          source: {
+            flags: OutputSymbolFlags.StaticMemberContainer,
+            staticMembers: {
+              level1: {
+                flags:
+                  OutputSymbolFlags.StaticMember |
+                  OutputSymbolFlags.StaticMemberContainer,
+                staticMembers: {
+                  level2: { flags: OutputSymbolFlags.StaticMember },
+                },
+              },
+            },
+          },
+          target: {},
+        },
+      },
+    });
+
+    binder.instantiateSymbolInto(source, target);
+
+    // level1 should appear under target.staticMemberScope
+    const key1 = refkey(target.refkeys[0], level1.refkeys[0]);
+    const instantiated1 = target.staticMemberScope!.symbolsByRefkey.get(key1)!;
+    expect(instantiated1.name).toBe(level1.name);
+
+    // and level2 should appear under the *child* staticMemberScope of that instantiated level1
+    const childScope = instantiated1.staticMemberScope!;
+    const key2 = refkey(instantiated1.refkeys[0], level2.refkeys[0]);
+    expect(childScope.symbolsByRefkey.get(key2)).toBeDefined();
+  });
+
+  it("copies both instance *and* static members when source has both flags", () => {
+    const binder = createOutputBinder();
+
+    /**
+     * ```ts
+     *   class Source {
+     *     instance() { print("inst"); }
+     *     static s1()  { print("static"); }
+     *   }
+     *
+     *   let t = new Source()
+     *   t.instance()
+     *   t.s1()
+     * ```
+     */
+    const {
+      symbols: { source, inst },
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          source: {
+            flags:
+              OutputSymbolFlags.InstanceMemberContainer |
+              OutputSymbolFlags.StaticMemberContainer,
+            instanceMembers: {
+              i1: { flags: OutputSymbolFlags.InstanceMember },
+            },
+            staticMembers: {
+              s1: { flags: OutputSymbolFlags.StaticMember },
+            },
+          },
+          inst: {},
+        },
+      },
+    });
+
+    binder.instantiateSymbolInto(source, inst);
+
+    expect(inst.staticMemberScope).toBeDefined();
+    expect(
+      [...inst.staticMemberScope!.symbols].some((s) => s.name === "i1"),
+    ).toBe(true);
+
+    // static side
+    const symbols = [...source.staticMemberScope!.symbols];
+    expect(inst.staticMemberScope).toBeDefined();
+    const sKey = refkey(inst.refkeys[0], symbols[0].refkeys[0]);
+    expect(inst.staticMemberScope!.symbolsByRefkey.has(sKey)).toBe(true);
+  });
+
+  it("is idempotent, calling twice does not duplicate", () => {
+    const binder = createOutputBinder();
+    const {
+      symbols: { source, target },
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          source: {
+            flags: OutputSymbolFlags.StaticMemberContainer,
+            staticMembers: {
+              a: { flags: OutputSymbolFlags.StaticMember },
+            },
+          },
+          target: {},
+        },
+      },
+    });
+
+    binder.instantiateSymbolInto(source, target);
+    flushJobs();
+    const initialCount = target.staticMemberScope!.symbols.size;
+    binder.instantiateSymbolInto(source, target);
+    flushJobs();
+    expect(target.staticMemberScope!.symbols.size).toBe(initialCount);
+  });
+
+  it("instantiates static children of instance members under the instance scope", () => {
+    const binder = createOutputBinder();
+    /**
+     * ```ts
+     *    class Source {
+     *     instM = class {
+     *       static deep() { print("deep"); }
+     *     }
+     *    }
+     *
+     *   var t = new Source();
+     *   t.instM.deep();
+     * ```
+     */
+    const {
+      symbols: { source, deep, target },
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          source: {
+            flags: OutputSymbolFlags.InstanceMemberContainer,
+            instanceMembers: {
+              instM: {
+                flags:
+                  OutputSymbolFlags.InstanceMember |
+                  OutputSymbolFlags.StaticMemberContainer,
+                staticMembers: {
+                  deep: { flags: OutputSymbolFlags.StaticMember },
+                },
+              },
+            },
+          },
+          target: {},
+        },
+      },
+    });
+
+    binder.instantiateSymbolInto(source, target);
+
+    // Find the instantiated copy of instM under target.instanceMemberScope
+    const instMSym = [...target.staticMemberScope!.symbols].find(
+      (s) => s.name === "instM",
+    )!;
+
+    // instMSym should have gotten its own staticMemberScope via the StaticMemberContainer flag
+    expect(instMSym.staticMemberScope).toBeDefined();
+
+    // compute the expected key for the deep child:
+    //    (<target>, <instM>)  then (on that)  (<deep original>)
+    const expectedDeepKey = refkey(instMSym.refkeys[0], deep.refkeys[0]);
+
+    expect(
+      instMSym.staticMemberScope!.symbolsByRefkey.has(expectedDeepKey),
+    ).toBe(true);
+  });
 });
 
 describe("symbol name resolution", () => {
@@ -540,6 +926,7 @@ describe("refkey resolution", () => {
     expect(resolvedSym.value).toBe(undefined);
 
     sym.refkeys[0] = key;
+    flushJobs();
     expect(resolvedSym.value?.targetDeclaration).toBe(sym);
   });
 });
@@ -563,10 +950,11 @@ describe("Deleting symbols", () => {
     expect(resolvedSym.value).toBe(undefined);
 
     sym.refkeys[0] = key;
+    flushJobs();
     expect(resolvedSym.value?.targetDeclaration).toBe(sym);
 
     binder.deleteSymbol(sym);
-
+    flushJobs();
     expect(resolvedSym.value).toBe(undefined);
   });
 

package/test/utils.test.tsx

@@ -2,6 +2,7 @@ import { Children } from "@alloy-js/core/jsx-runtime";
 import { computed, ref, triggerRef } from "@vue/reactivity";
 import { describe, expect, it } from "vitest";
 import { renderTree } from "../src/render.js";
+import { flushJobs } from "../src/scheduler.js";
 import { children, join, mapJoin } from "../src/utils.js";
 import "../testing/extend-expect.js";
 
@@ -93,6 +94,7 @@ describe("mapJoin", () => {
     expect(callCount).toBe(2);
     arr.value.push(3);
     triggerRef(arr);
+    flushJobs();
     expect(callCount).toBe(3);
   });
   it("can map a joiner", () => {