@alloy-js/core 0.20.0-dev.3 → 0.20.0-dev.6

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

@@ -1,141 +1,458 @@
 import { describe, expect, it } from "vitest";
-import { createOutputBinder, refkey } from "../../src/index.browser.js";
+import { createOutputBinder } from "../../src/binder.js";
+import { memberRefkey, refkey } from "../../src/refkey.js";
 import { flushJobs } from "../../src/scheduler.js";
-import { OutputSymbolFlags } from "../../src/symbols/flags.js";
-import { OutputSymbol } from "../../src/symbols/output-symbol.js";
-import { createScopeTree } from "./utils.js";
-describe("Symbol name resolution", () => {
-  it("resolves static symbols", () => {
+import { BasicScope } from "../../src/symbols/basic-scope.js";
+import { BasicSymbol } from "../../src/symbols/basic-symbol.js";
+import { binder, createScope, createSymbol } from "./utils.js";
+describe("dynamic refkey resolution", () => {
+  it("resolves symbols by refkey when symbol is added later", () => {
+    const key = refkey();
     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 scope = new BasicScope("global", undefined);
+    const resolvedSym = binder.resolveDeclarationByKey(undefined, key);
+    const sym = new BasicSymbol("foo", scope.symbols, {
+      binder,
+      refkeys: [key]
+    });
+    expect(resolvedSym.value?.symbol).toBe(sym);
+  });
+  it("handles deleted symbols by updating resolutions", () => {
+    const key = refkey();
     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 resolvedSym = binder.resolveDeclarationByKey(undefined, key);
+    const scope = new BasicScope("global", undefined);
+    const sym = new BasicSymbol("foo", scope.symbols, {
+      binder,
+      refkeys: [key]
+    });
+    flushJobs();
+    expect(resolvedSym.value?.symbol).toBe(sym);
+    sym.delete();
+    flushJobs();
+    expect(resolvedSym.value).toBe(undefined);
+  });
+});
+describe("resolving lexical declarations by refkey", () => {
+  it("from the same scope", () => {
+    const key = refkey();
     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 scope = new BasicScope("global", undefined);
+    const sym = new BasicSymbol("foo", scope.symbols, {
+      binder,
+      refkeys: [key]
+    });
+    const result = binder.resolveDeclarationByKey(scope, key).value;
+    expect(result.symbol).toBe(sym);
+    expect(result.commonScope).toBe(scope);
+    expect(result.lexicalDeclaration).toBe(sym);
+    expect(result.pathDown).toEqual([]);
+    expect(result.pathUp).toEqual([]);
+    expect(result.memberPath).toEqual([]);
+    expect(result.fullReferencePath).toEqual([scope]);
+    expect(result.fullSymbolPath).toEqual([scope]);
+  });
+  it("from a different scope for the same member", () => {
+    const key = refkey();
     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);
+    const globalSym = new BasicSymbol("global", undefined, {
+      binder
+    });
+    const scope = new BasicScope("global", undefined, {
+      binder,
+      ownerSymbol: globalSym
+    });
+    const sym = new BasicSymbol("foo", scope.symbols, {
+      binder,
+      refkeys: [key]
+    });
+    const resolveScope = new BasicScope("other global", undefined, {
+      binder,
+      ownerSymbol: globalSym
+    });
+    const result = binder.resolveDeclarationByKey(resolveScope, key).value;
+    expect(result.symbol).toBe(sym);
+    expect(result.commonScope).toBe(resolveScope);
+    expect(result.lexicalDeclaration).toBe(sym);
+    expect(result.pathDown).toEqual([]);
+    expect(result.pathUp).toEqual([]);
+    expect(result.memberPath).toEqual([]);
+    expect(result.fullReferencePath).toEqual([scope]);
+    expect(result.fullSymbolPath).toEqual([scope]);
+  });
+  it("from a parent scope", () => {
+    const key = refkey();
+    const binder = createOutputBinder();
+    const scope = new BasicScope("global", undefined);
+    const childScope = new BasicScope("child", scope);
+    const sym = new BasicSymbol("foo", childScope.symbols, {
+      binder,
+      refkeys: [key]
+    });
+    const result = binder.resolveDeclarationByKey(scope, key).value;
+    expect(result.symbol).toBe(sym);
+    expect(result.commonScope).toBe(scope);
+    expect(result.lexicalDeclaration).toBe(sym);
+    expect(result.pathDown).toEqual([childScope]);
+    expect(result.pathUp).toEqual([]);
+    expect(result.memberPath).toEqual([]);
+    expect(result.fullReferencePath).toEqual([scope]);
+    expect(result.fullSymbolPath).toEqual([scope, childScope]);
   });
+  it("from a parent scope for the same member", () => {
+    const key = refkey();
+    const binder = createOutputBinder();
+    const globalSym = new BasicSymbol("global", undefined, {
+      binder
+    });
+    const scope = new BasicScope("global", undefined, {
+      ownerSymbol: globalSym
+    });
+    const childScope = new BasicScope("child", scope);
+    const sym = new BasicSymbol("foo", childScope.symbols, {
+      binder,
+      refkeys: [key]
+    });
+    const referenceScope = new BasicScope("otherGlobal global", undefined, {
+      ownerSymbol: globalSym
+    });
+    const result = binder.resolveDeclarationByKey(referenceScope, key).value;
+    expect(result.symbol).toBe(sym);
+    expect(result.commonScope).toBe(referenceScope);
+    expect(result.lexicalDeclaration).toBe(sym);
+    expect(result.pathDown).toEqual([childScope]);
+    expect(result.pathUp).toEqual([]);
+    expect(result.memberPath).toEqual([]);
+    expect(result.fullReferencePath).toEqual([scope]);
+    expect(result.fullSymbolPath).toEqual([scope, childScope]);
+  });
+  it("from a child scope", () => {
+    const key = refkey();
+    const binder = createOutputBinder();
+    const scope = new BasicScope("global", undefined);
+    const childScope = new BasicScope("child", scope);
+    const sym = new BasicSymbol("foo", scope.symbols, {
+      binder,
+      refkeys: [key]
+    });
+    const result = binder.resolveDeclarationByKey(childScope, key).value;
+    expect(result.symbol).toBe(sym);
+    expect(result.lexicalDeclaration).toBe(sym);
+    expect(result.commonScope).toBe(scope);
+    expect(result.pathDown).toEqual([]);
+    expect(result.pathUp).toEqual([childScope]);
+    expect(result.memberPath).toEqual([]);
+    expect(result.fullReferencePath).toEqual([scope, childScope]);
+    expect(result.fullSymbolPath).toEqual([scope]);
+  });
+  it("from a different child scope for the same member", () => {
+    const key = refkey();
+    const binder = createOutputBinder();
+    const globalSym = new BasicSymbol("global", undefined, {
+      binder
+    });
+    const scope = new BasicScope("global", undefined, {
+      ownerSymbol: globalSym
+    });
+    const otherGlobalScope = new BasicScope("other global", undefined, {
+      ownerSymbol: globalSym
+    });
+    const childMember = new BasicSymbol("child", scope.symbols);
+    const childScope = new BasicScope("child", otherGlobalScope, {
+      ownerSymbol: childMember
+    });
+    const sym = new BasicSymbol("foo", scope.symbols, {
+      binder,
+      refkeys: [key]
+    });
+    const result = binder.resolveDeclarationByKey(childScope, key).value;
+    expect(result.symbol).toBe(sym);
+    expect(result.lexicalDeclaration).toBe(sym);
+    expect(result.commonScope).toBe(otherGlobalScope);
+    expect(result.pathDown).toEqual([]);
+    expect(result.pathUp).toEqual([childScope]);
+    expect(result.memberPath).toEqual([]);
+    expect(result.fullReferencePath).toEqual([scope, childScope]);
+    expect(result.fullSymbolPath).toEqual([scope]);
+  });
+  it("from a different child scope for the same member with a different root scope", () => {
+    const key = refkey();
+    const binder = createOutputBinder();
+    const rootRefScope = new BasicScope("root", undefined, {
+      binder
+    });
+    const globalSym = new BasicSymbol("global", undefined, {
+      binder
+    });
+    const scope = new BasicScope("global", undefined, {
+      ownerSymbol: globalSym
+    });
+    const otherGlobalScope = new BasicScope("other global", rootRefScope, {
+      ownerSymbol: globalSym
+    });
+    const childMember = new BasicSymbol("child", scope.symbols);
+    const childScope = new BasicScope("child", otherGlobalScope, {
+      ownerSymbol: childMember
+    });
+    const sym = new BasicSymbol("foo", scope.symbols, {
+      binder,
+      refkeys: [key]
+    });
+    const result = binder.resolveDeclarationByKey(childScope, key).value;
+    expect(result.symbol).toBe(sym);
+    expect(result.lexicalDeclaration).toBe(sym);
+    expect(result.commonScope).toBe(otherGlobalScope);
+    expect(result.pathDown).toEqual([]);
+    expect(result.pathUp).toEqual([childScope]);
+    expect(result.memberPath).toEqual([]);
+    expect(result.fullReferencePath).toEqual([rootRefScope, scope, childScope]);
+    expect(result.fullSymbolPath).toEqual([rootRefScope, scope]);
+  });
+  it("from a parallel scope", () => {
+    const key = refkey();
+    const binder = createOutputBinder();
+    const scope = new BasicScope("global", undefined);
+    const childScope1 = new BasicScope("child", scope);
+    const childScope2 = new BasicScope("child2", scope);
+    const sym = new BasicSymbol("foo", childScope1.symbols, {
+      binder,
+      refkeys: [key]
+    });
+    const result = binder.resolveDeclarationByKey(childScope2, key).value;
+    expect(result.symbol).toBe(sym);
+    expect(result.lexicalDeclaration).toBe(sym);
+    expect(result.pathDown).toEqual([childScope1]);
+    expect(result.pathUp).toEqual([childScope2]);
+    expect(result.commonScope).toBe(scope);
+    expect(result.memberPath).toEqual([]);
+    expect(result.fullReferencePath).toEqual([scope, childScope2]);
+    expect(result.fullSymbolPath).toEqual([scope, childScope1]);
+  });
+  it("from a member scope", () => {
+    const key = refkey();
+    const binder = createOutputBinder();
+    const globalScope = new BasicScope("global", undefined, {
+      binder
+    });
+    const object = new BasicSymbol("object", globalScope.symbols, {
+      binder,
+      refkeys: key
+    });
+    const memberScope = new BasicScope("object members", globalScope, {
+      binder,
+      ownerSymbol: object
+    });
+    const result = binder.resolveDeclarationByKey(memberScope, key).value;
+    expect(result.symbol).toBe(object);
+    expect(result.lexicalDeclaration).toBe(object);
+    expect(result.commonScope).toBe(globalScope);
+    expect(result.pathDown).toEqual([]);
+    expect(result.pathUp).toEqual([memberScope]);
+    expect(result.memberPath).toEqual([]);
+    expect(result.fullReferencePath).toEqual([globalScope, memberScope]);
+    expect(result.fullSymbolPath).toEqual([globalScope]);
+  });
+  it("from another scope for the same member", () => {});
 });
-describe("refkey resolution", () => {
-  it("resolves existing symbols by refkey", () => {
+describe("resolving members by refkey", () => {
+  it("simple member", () => {
     const key = refkey();
     const binder = createOutputBinder();
-    const sym = new OutputSymbol("foo", {
+    const globalScope = new BasicScope("global", undefined, {
+      binder
+    });
+    const foo = new BasicSymbol("foo", globalScope.symbols, {
+      binder
+    });
+    const bar = new BasicSymbol("bar", foo.staticMembers, {
       binder,
-      scope: binder.globalScope,
       refkeys: [key]
     });
-    const resolvedSym = binder.resolveDeclarationByKey(undefined, undefined, key);
-    expect(resolvedSym.value?.targetDeclaration).toBe(sym);
+    const result = binder.resolveDeclarationByKey(globalScope, key).value;
+
+    // we successfully resolve the symbol, so:
+    expect(result.symbol).toBe(bar);
+
+    // the member is off of a declaration in our current scope, so:
+    expect(result.commonScope).toBe(globalScope);
+    expect(result.pathUp.length).toBe(0);
+    expect(result.pathDown.length).toBe(0);
+
+    // the declaration symbol carrying the resolved member is:
+    expect(result.lexicalDeclaration).toBe(foo);
+
+    // the path to the resolved symbol is
+    expect(result.memberPath).toEqual([bar]);
+    expect(result.fullReferencePath).toEqual([globalScope]);
+    expect(result.fullSymbolPath).toEqual([globalScope]);
   });
-  it("resolves symbols by refkey when symbol is added later", () => {
+  it("nested members", () => {
     const key = refkey();
     const binder = createOutputBinder();
-    const resolvedSym = binder.resolveDeclarationByKey(undefined, undefined, key);
-    const sym = new OutputSymbol("foo", {
+    const globalScope = new BasicScope("global", undefined, {
+      binder
+    });
+    const foo = new BasicSymbol("foo", globalScope.symbols, {
+      binder
+    });
+    const bar = new BasicSymbol("bar", foo.staticMembers, {
+      binder
+    });
+    const baz = new BasicSymbol("baz", bar.staticMembers, {
       binder,
-      scope: binder.globalScope,
       refkeys: [key]
     });
-    expect(resolvedSym.value?.targetDeclaration).toBe(sym);
+    const result = binder.resolveDeclarationByKey(globalScope, key).value;
+    expect(result.symbol).toBe(baz);
+    expect(result.commonScope).toBe(globalScope);
+    expect(result.pathUp.length).toBe(0);
+    expect(result.pathDown.length).toBe(0);
+    expect(result.lexicalDeclaration).toBe(foo);
+    expect(result.memberPath).toEqual([bar, baz]);
+    expect(result.fullReferencePath).toEqual([globalScope]);
+    expect(result.fullSymbolPath).toEqual([globalScope]);
   });
-  it("handles deleted symbols by updating resolutions", () => {
+  it("nested members, while declaring a neighboring member", () => {
     const key = refkey();
     const binder = createOutputBinder();
-    const resolvedSym = binder.resolveDeclarationByKey(undefined, undefined, key);
-    const sym = new OutputSymbol("foo", {
+    const globalScope = new BasicScope("global", undefined, {
+      binder
+    });
+    const foo = new BasicSymbol("foo", globalScope.symbols, {
+      binder
+    });
+    const fooMemberScope = new BasicScope("foo members", globalScope, {
+      ownerSymbol: foo
+    });
+    const bar = new BasicSymbol("bar", foo.staticMembers, {
+      binder
+    });
+    const barMemberScope = new BasicScope("bar members", fooMemberScope, {
+      ownerSymbol: bar
+    });
+    const baz = new BasicSymbol("baz", bar.staticMembers, {
       binder,
-      scope: binder.globalScope,
       refkeys: [key]
     });
-    flushJobs();
-    expect(resolvedSym.value?.targetDeclaration).toBe(sym);
-    sym.delete();
-    flushJobs();
-    expect(resolvedSym.value).toBe(undefined);
+    const result = binder.resolveDeclarationByKey(barMemberScope, key).value;
+    expect(result.symbol).toBe(baz);
+    expect(result.commonScope).toBe(barMemberScope);
+    expect(result.pathUp.length).toBe(0);
+    expect(result.pathDown.length).toBe(0);
+    expect(result.lexicalDeclaration).toBe(baz);
+    expect(result.memberPath).toEqual([]);
+    expect(result.fullReferencePath).toEqual([globalScope, fooMemberScope, barMemberScope]);
+    expect(result.fullSymbolPath).toEqual([globalScope, fooMemberScope, barMemberScope]);
+  });
+  it("nested members, while declaring a neighboring nested member", () => {
+    const globalScope = createScope("global");
+    const [foo] = createSymbol("foo", globalScope);
+    const fooMemberScope = createScope("foo members", globalScope, {
+      ownerSymbol: foo
+    });
+    const [bar] = createSymbol("bar", foo.staticMembers);
+    const barMemberScope = createScope("bar members", fooMemberScope, {
+      ownerSymbol: bar
+    });
+    const [baz, bazKey] = createSymbol("baz", bar.staticMembers);
+    const bazMemberScope = createScope("baz members", barMemberScope, {
+      ownerSymbol: baz
+    });
+    createSymbol("otherBaz", bar.staticMembers);
+    const result = binder.resolveDeclarationByKey(bazMemberScope, bazKey).value;
+    expect(result.symbol).toBe(baz);
+    expect(result.commonScope).toBe(barMemberScope);
+    expect(result.pathUp).toEqual([bazMemberScope]);
+    expect(result.pathDown.length).toBe(0);
+    expect(result.lexicalDeclaration).toBe(baz);
+    expect(result.memberPath).toEqual([]);
+    expect(result.fullReferencePath).toEqual([globalScope, fooMemberScope, barMemberScope, bazMemberScope]);
+    expect(result.fullSymbolPath).toEqual([globalScope, fooMemberScope, barMemberScope]);
+  });
+});
+describe("resolving type members by refkey", () => {
+  it("simple member", () => {
+    const globalScope = createScope("global");
+    const [typeSymbol, typeKey] = createSymbol("MyType", globalScope);
+    const [staticProp, staticKey] = createSymbol("staticProp", typeSymbol.staticMembers);
+
+    // resolve a member of type
+    const result = binder.resolveDeclarationByKey(globalScope, memberRefkey(typeKey, staticKey)).value;
+    expect(result.symbol).toBe(staticProp);
+    expect(result.lexicalDeclaration).toBe(typeSymbol);
+    expect(result.memberPath).toEqual([staticProp]);
+  });
+  it("nested member", () => {
+    const globalScope = createScope("global");
+    const [typeSymbol, typeKey] = createSymbol("MyType", globalScope);
+    const [staticProp, staticPropKey] = createSymbol("staticProp", typeSymbol.staticMembers);
+    const [nestedProp, nestedKey] = createSymbol("nestedProp", staticProp.staticMembers);
+
+    // resolve a member of type directly
+    const result = binder.resolveDeclarationByKey(globalScope, memberRefkey(staticPropKey, nestedKey)).value;
+    expect(result.symbol).toBe(nestedProp);
+    expect(result.lexicalDeclaration).toBe(typeSymbol);
+    expect(result.memberPath).toEqual([staticProp, nestedProp]);
+
+    // resolve from a member refkey
+    const result2 = binder.resolveDeclarationByKey(globalScope, memberRefkey(memberRefkey(typeKey, staticPropKey), nestedKey)).value;
+    expect(result2.symbol).toBe(nestedProp);
+    expect(result2.lexicalDeclaration).toBe(typeSymbol);
+    expect(result2.memberPath).toEqual([staticProp, nestedProp]);
+  });
+  it("member of type", () => {
+    const globalScope = createScope("global");
+    const [typeSymbol] = createSymbol("MyType", globalScope);
+    const [staticProp, staticKey] = createSymbol("staticProp", typeSymbol.staticMembers);
+    const [value, valueKey] = createSymbol("myValue", globalScope, {
+      type: typeSymbol
+    });
+
+    // resolve a member of type
+    const result = binder.resolveDeclarationByKey(globalScope, memberRefkey(valueKey, staticKey)).value;
+    expect(result.symbol).toBe(staticProp);
+    expect(result.lexicalDeclaration).toBe(value);
+    expect(result.memberPath).toEqual([staticProp]);
+  });
+  it("nested member of type", () => {
+    const globalScope = createScope("global");
+    const [typeSymbol] = createSymbol("MyType", globalScope);
+    const [staticProp, staticKey] = createSymbol("staticProp", typeSymbol.staticMembers);
+    const [nestedProp, nestedKey] = createSymbol("nestedProp", staticProp.staticMembers);
+    const [value, valueKey] = createSymbol("myValue", globalScope, {
+      type: typeSymbol
+    });
+
+    // resolve a member of type
+    const result = binder.resolveDeclarationByKey(globalScope, memberRefkey(memberRefkey(valueKey, staticKey), nestedKey)).value;
+    expect(result.symbol).toBe(nestedProp);
+    expect(result.lexicalDeclaration).toBe(value);
+    expect(result.memberPath).toEqual([staticProp, nestedProp]);
+  });
+  it("nested member of nested type", () => {
+    const globalScope = createScope("global");
+    const [typeSymbol] = createSymbol("MyType", globalScope);
+    const [staticProp, staticKey] = createSymbol("staticProp", typeSymbol.staticMembers);
+    const [nestedProp, nestedKey] = createSymbol("nestedProp", staticProp.staticMembers);
+    const [value, valueKey] = createSymbol("myValue", globalScope);
+    const [regularProp, regularPropKey] = createSymbol("regularProp", value.staticMembers, {
+      type: typeSymbol
+    });
+
+    // resolve a member of type
+    const result = binder.resolveDeclarationByKey(globalScope, memberRefkey(memberRefkey(memberRefkey(valueKey, regularPropKey), staticKey), nestedKey)).value;
+    expect(result.symbol).toBe(nestedProp);
+    expect(result.lexicalDeclaration).toBe(value);
+    expect(result.memberPath).toEqual([regularProp, staticProp, nestedProp]);
+  });
+  it("throws an error when resolving something that isn't a member", () => {
+    const globalScope = createScope("global");
+    const [typeSymbol] = createSymbol("MyType", globalScope);
+    const [, ts2Key] = createSymbol("MyType2", globalScope);
+    const [, staticKey] = createSymbol("staticProp", typeSymbol.staticMembers);
+    expect(() => {
+      const result = binder.resolveDeclarationByKey(globalScope, memberRefkey(ts2Key, staticKey));
+      return result.value; // force evaluation
+    }).toThrow(/is not a member/);
   });
 });

package/dist/test/symbols/symbol-table.test.d.ts

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

package/dist/test/symbols/symbol-table.test.d.ts.map

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

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

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+import { createScope, createSymbol } from "./utils.js";
+describe("OutputSymbol#moveTo", () => {
+  it("moves the symbol to a new symbol table", () => {
+    const scope = createScope("scope");
+    const [symbol] = createSymbol("sym", scope);
+    expect(symbol.spaces).toEqual([scope.symbols]);
+    const newScope = createScope("new-scope");
+    scope.symbols.moveTo(newScope.symbols);
+    expect(scope.symbols.has(symbol)).toBe(false);
+    expect(newScope.symbols.has(symbol)).toBe(true);
+    expect(symbol.spaces).toEqual([newScope.symbols]);
+  });
+});

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

@@ -1,25 +1,11 @@
-import { Binder } from "../../src/index.browser.js";
-import { Refkey } from "../../src/refkey.js";
-import { OutputScopeFlags, OutputSymbolFlags } from "../../src/symbols/flags.js";
-import { OutputScope } from "../../src/symbols/output-scope.js";
-import { OutputSymbol } 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 {};
+import { Binder } from "../../src/binder.js";
+import { OutputSpace } from "../../src/index.js";
+import { Namekey, Refkey } from "../../src/refkey.js";
+import { BasicScope } from "../../src/symbols/basic-scope.js";
+import { BasicSymbol } from "../../src/symbols/basic-symbol.js";
+import { OutputScopeOptions } from "../../src/symbols/output-scope.js";
+import { OutputSymbolOptions } from "../../src/symbols/output-symbol.js";
+export declare let binder: Binder;
+export declare function createScope(name: string, parent?: BasicScope, options?: OutputScopeOptions): BasicScope;
+export declare function createSymbol(name: string | Namekey, scope: BasicScope | OutputSpace, options?: OutputSymbolOptions): [BasicSymbol, Refkey];
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +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,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAElE,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"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../test/symbols/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAsB,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,OAAO,EAAU,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAgBzE,eAAO,IAAI,MAAM,EAAE,MAAM,CAAC;AAK1B,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,UAAU,EACnB,OAAO,CAAC,EAAE,kBAAkB,cAM7B;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,GAAG,OAAO,EACtB,KAAK,EAAE,UAAU,GAAG,WAAW,EAC/B,OAAO,CAAC,EAAE,mBAAmB,GAC5B,CAAC,WAAW,EAAE,MAAM,CAAC,CAavB"}