@alloy-js/core 0.15.0 → 0.17.0

package/dist/test/symbols/output-symbol.test.js

@@ -0,0 +1,446 @@
+import { reactive, watch } from "@vue/reactivity";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createOutputBinder } from "../../src/binder.js";
+import { ScopeContext } from "../../src/index.browser.js";
+import { renderTree } from "../../src/render.js";
+import { flushJobs } from "../../src/scheduler.js";
+import { OutputScope, OutputScopeFlags } from "../../src/symbols/output-scope.js";
+import { OutputSymbol, OutputSymbolFlags } from "../../src/symbols/output-symbol.js";
+import { MemberScopeContext } from "../../src/context/member-scope.js";
+let binder;
+beforeEach(() => {
+  binder = createOutputBinder();
+});
+describe("OutputSymbol reactivity", () => {
+  it("keeps symbol names up-to-date", () => {
+    const scope = new OutputScope("scope", {
+      binder
+    });
+    const symbol = new OutputSymbol("sym", {
+      binder,
+      scope
+    });
+    flushJobs();
+    expect(scope.symbolNames.has("sym")).toBe(true);
+    symbol.name = "bar";
+    flushJobs();
+    expect(scope.symbolNames.has("bar")).toBe(true);
+  });
+  it("resolves symbol conflicts", () => {
+    const scope = new OutputScope("scope", {
+      binder
+    });
+    const s1 = new OutputSymbol("sym", {
+      binder,
+      scope
+    });
+    const s2 = new OutputSymbol("sym", {
+      binder,
+      scope
+    });
+    const s3 = new OutputSymbol("sym", {
+      binder,
+      scope
+    });
+    flushJobs();
+    expect(s1.name).toEqual("sym");
+    expect(s2.name).toEqual("sym_2");
+    expect(s3.name).toEqual("sym_3");
+  });
+  it("is reactive on name, flags, scope, instanceMemberScope, and staticMemberScope", () => {
+    const scope = new OutputScope("scope", {
+      binder
+    });
+    const symbol = new OutputSymbol("sym", {
+      binder,
+      scope
+    });
+    const nameSpy = vi.fn();
+    watch(() => symbol.name, nameSpy);
+    const flagsSpy = vi.fn();
+    watch(() => symbol.flags, flagsSpy);
+    const scopeSpy = vi.fn();
+    watch(() => symbol.scope, scopeSpy);
+    const instanceMemberScopeSpy = vi.fn();
+    watch(() => symbol.instanceMemberScope, instanceMemberScopeSpy);
+    const staticMemberScopeSpy = vi.fn();
+    watch(() => symbol.staticMemberScope, staticMemberScopeSpy);
+    symbol.name = "foo";
+    symbol.flags = 0;
+    symbol.scope = new OutputScope("new-scope", {
+      binder
+    });
+    symbol.flags |= OutputSymbolFlags.InstanceMemberContainer | OutputSymbolFlags.StaticMemberContainer;
+    expect(nameSpy).toHaveBeenCalled();
+    expect(flagsSpy).toHaveBeenCalled();
+    expect(scopeSpy).toHaveBeenCalled();
+    expect(instanceMemberScopeSpy).toHaveBeenCalled();
+    expect(staticMemberScopeSpy).toHaveBeenCalled();
+  });
+  it("doesn't get wrapped in a reactive proxy", () => {
+    const scope = new OutputScope("scope", {
+      binder
+    });
+    const symbol = new OutputSymbol("sym", {
+      binder,
+      scope
+    });
+    const rSymbol = reactive(symbol);
+    expect(rSymbol).toBe(symbol);
+  });
+});
+describe("OutputSymbol#flags", () => {
+  it("sets member flags based on parent scope", () => {
+    const scope = new OutputScope("scope", {
+      binder
+    });
+    const symbol = new OutputSymbol("sym", {
+      binder,
+      scope
+    });
+    expect(symbol.flags & OutputSymbolFlags.Member).toBeFalsy();
+    const memberScope = new OutputScope("member-scope", {
+      binder,
+      owner: symbol,
+      flags: OutputScopeFlags.InstanceMemberScope
+    });
+    const memberSymbol = new OutputSymbol("member-sym", {
+      binder,
+      scope: memberScope
+    });
+    expect(memberSymbol.flags & OutputSymbolFlags.InstanceMember).toBeTruthy();
+  });
+});
+describe("OutputSymbol#staticMemberScope", () => {
+  it("is created when needed", () => {
+    const scope = new OutputScope("scope", {
+      binder
+    });
+    const symbol = new OutputSymbol("sym", {
+      binder,
+      scope,
+      flags: OutputSymbolFlags.StaticMemberContainer
+    });
+    expect(symbol.staticMemberScope).toBeDefined();
+    expect(symbol.staticMemberScope.symbols.size).toEqual(0);
+  });
+});
+describe("OutputSymbol#instanceMemberScope", () => {
+  it("is created when needed", () => {
+    const scope = new OutputScope("scope", {
+      binder
+    });
+    const symbol = new OutputSymbol("sym", {
+      binder,
+      scope,
+      flags: OutputSymbolFlags.InstanceMemberContainer
+    });
+    expect(symbol.instanceMemberScope).toBeDefined();
+    expect(symbol.instanceMemberScope.symbols.size).toEqual(0);
+  });
+});
+describe("OutputSymbol#metadata", () => {
+  it("is reactive", () => {
+    const scope = new OutputScope("scope", {
+      binder
+    });
+    const symbol = new OutputSymbol("sym", {
+      binder,
+      scope,
+      metadata: {
+        foo: "bar"
+      }
+    });
+    const metadataSpy = vi.fn();
+    watch(() => symbol.metadata.foo, metadataSpy);
+    symbol.metadata.foo = "baz";
+    expect(metadataSpy).toHaveBeenCalled();
+    expect(symbol.metadata.foo).toEqual("baz");
+  });
+});
+describe("OutputSymbol#scope", () => {
+  it("adds to parent scope", () => {
+    const scope = new OutputScope("parent", {
+      binder
+    });
+    const symbol = new OutputSymbol("sym", {
+      binder,
+      scope
+    });
+    expect(scope.symbols.has(symbol)).toBe(true);
+  });
+  it("defaults to the current lexical scope when not a member", () => {
+    const scope = new OutputScope("parent", {
+      binder
+    });
+    withContext([[ScopeContext, scope]], () => {
+      const symbol = new OutputSymbol("sym", {
+        binder
+      });
+      expect(scope.symbols.has(symbol)).toBe(true);
+    });
+  });
+  it("defaults to the current member scope when a member", () => {
+    const symbol = new OutputSymbol("Class", {
+      binder,
+      scope: binder.globalScope,
+      flags: OutputSymbolFlags.MemberContainer
+    });
+    withContext([[MemberScopeContext, {
+      instanceMembers: symbol.instanceMemberScope,
+      staticMembers: symbol.staticMemberScope
+    }]], () => {
+      const ms = new OutputSymbol("ms", {
+        binder,
+        flags: OutputSymbolFlags.InstanceMember
+      });
+      const ss = new OutputSymbol("ss", {
+        binder,
+        flags: OutputSymbolFlags.StaticMember
+      });
+      expect(symbol.instanceMemberScope.symbols.has(ms)).toBe(true);
+      expect(symbol.staticMemberScope.symbols.has(ss)).toBe(true);
+    });
+  });
+});
+function withContext(contexts, fn) {
+  let children = fn;
+  for (let i = 0; i < contexts.length; i++) {
+    const [context, value] = contexts[i];
+    children = context.ProviderStc({
+      value
+    }).children(children);
+  }
+  renderTree(children);
+}
+describe("Symbol#delete", () => {
+  it("deletes from parent scope", () => {
+    const scope = new OutputScope("parent", {
+      binder
+    });
+    const symbol = new OutputSymbol("sym", {
+      binder,
+      scope
+    });
+    expect(scope.symbols.has(symbol)).toBe(true);
+    symbol.delete();
+    expect(scope.symbols.has(symbol)).toBe(false);
+  });
+  it("updates resolution");
+});
+describe("OutputSymbol#cloneInto", () => {
+  it("copies values and propagates updates", () => {
+    const scope = new OutputScope("scope", {
+      binder
+    });
+    const scope2 = new OutputScope("scope2", {
+      binder
+    });
+    const symbol = new OutputSymbol("sym", {
+      binder,
+      scope
+    });
+    const clone = symbol.copyToScope(scope2);
+    expect(clone.name).toEqual("sym");
+    expect(clone.flags).toEqual(symbol.flags);
+    expect(clone.originalName).toEqual(symbol.originalName);
+    symbol.name = "bar";
+    symbol.flags = OutputSymbolFlags.InstanceMemberContainer;
+    flushJobs();
+    expect(clone.name).toEqual("bar");
+    expect(clone.flags).toEqual(OutputSymbolFlags.InstanceMemberContainer);
+  });
+  it("works simply", () => {
+    const scope = new OutputScope("scope", {
+      binder
+    });
+    const symbol = new OutputSymbol("sym", {
+      binder,
+      scope,
+      flags: OutputSymbolFlags.StaticMemberContainer
+    });
+    const sourceStaticMember = new OutputSymbol("static-member", {
+      binder,
+      scope: symbol.staticMemberScope
+    });
+    const scope2 = new OutputScope("scope2", {
+      binder
+    });
+    const clone = symbol.copyToScope(scope2);
+    expect(clone.staticMemberScope.symbols.size).toBe(1);
+    sourceStaticMember.delete();
+    flushJobs();
+    expect(clone.staticMemberScope.symbols.size).toBe(0);
+  });
+  it("clones instance and static member scopes", () => {
+    const scope = new OutputScope("scope", {
+      binder
+    });
+    const symbol = new OutputSymbol("sym", {
+      binder,
+      scope,
+      flags: OutputSymbolFlags.MemberContainer
+    });
+    const sourceStaticMember = new OutputSymbol("static-member", {
+      binder,
+      scope: symbol.staticMemberScope,
+      flags: OutputSymbolFlags.StaticMemberContainer
+    });
+    const sourceInstanceMember = new OutputSymbol("instance-member", {
+      binder,
+      scope: symbol.instanceMemberScope
+    });
+    const scope2 = new OutputScope("scope2", {
+      binder
+    });
+    const clone = symbol.copyToScope(scope2);
+    expect(clone.instanceMemberScope).toBeDefined();
+    expect(clone.staticMemberScope).toBeDefined();
+    const clonedStaticMember = [...clone.staticMemberScope.symbols][0];
+    expect(clonedStaticMember.name).toBe("static-member");
+    expect(clonedStaticMember).toBeDefined();
+    expect(clonedStaticMember.flags).toBe(sourceStaticMember.flags);
+    const clonedInstanceMember = [...clone.instanceMemberScope.symbols][0];
+    expect(clonedInstanceMember.name).toBe("instance-member");
+    expect(clonedInstanceMember).toBeDefined();
+    expect(clonedInstanceMember.flags).toBe(sourceInstanceMember.flags);
+    expect(clonedInstanceMember.staticMemberScope).toBeUndefined();
+
+    // test reactivity
+    const newStaticSym = new OutputSymbol("new-sym", {
+      binder,
+      scope: symbol.staticMemberScope
+    });
+    const newInstanceSym = new OutputSymbol("new-sym", {
+      binder,
+      scope: symbol.instanceMemberScope
+    });
+    flushJobs();
+    expect(clone.staticMemberScope.symbolNames.has("new-sym")).toBe(true);
+    expect(clone.instanceMemberScope.symbolNames.has("new-sym")).toBe(true);
+    newStaticSym.delete();
+    newInstanceSym.delete();
+    flushJobs();
+    expect(clone.staticMemberScope.symbolNames.has("new-sym")).toBe(false);
+    expect(clone.instanceMemberScope.symbolNames.has("new-sym")).toBe(false);
+  });
+});
+describe("OutputSymbol#instantiateInto", () => {
+  it("copies instance members to static member scope", () => {
+    const scope = new OutputScope("scope", {
+      binder
+    });
+    const classSym = new OutputSymbol("Class", {
+      binder,
+      scope,
+      flags: OutputSymbolFlags.MemberContainer
+    });
+    new OutputSymbol("instance-member", {
+      binder,
+      scope: classSym.instanceMemberScope
+    });
+    new OutputSymbol("static-member", {
+      binder,
+      scope: classSym.staticMemberScope
+    });
+    const targetSym = new OutputSymbol("Target", {
+      binder,
+      scope
+    });
+    classSym.instantiateTo(targetSym);
+    expect(targetSym.staticMemberScope).toBeDefined();
+    const staticNames = targetSym.staticMemberScope.symbolNames;
+    expect(staticNames.size).toEqual(1);
+    expect(staticNames.has("instance-member")).toBe(true);
+    const instantiatedSym = [...targetSym.staticMemberScope.symbols][0];
+    expect(instantiatedSym.flags & OutputSymbolFlags.StaticMember).toBeTruthy();
+  });
+  it("is reactive to new instance members", () => {
+    const scope = new OutputScope("scope", {
+      binder
+    });
+    const classSym = new OutputSymbol("Class", {
+      binder,
+      scope,
+      flags: OutputSymbolFlags.MemberContainer
+    });
+    new OutputSymbol("instance-member", {
+      binder,
+      scope: classSym.instanceMemberScope
+    });
+    const targetSym = new OutputSymbol("Target", {
+      binder,
+      scope
+    });
+    classSym.instantiateTo(targetSym);
+    new OutputSymbol("new-instance-member", {
+      binder,
+      scope: classSym.instanceMemberScope
+    });
+    expect(targetSym.staticMemberScope.symbolNames.has("new-instance-member")).toBeDefined();
+    expect(targetSym.instanceMemberScope).toBeUndefined();
+  });
+  it("copies static members of instance members", () => {
+    const scope = new OutputScope("scope", {
+      binder
+    });
+    const classSym = new OutputSymbol("Class", {
+      binder,
+      scope,
+      flags: OutputSymbolFlags.MemberContainer
+    });
+    const instanceMemberSym = new OutputSymbol("instance-member", {
+      binder,
+      scope: classSym.instanceMemberScope,
+      flags: OutputSymbolFlags.StaticMemberContainer
+    });
+    new OutputSymbol("static-of-instance", {
+      binder,
+      scope: instanceMemberSym.staticMemberScope
+    });
+    const targetSym = new OutputSymbol("Target", {
+      binder,
+      scope
+    });
+    classSym.instantiateTo(targetSym);
+    expect(targetSym.staticMemberScope.symbolNames.has("instance-member")).toBeTruthy();
+    expect(targetSym.instanceMemberScope).toBeUndefined();
+    const instantiatedSS = [...targetSym.staticMemberScope.symbols][0];
+    expect(instantiatedSS.staticMemberScope).toBeDefined();
+    expect(instantiatedSS.staticMemberScope.symbolNames.has("static-of-instance")).toBeTruthy();
+
+    // check reactivity
+    const newSym = new OutputSymbol("new-static-of-instance", {
+      binder,
+      scope: instanceMemberSym.staticMemberScope
+    });
+    flushJobs();
+    expect(instantiatedSS.staticMemberScope.symbolNames.has("new-static-of-instance")).toBeTruthy();
+    newSym.delete();
+    flushJobs();
+    expect(instantiatedSS.staticMemberScope.symbolNames.has("static-member-2")).toBeFalsy();
+  });
+  it("is idempotent", () => {
+    const scope = new OutputScope("scope", {
+      binder
+    });
+    const source = new OutputSymbol("sym", {
+      binder,
+      scope,
+      flags: OutputSymbolFlags.InstanceMemberContainer
+    });
+    new OutputSymbol("instance-member", {
+      binder,
+      scope: source.instanceMemberScope
+    });
+    const target = new OutputSymbol("target", {
+      binder,
+      scope
+    });
+    source.instantiateTo(target);
+    source.instantiateTo(target);
+    expect(target.staticMemberScope).toBeDefined();
+    expect(target.staticMemberScope.symbolNames.size).toEqual(1);
+    expect(target.staticMemberScope.symbolNames.has("instance-member")).toBe(true);
+  });
+});

