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

package/dist/src/binder.d.ts

@@ -1,6 +1,5 @@
 import { Ref } from "@vue/reactivity";
 import { Refkey } from "./refkey.js";
-import { OutputSymbolFlags } from "./symbols/flags.js";
 import { OutputScope } from "./symbols/output-scope.js";
 import { type OutputSymbol } from "./symbols/output-symbol.js";
 export type Metadata = object;
@@ -25,28 +24,12 @@ export interface Binder {
      * @see {@link resolve} a convenience function that uses the current scope and
      * binder.
      */
-    resolveDeclarationByKey<TScope extends OutputScope = OutputScope, TSymbol extends OutputSymbol = OutputSymbol>(currentScope: TScope | undefined, currentMemberScope: TScope | undefined, key: Refkey): Ref<ResolutionResult<TScope, TSymbol> | undefined>;
-    getSymbolForRefkey<TSymbol extends OutputSymbol>(refkey: Refkey): Ref<TSymbol | undefined>;
-    /**
-     * Find a symbol with a given name in the given scope. Returns a ref
-     * for the symbol, such that when the symbol is available, the ref value
-     * will update.
-     */
-    findSymbolName<TScope extends OutputScope = OutputScope, TSymbol extends OutputSymbol = OutputSymbol>(currentScope: TScope | undefined, name: string): Ref<TSymbol | undefined>;
-    findScopeName<TScope extends OutputScope = OutputScope>(currentScope: TScope | undefined, name: string): Ref<TScope | undefined>;
-    /**
-     * Resolve a fully qualified name to a symbol. Access a nested scope by name
-     * with `::`, a nested static member with `.` and a nested instance member
-     * with `#`.
-     *
-     * Per-language packages may provide their own resolveFQN function that uses
-     * syntax more natural to that  language.
-     */
-    resolveFQN<TScope extends OutputScope = OutputScope, TSymbol extends OutputSymbol = OutputSymbol>(fqn: string): Ref<TSymbol | TScope | undefined>;
+    resolveDeclarationByKey<TScope extends OutputScope = OutputScope, TSymbol extends OutputSymbol = OutputSymbol>(currentScope: TScope | undefined, key: Refkey, options?: ResolveDeclarationByKeyOptions<TScope, TSymbol>): Ref<ResolutionResult<TScope, TSymbol> | undefined>;
     /**
-     * The global scope. This is the root scope for all symbols.
+     * Get a ref to the symbol associated with the given refkey. The value of the
+     * ref is undefined if the symbol has not been created yet.
      */
-    globalScope: OutputScope;
+    getSymbolForRefkey<TSymbol extends OutputSymbol>(refkey: Refkey): Ref<TSymbol | undefined>;
     /**
      * The name conflict resolver to use for this binder.
      */
@@ -75,7 +58,7 @@ export interface Binder {
  * scope: global scope
  * ├── scope: namespace scope 1
  * │   └── symbol: foo
- * │       └── static member scope
+ * │       └── static members
  * │           └── symbol: bar
  * └── scope: namespace scope 2
  *    └── (resolve bar from here)
@@ -92,11 +75,19 @@ export interface Binder {
  */
 export interface ResolutionResult<TScope extends OutputScope, TSymbol extends OutputSymbol> {
     /**
-     * The symbol for the resolved declaration.
+     * The resolved symbol. May be declared in a lexical scope or be a member symbol.
+     */
+    symbol: TSymbol;
+    /**
+     * When the symbol is a member symbol, this is the symbol of the lexical
+     * declaration which contains this member symbol, either as one of its own
+     * member symbols, or as a member of one of its members.
+     *
+     * When the symbol is a non-member symbol, this is the same as `symbol`.
      */
-    targetDeclaration: TSymbol;
+    lexicalDeclaration: TSymbol;
     /**
-     * The scopes between the common scope and the reference
+     * The scopes between the common scope and the reference.
      */
     pathUp: TScope[];
     /**
@@ -104,18 +95,60 @@ export interface ResolutionResult<TScope extends OutputScope, TSymbol extends Ou
      */
     pathDown: TScope[];
     /**
-     * The scope which contains both the reference and the declaration.
+     * The scopes from the root to scope of the lexical declaration.
+     */
+    fullSymbolPath: TScope[];
+    /**
+     * The scopes from the root to the scope of the reference.
+     */
+    fullReferencePath: TScope[];
+    /**
+     * The lexical scope which contains both the reference and the lexical
+     * declaration. Undefined when they do not share a common scope.
      */
     commonScope: TScope | undefined;
     /**
      * When resolving a member symbol, this is the path of symbols that lead from
-     * the base declaration to the member symbol.
+     * the lexical declaration to the member symbol.
      */
-    memberPath?: TSymbol[];
+    memberPath: TSymbol[];
+}
+/**
+ * Describes a member in a member access chain, tracking both the symbol
+ * and whether this specific member was accessed via a memberRefkey.
+ */
+export interface MemberDescriptor {
+    symbol: OutputSymbol;
+    isMemberAccess: boolean;
 }
 export interface NameConflictResolver {
     (name: string, symbols: OutputSymbol[]): void;
 }
+/**
+ * The context for a member resolution. This is used to properly resolve a
+ * member in the MemberResolver.
+ */
+export interface MemberResolutionContext<TScope extends OutputScope> {
+    /**
+     * The scopes that the member reference occurred in.
+     */
+    referencePath: TScope[];
+    /**
+     * Whether we are using member access e.g. via `memberRefkey`.
+     * This is true when the member was resolved using a memberRefkey,
+     * which may carry additional metadata about the member access in the future.
+     */
+    isMemberAccess: boolean;
+}
+/**
+ *
+ */
+export interface MemberResolver<TScope extends OutputScope, TSymbol extends OutputSymbol> {
+    (owner: TSymbol, member: TSymbol, context: MemberResolutionContext<TScope>): void;
+}
+export interface ResolveDeclarationByKeyOptions<TScope extends OutputScope, TSymbol extends OutputSymbol> {
+    memberResolver?: MemberResolver<TScope, TSymbol>;
+}
 export interface BinderOptions {
     nameConflictResolver?: NameConflictResolver;
 }
@@ -130,21 +163,12 @@ export declare function createOutputBinder(options?: BinderOptions): Binder;
  * not found. The symbol you're looking for may not have been declared yet. When the symbol
  * is declared, the ref will be updated with the resolution result.
  */
-export declare function resolve<TScope extends OutputScope, TSymbol extends OutputSymbol>(refkey: Refkey): Ref<ResolutionResult<TScope, TSymbol>>;
+export declare function resolve<TScope extends OutputScope, TSymbol extends OutputSymbol>(refkey: Refkey, options?: ResolveDeclarationByKeyOptions<TScope, TSymbol>): Ref<ResolutionResult<TScope, TSymbol>>;
 declare const createSymbolsSymbol: unique symbol;
 export declare function getSymbolCreator(creator: SymbolCreator): SymbolCreator[typeof createSymbolsSymbol];
 export declare function getSymbolCreatorSymbol(): typeof createSymbolsSymbol;
 export interface SymbolCreator {
     [createSymbolsSymbol](binder: Binder): void;
 }
-/**
- * Use symbol flags to determine the scope in which a symbol with those flags
- * should be declared given the current context.
- *
- * @param flags - The symbol flags to use to determine the default scope.
- * @returns an {@link OutputScope} that is the default scope for the given
- * flags.
- */
-export declare function useDefaultScope(flags?: OutputSymbolFlags): OutputScope | undefined;
 export {};
 //# sourceMappingURL=binder.d.ts.map

package/dist/src/binder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"binder.d.ts","sourceRoot":"","sources":["../../src/binder.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"binder.d.ts","sourceRoot":"","sources":["../../src/binder.ts"],"names":[],"mappings":"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"}

package/dist/src/binder.js

@@ -1,11 +1,9 @@
-import { computed, ref, shallowRef } from "@vue/reactivity";
-import { useMemberScope } from "./context/member-scope.js";
+import { computed, shallowRef } from "@vue/reactivity";
+import { useMemberContext } from "./context/member-scope.js";
 import { useScope } from "./context/scope.js";
-import { effect, untrack } from "./reactivity.js";
-import { refkey } from "./refkey.js";
-import { OutputSymbolFlags } from "./symbols/flags.js";
-import { OutputScope } from "./symbols/output-scope.js";
-import { formatRefkeys, formatSymbol, formatSymbolName, trace, TracePhase } from "./tracer.js";
+import { effect } from "./reactivity.js";
+import { isMemberRefkey, refkey } from "./refkey.js";
+import { formatRefkeys, formatSymbolName, trace, TracePhase } from "./tracer.js";
 
 /**
  * The binder tracks all output scopes and symbols. Scopes are nested containers
@@ -32,7 +30,7 @@ import { formatRefkeys, formatSymbol, formatSymbolName, trace, TracePhase } from
  * scope: global scope
  * ├── scope: namespace scope 1
  * │   └── symbol: foo
- * │       └── static member scope
+ * │       └── static members
  * │           └── symbol: bar
  * └── scope: namespace scope 2
  *    └── (resolve bar from here)
@@ -48,23 +46,29 @@ import { formatRefkeys, formatSymbol, formatSymbolName, trace, TracePhase } from
  * * **memberPath**: [foo, bar], because we resolved a member symbol and these are the symbols that lead from the base declaration to the member symbol.
  */
 
+/**
+ * Describes a member in a member access chain, tracking both the symbol
+ * and whether this specific member was accessed via a memberRefkey.
+ */
+
+/**
+ * The context for a member resolution. This is used to properly resolve a
+ * member in the MemberResolver.
+ */
+
+/**
+ *
+ */
+
 export function createOutputBinder(options = {}) {
   const binder = {
     resolveDeclarationByKey,
     getSymbolForRefkey,
-    findSymbolName,
-    findScopeName,
-    resolveFQN: resolveFQN,
-    globalScope: undefined,
     notifyScopeCreated,
     notifySymbolCreated,
     notifySymbolDeleted,
     nameConflictResolver: options.nameConflictResolver
   };
-  binder.globalScope = new OutputScope("<global>", {
-    binder,
-    kind: "global"
-  });
   const knownDeclarations = new Map();
   const waitingDeclarations = new Map();
   const waitingSymbolNames = new Map();
@@ -90,67 +94,95 @@ export function createOutputBinder(options = {}) {
       resolution.value = undefined;
     }
   }
-  function hasTransientScope(symbol) {
-    let sym = symbol;
-    let transient = false;
-    while (sym) {
-      if (sym.flags & OutputSymbolFlags.Transient) {
-        transient = true;
-        break;
+  function buildResult(currentScope, targetDeclarationBase) {
+    const {
+      memberPath: targetMemberPath,
+      scopeChain: targetChain
+    } = scopeAndMemberChain(targetDeclarationBase);
+    let targetLexicalDeclaration = targetMemberPath && targetMemberPath.length > 0 ? targetMemberPath[0].ownerSymbol : targetDeclarationBase;
+    // when we are resolving from a scope which is a member scope and might have
+    // member scope parents, and any symbols in the member path are members of
+    // the member scope's owner symbol (i.e., those symbols are in scope where
+    // the reference is made), we replace the target member path with an entry
+    // on the scope chain.
+
+    // So, first we find all the owner symbols for any member scopes in scope
+    // for the reference.
+    const referenceChain = scopeChain(currentScope);
+    const inScopeSymbols = new Map();
+    for (const scope of referenceChain) {
+      if (scope.isMemberScope) {
+        inScopeSymbols.set(scope.ownerSymbol, scope);
       }
-      if (sym.flags & ~OutputSymbolFlags.Member) {
-        break;
+    }
+
+    // then if the lexical declaration symbol's members are in scope, remove the
+    // symbol from the member path and add its corresponding member scope to the
+    // target chain.
+    while (targetMemberPath.length > 0 && inScopeSymbols.has(targetLexicalDeclaration)) {
+      targetChain.push(inScopeSymbols.get(targetLexicalDeclaration));
+      targetLexicalDeclaration = targetMemberPath.shift();
+    }
+
+    // Now we replace any scopes in the target chain with corresponding scopes
+    // from the reference chain.
+    for (const [index, scope] of targetChain.entries()) {
+      if (inScopeSymbols.has(scope.ownerSymbol)) {
+        targetChain[index] = inScopeSymbols.get(scope.ownerSymbol);
       }
-      sym = sym.scope.owner;
     }
-    return transient;
-  }
-  function buildResult(currentScope, currentMemberScope, targetDeclarationBase) {
-    trace(TracePhase.resolve.success, () => {
-      return `Resolved ${formatRefkeys(targetDeclarationBase.refkeys)} to ${formatSymbol(targetDeclarationBase)}`;
-    });
-    if (targetDeclarationBase.flags & OutputSymbolFlags.InstanceMember) {
-      // todo: handle referencing nested objects by refkey
-      return {
-        pathUp: [],
-        pathDown: [],
-        memberPath: [targetDeclarationBase],
-        commonScope: currentMemberScope,
-        targetDeclaration: targetDeclarationBase
-      };
+
+    // Next we look for member scopes in the target chain that correspond to
+    // member scopes in the reference chain. We splice the reference chain into
+    // the target chain at that point. This ensures that we establish the proper
+    // common scope and path up/down even if the reference chain has additional
+    // scopes above it (e.g. a scope for the current source file).
+    const commonMemberContainer = targetChain.findIndex(scope => scope.isMemberScope && inScopeSymbols.has(scope.ownerSymbol));
+    if (commonMemberContainer > -1) {
+      const sourceLocation = referenceChain.findIndex(scope => scope.isMemberScope && scope.ownerSymbol === targetChain[commonMemberContainer].ownerSymbol);
+
+      // source location is guaranteed to exist at this point.
+      targetChain.splice(0, commonMemberContainer + 1, ...referenceChain.slice(0, sourceLocation + 1));
     }
-    const {
-      memberPath,
-      scopeChain: targetChain
-    } = scopeAndMemberChain(targetDeclarationBase);
-    const currentChain = scopeChain(currentScope);
+
+    // Now that we have the target chain and scopes, we can determine the common
+    // scopes and paths.
     let diffStart = 0;
-    while (targetChain[diffStart] && currentChain[diffStart] && targetChain[diffStart] === currentChain[diffStart]) {
+    while (targetChain[diffStart] && referenceChain[diffStart] && targetChain[diffStart] === referenceChain[diffStart]) {
       diffStart++;
     }
-    const pathUp = currentChain.slice(diffStart);
+    const pathUp = referenceChain.slice(diffStart);
     const pathDown = targetChain.slice(diffStart);
-    const commonScope = targetChain[diffStart - 1] ?? null;
+    const commonScope = targetChain[diffStart - 1] ?? undefined;
     return {
       pathUp,
       pathDown,
-      memberPath,
+      memberPath: targetMemberPath,
       commonScope,
-      targetDeclaration: memberPath && memberPath.length > 0 ? memberPath.at(0) : targetDeclarationBase
+      symbol: targetDeclarationBase,
+      lexicalDeclaration: targetLexicalDeclaration,
+      fullSymbolPath: targetChain,
+      fullReferencePath: referenceChain
     };
   }
+
+  /**
+   * Walk from the provided symbol up to the non-member symbol. This constitutes
+   * the member path. Then, walk from the first non-member symbol's scope up to
+   * the global scope. This constitutes the scope chain.
+   */
   function scopeAndMemberChain(symbol) {
     const result = {
       memberPath: [],
       scopeChain: []
     };
     let currentSymbol = symbol;
-    while (currentSymbol.flags & OutputSymbolFlags.StaticMember) {
-      result.memberPath.unshift(currentSymbol);
-      currentSymbol = currentSymbol.scope.owner;
-    }
-    if (symbol.flags & OutputSymbolFlags.StaticMember) {
-      result.memberPath.unshift(currentSymbol);
+    if (currentSymbol.isMemberSymbol) {
+      result.memberPath = [];
+      while (currentSymbol.isMemberSymbol) {
+        result.memberPath.unshift(currentSymbol);
+        currentSymbol = currentSymbol.ownerSymbol;
+      }
     }
     const startScope = currentSymbol.scope;
     result.scopeChain = scopeChain(startScope);
@@ -168,14 +200,39 @@ export function createOutputBinder(options = {}) {
     if (waitingDeclarations.has(refkey)) {
       return waitingDeclarations.get(refkey);
     }
-    const symbolRef = shallowRef();
+    let symbolRef;
+    if (isMemberRefkey(refkey)) {
+      const baseSymbolRef = getSymbolForRefkey(refkey.base);
+      const memberSymbolRef = getSymbolForRefkey(refkey.member);
+      symbolRef = computed(() => {
+        // even though we don't necessarily need the base symbol to be available
+        // yet (the member symbol might already be declared on a type), we wait
+        // to resolve the member refkey until the base symbol is available.
+        const baseSymbol = baseSymbolRef.value;
+        const memberSymbol = memberSymbolRef.value;
+        if (!baseSymbol || !memberSymbol) {
+          return undefined;
+        }
+        return memberSymbol;
+      });
+    } else {
+      symbolRef = shallowRef();
+    }
     waitingDeclarations.set(refkey, symbolRef);
     if (knownDeclarations.has(refkey)) {
       symbolRef.value = knownDeclarations.get(refkey);
     }
     return symbolRef;
   }
-  function resolveDeclarationByKey(currentScope, currentMemberScope, refkey) {
+
+  /**
+   * There are two ways to reference a member symbol - directly via its refkey,
+   * and via a member refkey. In the former case, we just find the member
+   * symbol, and then compute its path directly from there. In hte latter case,
+   * we need to find the base of the member expression, and then add the members
+   * from the (possibly nested) member refkey to result.
+   */
+  function resolveDeclarationByKey(currentScope, refkey, options = {}) {
     const resolvedSymbol = getSymbolForRefkey(refkey);
     return computed(() => {
       trace(TracePhase.resolve.pending, () => `Resolving ${formatRefkeys(refkey)}.`);
@@ -185,21 +242,101 @@ export function createOutputBinder(options = {}) {
         return undefined;
       }
       trace(TracePhase.resolve.pending, () => `${formatRefkeys(refkey)} resolved to ${formatSymbolName(symbol)}.`);
-      if (hasTransientScope(symbol)) {
-        trace(TracePhase.resolve.failure, () => `Symbol ${formatSymbolName(symbol)} in transient scope.`);
+      if (symbol.isTransient) {
+        trace(TracePhase.resolve.failure, () => `Symbol ${formatSymbolName(symbol)} is transient.`);
         return undefined;
       }
-      trace(TracePhase.resolve.success, () => `${formatRefkeys(refkey)} successfully resolved to ${formatSymbolName(symbol)}.`);
-      return buildResult(currentScope, currentMemberScope, symbol);
+      const chain = scopeChain(symbol.scope);
+      if (chain.some(scope => scope.isTransient)) {
+        trace(TracePhase.resolve.failure, () => `Symbol ${formatSymbolName(symbol)} is in a transient scope.`);
+        return undefined;
+      }
+      let result;
+      let memberDescriptorsFromRefkey;
+      if (isMemberRefkey(refkey)) {
+        memberDescriptorsFromRefkey = getMemberPathFromRefkey(refkey);
+        result = buildResult(currentScope, memberDescriptorsFromRefkey[0].symbol);
+      } else {
+        memberDescriptorsFromRefkey = [];
+        result = buildResult(currentScope, symbol);
+      }
+
+      // When we have member descriptors, this first entry is already part of the result due to passing it
+      // to buildResult above, so we don't need it here.
+      const newMemberPathDescriptors = memberDescriptorsFromRefkey.slice(1);
+      const allDescriptors = [...result.memberPath.map(s => ({
+        symbol: s,
+        isMemberAccess: false
+      })), ...newMemberPathDescriptors];
+
+      // update the member path and resolved symbol from our member descriptors
+      // (if we have them)
+      if (memberDescriptorsFromRefkey.length > 0) {
+        for (const descriptor of newMemberPathDescriptors) {
+          result.memberPath.push(descriptor.symbol);
+        }
+        result.symbol = memberDescriptorsFromRefkey.at(-1).symbol;
+      }
+
+      // a subcomputed here ensures we don't lose the progress above When
+      // we fail to resolve because a type isn't available yet.
+      return computed(() => {
+        // resolve each member in the member path
+        let currentBase = result.lexicalDeclaration;
+        for (const descriptor of allDescriptors) {
+          const member = descriptor.symbol;
+          if (currentBase.isTyped && !currentBase.hasTypeSymbol) {
+            trace(TracePhase.resolve.pending, () => `${formatRefkeys(refkey)} needs type information from a parent type.`);
+            // waiting for type
+            return undefined;
+          }
+          resolveMember(currentBase, member, options.memberResolver, {
+            referencePath: result.fullReferencePath,
+            isMemberAccess: descriptor.isMemberAccess
+          });
+          currentBase = member;
+        }
+        trace(TracePhase.resolve.success, () => `${formatRefkeys(refkey)} successfully resolved to ${formatSymbolName(symbol)}.`);
+        return result;
+      }).value;
     });
   }
-  function notifySymbolCreated(symbol) {
-    if (symbol.flags & OutputSymbolFlags.Transient) {
-      // just ignore transient symbols.
-      return;
+
+  /**
+   * Extracts member descriptors from a refkey, tracking which members
+   * were accessed via memberRefkey for proper member resolution context.
+   */
+  function getMemberPathFromRefkey(refkey) {
+    if (isMemberRefkey(refkey)) {
+      return [...getMemberPathFromRefkey(refkey.base), {
+        symbol: getSymbolForRefkey(refkey.member).value,
+        isMemberAccess: true
+      }];
+    }
+    return [{
+      symbol: getSymbolForRefkey(refkey).value,
+      isMemberAccess: false
+    }];
+  }
+  function resolveMember(base, member, memberResolver, context) {
+    if (memberResolver) {
+      memberResolver(base, member, context);
+    } else {
+      // default member resolution
+      if (!member.isMemberSymbol) {
+        throw new Error(`${formatSymbolName(member)} is not a member symbol.`);
+      }
+      const memberOwner = base.hasTypeSymbol ? base.type : base.dealias();
+      if (member.ownerSymbol !== memberOwner) {
+        throw new Error(`${formatSymbolName(member)} is not a member of ${formatSymbolName(base)}.`);
+      }
     }
+  }
+  function notifySymbolCreated(symbol) {
     effect(oldRefkeys => {
-      trace(TracePhase.resolve.pending, () => `Notifying resolutions for ${formatRefkeys(symbol.refkeys)}.`);
+      if (symbol.refkeys) {
+        trace(TracePhase.resolve.pending, () => `Notifying resolutions for ${formatRefkeys(symbol.refkeys)}.`);
+      }
       if (oldRefkeys) {
         for (const refkey of oldRefkeys) {
           if (!symbol.refkeys.includes(refkey)) {
@@ -221,9 +358,13 @@ export function createOutputBinder(options = {}) {
           const signal = waitingDeclarations.get(refkey);
           signal.value = symbol;
         }
+        const scope = symbol.scope;
+        if (!scope) {
+          continue;
+        }
 
         // notify those waiting for this symbol name
-        const waitingScope = waitingSymbolNames.get(symbol.scope);
+        const waitingScope = waitingSymbolNames.get(scope);
         if (waitingScope) {
           const waitingName = waitingScope.get(symbol.name);
           if (waitingName) {
@@ -234,83 +375,6 @@ export function createOutputBinder(options = {}) {
       return [...symbol.refkeys];
     });
   }
-  function findSymbolName(scope, name) {
-    return untrack(() => {
-      scope ??= binder.globalScope;
-      for (const sym of scope.symbols) {
-        if (sym.name === name) {
-          return shallowRef(sym);
-        }
-      }
-      const symRef = shallowRef(undefined);
-      if (!waitingSymbolNames.has(scope)) {
-        waitingSymbolNames.set(scope, new Map());
-      }
-      const waiting = waitingSymbolNames.get(scope);
-      waiting.set(name, symRef);
-      return symRef;
-    });
-  }
-  function findScopeName(scope, name) {
-    return untrack(() => {
-      scope ??= binder.globalScope;
-      for (const child of scope.children) {
-        if (child.name === name) {
-          return shallowRef(child);
-        }
-      }
-      const scopeRef = shallowRef(undefined);
-      if (!waitingScopeNames.has(scope)) {
-        waitingScopeNames.set(scope, new Map());
-      }
-      const waiting = waitingScopeNames.get(scope);
-      waiting.set(name, scopeRef);
-      return scopeRef;
-    });
-  }
-  function findScopeOrSymbolName(scope, name) {
-    return untrack(() => {
-      return computed(() => {
-        return findSymbolName(scope, name).value ?? findScopeName(scope, name).value;
-      });
-    });
-  }
-  function resolveFQN(fqn) {
-    const parts = fqn.match(/[^.#]+|[.#]/g);
-    if (!parts) return ref(undefined);
-    if (parts.length === 0) return ref(undefined);
-    parts.unshift(".");
-    return computed(() => {
-      let base = binder.globalScope;
-      for (let i = 0; i < parts.length; i += 2) {
-        if (base === undefined) {
-          return;
-        }
-        const op = parts[i];
-        const name = parts[i + 1];
-        if (op === ".") {
-          if ("originalName" in base) {
-            if (!base.staticMemberScope) {
-              return undefined;
-            }
-            base = findSymbolName(base.staticMemberScope, name).value;
-          } else {
-            base = findScopeOrSymbolName(base, name).value;
-          }
-        } else if (op === "#") {
-          if ("originalName" in base) {
-            if (!base.instanceMemberScope) {
-              return undefined;
-            }
-            base = findSymbolName(base.instanceMemberScope, name).value;
-          } else {
-            return undefined;
-          }
-        }
-      }
-      return base;
-    });
-  }
 }
 
 /**
@@ -323,14 +387,14 @@ export function createOutputBinder(options = {}) {
  * not found. The symbol you're looking for may not have been declared yet. When the symbol
  * is declared, the ref will be updated with the resolution result.
  */
-export function resolve(refkey) {
+export function resolve(refkey, options = {}) {
   const scope = useScope();
-  const memberScope = useMemberScope();
-  const binder = scope?.binder ?? memberScope?.instanceMembers?.binder ?? memberScope?.staticMembers?.binder;
+  const memberScope = useMemberContext();
+  const binder = scope?.binder ?? memberScope?.ownerSymbol.binder;
   if (!binder) {
     throw new Error("Can't resolve refkey without a binder");
   }
-  return binder.resolveDeclarationByKey(scope, memberScope?.instanceMembers, refkey);
+  return binder.resolveDeclarationByKey(scope, refkey, options);
 }
 const createSymbolsSymbol = Symbol();
 export function getSymbolCreator(creator) {
@@ -338,27 +402,4 @@ export function getSymbolCreator(creator) {
 }
 export function getSymbolCreatorSymbol() {
   return createSymbolsSymbol;
-}
-/**
- * Use symbol flags to determine the scope in which a symbol with those flags
- * should be declared given the current context.
- *
- * @param flags - The symbol flags to use to determine the default scope.
- * @returns an {@link OutputScope} that is the default scope for the given
- * flags.
- */
-export function useDefaultScope(flags = OutputSymbolFlags.None) {
-  if ((flags & OutputSymbolFlags.Member) === 0) {
-    return useScope();
-  } else {
-    const memberScope = useMemberScope();
-    if (!memberScope) {
-      throw new Error("Cannot declare member symbols without a member scope");
-    }
-    if (flags & OutputSymbolFlags.InstanceMember) {
-      return memberScope.instanceMembers;
-    } else {
-      return memberScope.staticMembers;
-    }
-  }
 }