package/dist/test/symbols/resolution.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=resolution.test.d.ts.map

package/dist/test/symbols/resolution.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolution.test.d.ts","sourceRoot":"","sources":["../../../test/symbols/resolution.test.ts"],"names":[],"mappings":""}

package/dist/test/symbols/resolution.test.js

@@ -0,0 +1,140 @@
+import { describe, expect, it } from "vitest";
+import { createOutputBinder, refkey } from "../../src/index.browser.js";
+import { flushJobs } from "../../src/scheduler.js";
+import { OutputSymbol, OutputSymbolFlags } from "../../src/symbols/output-symbol.js";
+import { createScopeTree } from "./utils.js";
+describe("Symbol name resolution", () => {
+  it("resolves static symbols", () => {
+    const binder = createOutputBinder();
+    const {
+      symbols: {
+        static: staticSym
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          root: {
+            flags: OutputSymbolFlags.InstanceMemberContainer | OutputSymbolFlags.StaticMemberContainer,
+            staticMembers: {
+              static: {
+                flags: OutputSymbolFlags.StaticMember
+              }
+            }
+          }
+        }
+      }
+    });
+    const result = binder.resolveFQN("root.root.static");
+    expect(result.value).toEqual(staticSym);
+  });
+  it("resolves static symbols that are added later", () => {
+    const binder = createOutputBinder();
+    const result = binder.resolveFQN("root.root.static");
+    expect(result.value).toBeUndefined();
+    const {
+      symbols: {
+        static: staticSym
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          root: {
+            flags: OutputSymbolFlags.InstanceMemberContainer | OutputSymbolFlags.StaticMemberContainer,
+            staticMembers: {
+              static: {
+                flags: OutputSymbolFlags.StaticMember
+              }
+            }
+          }
+        }
+      }
+    });
+    expect(result.value).toEqual(staticSym);
+  });
+  it("resolves instance symbols", () => {
+    const binder = createOutputBinder();
+    const {
+      symbols: {
+        instance
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          root: {
+            flags: OutputSymbolFlags.InstanceMemberContainer,
+            instanceMembers: {
+              instance: {
+                flags: OutputSymbolFlags.InstanceMember
+              }
+            }
+          }
+        }
+      }
+    });
+    const result = binder.resolveFQN("root.root#instance");
+    expect(result.value).toEqual(instance);
+  });
+  it("resolves instance symbols that are added later", () => {
+    const binder = createOutputBinder();
+    const result = binder.resolveFQN("root.root#instance");
+    expect(result.value).toBeUndefined();
+    const {
+      symbols: {
+        instance
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          root: {
+            flags: OutputSymbolFlags.InstanceMemberContainer,
+            instanceMembers: {
+              instance: {
+                flags: OutputSymbolFlags.InstanceMember
+              }
+            }
+          }
+        }
+      }
+    });
+    expect(result.value).toEqual(instance);
+  });
+});
+describe("refkey resolution", () => {
+  it("resolves existing symbols by refkey", () => {
+    const key = refkey();
+    const binder = createOutputBinder();
+    const sym = new OutputSymbol("foo", {
+      binder,
+      scope: binder.globalScope,
+      refkeys: [key]
+    });
+    const resolvedSym = binder.resolveDeclarationByKey(undefined, undefined, key);
+    expect(resolvedSym.value?.targetDeclaration).toBe(sym);
+  });
+  it("resolves symbols by refkey when symbol is added later", () => {
+    const key = refkey();
+    const binder = createOutputBinder();
+    const resolvedSym = binder.resolveDeclarationByKey(undefined, undefined, key);
+    const sym = new OutputSymbol("foo", {
+      binder,
+      scope: binder.globalScope,
+      refkeys: [key]
+    });
+    expect(resolvedSym.value?.targetDeclaration).toBe(sym);
+  });
+  it("handles deleted symbols by updating resolutions", () => {
+    const key = refkey();
+    const binder = createOutputBinder();
+    const resolvedSym = binder.resolveDeclarationByKey(undefined, undefined, key);
+    const sym = new OutputSymbol("foo", {
+      binder,
+      scope: binder.globalScope,
+      refkeys: [key]
+    });
+    flushJobs();
+    expect(resolvedSym.value?.targetDeclaration).toBe(sym);
+    sym.delete();
+    flushJobs();
+    expect(resolvedSym.value).toBe(undefined);
+  });
+});

package/dist/test/symbols/utils.d.ts

@@ -0,0 +1,24 @@
+import { Binder } from "../../src/index.browser.js";
+import { Refkey } from "../../src/refkey.js";
+import { OutputScope, OutputScopeFlags } from "../../src/symbols/output-scope.js";
+import { OutputSymbol, OutputSymbolFlags } from "../../src/symbols/output-symbol.js";
+type ScopeRecords = Record<string, ScopeDescriptor>;
+type SymbolRecords = Record<string, SymbolDescriptor>;
+interface ScopeDescriptor {
+    flags?: OutputScopeFlags;
+    scopes?: ScopeRecords;
+    symbols: SymbolRecords;
+}
+interface SymbolDescriptor {
+    refkey?: Refkey;
+    flags?: OutputSymbolFlags;
+    instanceMembers?: SymbolRecords;
+    staticMembers?: SymbolRecords;
+}
+interface ScopeTreeResult {
+    symbols: Record<string, OutputSymbol>;
+    scopes: Record<string, OutputScope>;
+}
+export declare function createScopeTree(binder: Binder, tree: ScopeRecords): ScopeTreeResult;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/test/symbols/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../test/symbols/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACpD,OAAO,EAAE,MAAM,EAAU,MAAM,qBAAqB,CAAC;AACrD,OAAO,EACL,WAAW,EACX,gBAAgB,EACjB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,YAAY,EACZ,iBAAiB,EAClB,MAAM,oCAAoC,CAAC;AAE5C,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;AACpD,KAAK,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;AAEtD,UAAU,eAAe;IACvB,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,aAAa,CAAC;CACxB;AAED,UAAU,gBAAgB;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED,UAAU,eAAe;IACvB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CACrC;AACD,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,YAAY,GACjB,eAAe,CA4DjB"}

package/dist/test/symbols/utils.js

@@ -0,0 +1,46 @@
+import { refkey } from "../../src/refkey.js";
+import { OutputScope } from "../../src/symbols/output-scope.js";
+import { OutputSymbol, OutputSymbolFlags } from "../../src/symbols/output-symbol.js";
+export function createScopeTree(binder, tree) {
+  const createdItems = {
+    symbols: {},
+    scopes: {}
+  };
+  for (const [name, desc] of Object.entries(tree)) {
+    createScope(name, desc);
+  }
+  return createdItems;
+  function createScope(name, descriptor, parent = binder.globalScope) {
+    const scope = new OutputScope(name, {
+      binder,
+      parent,
+      flags: descriptor.flags
+    });
+    createdItems.scopes[name] = scope;
+    for (const [name, desc] of Object.entries(descriptor.symbols)) {
+      createSymbol(name, desc, scope);
+    }
+    for (const [name, desc] of Object.entries(descriptor.scopes ?? {})) {
+      createScope(name, desc, scope);
+    }
+  }
+  function createSymbol(name, descriptor, parent) {
+    const symbol = new OutputSymbol(name, {
+      binder,
+      scope: parent,
+      refkeys: [descriptor.refkey ?? refkey()],
+      flags: descriptor.flags ?? OutputSymbolFlags.None
+    });
+    createdItems.symbols[name] = symbol;
+    if (descriptor.instanceMembers) {
+      for (const [name, desc] of Object.entries(descriptor.instanceMembers)) {
+        createSymbol(name, desc, symbol.instanceMemberScope);
+      }
+    }
+    if (descriptor.staticMembers) {
+      for (const [name, desc] of Object.entries(descriptor.staticMembers)) {
+        createSymbol(name, desc, symbol.staticMemberScope);
+      }
+    }
+  }
+}