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

package/src/symbols/output-symbol.ts

@@ -1,6 +1,8 @@
 import {
+  isRef,
   reactive,
   ReactiveFlags,
+  Ref,
   shallowReactive,
   track,
   TrackOpTypes,
@@ -10,27 +12,88 @@ import {
 } from "@vue/reactivity";
 import type { Binder } from "../binder.js";
 import { useBinder } from "../context/binder.js";
-import { useMemberScope } from "../context/member-scope.js";
-import { useScope } from "../context/scope.js";
-import { isRefkey, refkey, type Refkey } from "../refkey.js";
+import { inspect } from "../inspect.js";
+import { NamePolicyGetter } from "../name-policy.js";
+import { untrack } from "../reactivity.js";
+import { Namekey, type Refkey } from "../refkey.js";
 import {
-  formatScopeName,
   formatSymbol,
   formatSymbolName,
   trace,
   traceEffect,
   TracePhase,
 } from "../tracer.js";
-import { OutputScopeFlags, OutputSymbolFlags } from "./flags.js";
-import { OutputScope } from "./output-scope.js";
+import {
+  OutputDeclarationSpace,
+  OutputMemberSpace,
+  OutputSpace,
+} from "./output-space.js";
+import { SymbolTable } from "./symbol-table.js";
 
 export interface OutputSymbolOptions {
+  /**
+   * The binder instance associated with this symbol. Symbol updates and changes
+   * will be reported to this binder. This binder will be able to find this
+   * symbol via its refkey and other means. Without a binder, this symbol will
+   * be unbound, which means it cannot be referenced by refkey.
+   */
   binder?: Binder;
-  scope?: OutputScope;
-  flags?: OutputSymbolFlags;
+
+  /**
+   * The refkey or refkeys associated with this symbol.
+   */
   refkeys?: Refkey | Refkey[];
+
+  /**
+   * Arbitrary metadata about this symbol.
+   */
   metadata?: Record<string, unknown>;
+
+  /**
+   * The symbol this symbol is an alias for.
+   */
   aliasTarget?: OutputSymbol;
+
+  /**
+   * Whether this symbol is transient.
+   */
+  transient?: boolean;
+
+  /**
+   * The symbol that provides type information for this symbol. When present,
+   * this symbol will not contain its own members, and instead members will be
+   * provided by the type. This can be provided a Ref, in which case the type
+   * will be the value of that ref.
+   */
+  type?: OutputSymbol | Ref<OutputSymbol | undefined>;
+
+  /**
+   * When provided, this symbol will be named according to the provided name
+   * policy.
+   *
+   * @example
+   *
+   * ```ts
+   * const classNamer = useNamePolicy().for("class");
+   * const symbol = new BasicSymbol("my-class", { namePolicy: classNamer });
+   * console.log(symbol.name); // "MyClass" (assuming a PascalCase class naming policy)
+   * ```
+   */
+  namePolicy?: NamePolicyGetter;
+
+  /**
+   * Whether the name of this symbol should bypass the active name policy. When true,
+   * the name of this symbol will be fixed, though it may conflict with other symbols which are
+   * also ignoring the name policy.
+   */
+  ignoreNamePolicy?: boolean;
+
+  /**
+   * Whether the name of this symbol should bypass the active name conflict resolution.
+   * When true, the name of this symbol will be fixed, though it may conflict with other symbols which are
+   * also ignoring name conflict resolution.
+   */
+  ignoreNameConflict?: boolean;
 }
 
 let symbolCount = 0;
@@ -45,17 +108,32 @@ let symbolCount = 0;
  * subtypes that provide additional metadata. Symbols are reactive values, so
  * you can observe changes to their properties in a reactive context.
  */
-export class OutputSymbol {
+export abstract class OutputSymbol {
+  public static readonly memberSpaces: Readonly<string[]> = [];
+
   #originalName: string;
+  /**
+   * Read only. The requested name of this symbol. The symbol's actual name may
+   * be different depending on naming policy or conflicts with other symbols.
+   *
+   * @readonly
+   */
   get originalName() {
     return this.#originalName;
   }
 
-  #name: string;
+  // this field is set by calling the name accessor.
+  #name!: string;
+  /**
+   * The name of this symbol.
+   *
+   * @reactive
+   */
   get name() {
     track(this, TrackOpTypes.GET, "name");
     return this.#name;
   }
+
   set name(name: string) {
     const old = this.#name;
 
@@ -63,81 +141,139 @@ export class OutputSymbol {
       return;
     }
 
-    this.#name = name;
+    this.#name =
+      this.#namePolicy && !this.#ignoreNamePolicy ?
+        this.#namePolicy(name)
+      : name;
     trigger(this, TriggerOpTypes.SET, "name", name, old);
   }
 
   #id: number;
+  /**
+   * The unique id of this symbol.
+   *
+   * @readonly
+   */
   get id() {
     return this.#id;
   }
 
-  #flags: OutputSymbolFlags;
-  get flags() {
-    track(this, TrackOpTypes.GET, "flags");
-    return this.#flags;
+  #ignoreNamePolicy: boolean = false;
+  /**
+   * Whether the name of this symbol bypasses the active name policy. When true,
+   * the name of this symbol will be fixed, though it may conflict with other
+   * symbols which are also ignoring the name policy.
+   *
+   * @readonly
+   */
+  get ignoreNamePolicy() {
+    return this.#ignoreNamePolicy;
   }
-  set flags(flags: OutputSymbolFlags) {
-    const old = this.#flags;
-
-    if (old === flags) {
-      return;
-    }
 
-    this.#flags = flags;
-    trigger(this, TriggerOpTypes.SET, "flags", flags, old);
+  #ignoreNameConflict: boolean = false;
 
-    this.#createInstanceMemberScope();
-    this.#createStaticMemberScope();
+  /**
+   * Whether the name of this symbol bypasses the active name conflict
+   * resolution. When true, the name of this symbol will be fixed, though it may
+   * conflict with other symbols which are also ignoring name conflict
+   * resolution.
+   */
+  get ignoreNameConflict() {
+    return this.#ignoreNameConflict;
   }
 
-  #scope: OutputScope;
-  get scope() {
-    track(this, TrackOpTypes.GET, "scope");
-    return this.#scope;
+  #memberSpaces: Record<string, OutputMemberSpace> = shallowReactive({});
+  /**
+   * The member spaces of this symbol.
+   *
+   * @readonly
+   */
+  get memberSpaces() {
+    return Object.values(this.#memberSpaces);
   }
 
-  set scope(scope: OutputScope) {
-    const old = this.#scope;
+  /**
+   * Get the member space for the given key.
+   */
+  memberSpaceFor(spaceKey: string): OutputMemberSpace | undefined {
+    return this.#memberSpaces[spaceKey];
+  }
 
-    if (old === scope) {
-      return;
+  /**
+   * The scope this symbol is in. When this symbol is a member symbol, this will
+   * return undefined.
+   *
+   * @readonly
+   */
+  get scope() {
+    if (this.isMemberSymbol) {
+      return undefined;
     }
 
-    this.#handleNewScope(scope, old);
+    if (this.spaces.length === 0) {
+      return undefined;
+    }
 
-    this.#scope = scope;
+    return (this.spaces[0] as OutputDeclarationSpace).scope;
+  }
 
-    trigger(this, TriggerOpTypes.SET, "scope", scope, old);
+  #spaces: OutputSpace[];
+  /**
+   * The declaration or member spaces this symbol belongs to.
+   *
+   * @reactive
+   */
+  get spaces(): OutputSpace[] {
+    track(this, TrackOpTypes.GET, "spaces");
+    return this.#spaces;
   }
 
-  #handleNewScope(newScope: OutputScope, oldScope?: OutputScope) {
-    if (oldScope) {
-      // ensure when changing scope that this symbol only belongs to one of them
-      oldScope.symbols.delete(this);
-    }
+  set spaces(spaces: OutputSpace[] | OutputSpace | undefined) {
+    const old = this.#spaces;
 
-    if (!newScope) {
+    if (old === spaces) {
       return;
     }
 
-    newScope.symbols.add(this);
+    const spacesArray =
+      spaces === undefined ? []
+      : Array.isArray(spaces) ? spaces
+      : [spaces];
+    this.#handleNewSpaces(spacesArray, old);
+
+    this.#spaces = spacesArray;
 
-    if (newScope.flags & OutputScopeFlags.InstanceMemberScope) {
-      this.flags |= OutputSymbolFlags.InstanceMember;
+    trigger(this, TriggerOpTypes.SET, "spaces", spaces, old);
+  }
+
+  #handleNewSpaces(newSpaces: SymbolTable[], oldSpaces?: SymbolTable[]) {
+    if (oldSpaces) {
+      // ensure when changing scope that this symbol only belongs to one of them
+      oldSpaces.forEach((oldSpace) => oldSpace.delete(this));
     }
 
-    if (newScope.flags & OutputScopeFlags.StaticMemberScope) {
-      this.flags |= OutputSymbolFlags.StaticMember;
+    if (newSpaces) {
+      newSpaces.forEach((newSpace) => newSpace.add(this));
     }
   }
 
   #binder: Binder | undefined;
+  /**
+   * The binder that is tracking this symbol.
+   *
+   * @readonly
+   */
   get binder() {
     return this.#binder;
   }
 
   #refkeys: Refkey[];
+
+  /**
+   * The refkeys for this symbol.
+   *
+   * @reactive
+   */
   get refkeys() {
     track(this, TrackOpTypes.GET, "refkeys");
     return this.#refkeys;
@@ -156,122 +292,225 @@ export class OutputSymbol {
     trigger(this, TriggerOpTypes.SET, "refkeys", this.#refkeys, old);
   }
 
-  #instanceMemberScope?: OutputScope;
-  get instanceMemberScope() {
-    track(this, TrackOpTypes.GET, "instanceMemberScope");
-    return this.#instanceMemberScope;
-  }
-
   #aliasTarget?: OutputSymbol;
+  /**
+   * The symbol that this symbol is an alias for.
+   *
+   * @readonly
+   */
   get aliasTarget() {
     return this.#aliasTarget;
   }
 
-  #createInstanceMemberScope() {
-    if (
-      this.#instanceMemberScope ||
-      !(this.#flags & OutputSymbolFlags.InstanceMemberContainer)
-    ) {
-      return;
+  /**
+   * If this symbol is an alias for another symbol, return the the aliased symbol. Otherwise, return this symbol.
+   */
+  dealias(): OutputSymbol {
+    if (this.#aliasTarget) {
+      return this.#aliasTarget.dealias();
     }
+    return this;
+  }
 
-    this.#instanceMemberScope = new OutputScope(
-      `${this.name} instance members`,
-      {
-        binder: this.#binder,
-        owner: this,
-        flags: OutputScopeFlags.InstanceMemberScope,
-      },
-    );
-    trigger(
-      this,
-      TriggerOpTypes.SET,
-      "instanceMemberScope",
-      this.#instanceMemberScope,
-      undefined,
-    );
+  /**
+   * Whether this symbol is an alias for another symbol.
+   *
+   * @readonly
+   */
+  get isAlias() {
+    return !!this.#aliasTarget;
   }
 
+  #metadata: Record<string, unknown>;
   /**
-   * Create an output scope to hold member symbols. By default this just creates
-   * an OutputScope, but can be subclassed to build scope subtypes when needed.
+   * An arbitrary bag of metadata for this symbol. This property is read only,
+   * but the metadata is a reactive object.
+   *
+   * @readonly
    */
-  protected createMemberScope(
-    name: string,
-    options: {
-      owner?: OutputSymbol;
-      flags?: OutputScopeFlags;
-    },
-  ) {
-    return new OutputScope(name, {
-      binder: this.#binder,
-      owner: options.owner,
-      flags: options.flags,
-    });
+  get metadata() {
+    return this.#metadata;
   }
 
-  #staticMemberScope?: OutputScope;
-  get staticMemberScope() {
-    track(this, TrackOpTypes.GET, "staticMemberScope");
-    return this.#staticMemberScope;
+  copyToSpace(space: OutputSpace) {
+    const copy = this.copy();
+    copy.spaces = space;
+    return copy;
   }
 
-  #createStaticMemberScope() {
-    if (
-      this.#staticMemberScope ||
-      !(this.#flags & OutputSymbolFlags.StaticMemberContainer)
-    ) {
-      return;
+  /**
+   * Whether this symbol is a member of another symbol.
+   *
+   * @readonly
+   */
+  get isMemberSymbol() {
+    return this.spaces[0] instanceof OutputMemberSpace;
+  }
+
+  /**
+   * When this is a member symbol, this returns the symbol that this is symbol
+   * is a member of.
+   */
+  get ownerSymbol(): OutputSymbol | undefined {
+    if (!this.isMemberSymbol) {
+      return undefined;
     }
 
-    this.#staticMemberScope = new OutputScope(`${this.name} static members`, {
-      binder: this.#binder,
-      owner: this,
-      flags: OutputScopeFlags.StaticMemberScope,
-    });
-    trigger(
-      this,
-      TriggerOpTypes.SET,
-      "staticMemberScope",
-      this.#staticMemberScope,
-      undefined,
-    );
+    return (this.spaces[0] as OutputMemberSpace).symbol;
   }
 
-  #metadata: Record<string, unknown>;
-  get metadata() {
-    return this.#metadata;
+  #isTransient: boolean;
+
+  /**
+   * Whether this symbol is a transient symbol. Transient symbols cannot be
+   * referenced and are meant to be combined with other symbols.
+   *
+   * @readonly
+   */
+  get isTransient(): boolean {
+    if (this.#isTransient) {
+      return true;
+    }
+
+    if (this.ownerSymbol) {
+      return this.ownerSymbol.isTransient;
+    }
+
+    return false;
   }
 
+  #movedTo: OutputSymbol | undefined;
   /**
-   * Tell \@vue/reactivity that this symbol should never be wrapped in a reactive
-   * proxy.
+   * The symbol that this symbol's members have been moved to.
+   *
+   * @readonly
+   * @reactive
+   */
+  get movedTo() {
+    track(this, TrackOpTypes.GET, "movedTo");
+    return this.#movedTo;
+  }
+
+  #setMovedTo(value: OutputSymbol | undefined) {
+    this.#movedTo = value;
+    trigger(this, TriggerOpTypes.SET, "movedTo");
+  }
+
+  /**
+   * Whether this symbol's members have been moved to another symbol.
+   *
+   * @reactive
    */
+  get isMoved() {
+    return this.movedTo !== undefined;
+  }
+
+  #type: OutputSymbol | undefined;
+
+  /**
+   * The symbol which defines the type of this symbol. The type symbol provides
+   * information about the value this symbol contains, such as what members it
+   * has.
+   *
+   * @reactive
+   */
+  get type() {
+    track(this, TrackOpTypes.GET, "type");
+    return this.#type;
+  }
+
+  set type(value: OutputSymbol | Ref<OutputSymbol | undefined> | undefined) {
+    if (isRef(value)) {
+      watch(value, (newValue) => {
+        const old = this.#type;
+        this.#type = newValue && newValue.dealias();
+        trigger(this, TriggerOpTypes.SET, "type", newValue, old);
+      });
+    } else {
+      const old = this.#type;
+      this.#type = value && value.dealias();
+      trigger(this, TriggerOpTypes.SET, "type", value, old);
+    }
+  }
+
+  /**
+   * Whether this symbol has its symbol representing its type available.
+   *
+   * @readonly
+   * @reactive
+   */
+  get hasTypeSymbol() {
+    return this.type !== undefined;
+  }
+
+  #isTyped: boolean = false;
+
+  /**
+   * Whether this symbol's members are provided by a type symbol. The
+   * `typeSymbol` property is this symbol. It may not be available yet, so check
+   * `hasTypeSymbol`.
+   */
+  get isTyped() {
+    return this.#isTyped;
+  }
+
+  #namePolicy: NamePolicyGetter | undefined;
+  get namePolicy() {
+    return this.#namePolicy;
+  }
+
+  // Tell \@vue/reactivity that this symbol should never be wrapped in a reactive
+  // proxy.
   [ReactiveFlags.SKIP] = true;
 
-  constructor(name: string, options: OutputSymbolOptions = {}) {
+  constructor(
+    name: string | Namekey,
+    spaces: OutputSpace[] | OutputSpace | undefined,
+    options: OutputSymbolOptions = {},
+  ) {
     this.#binder = options.binder ?? useBinder();
-    this.#name = name;
-    this.#originalName = name;
-    this.#id = symbolCount++;
-    this.#flags = options.flags ?? OutputSymbolFlags.None;
-    this.#scope = options.scope ?? (this.#defaultScope() as OutputScope);
-    this.#aliasTarget = options.aliasTarget;
-    if (this.#aliasTarget) {
-      this.#flags |= OutputSymbolFlags.Alias;
-      this.#flags &= ~(
-        OutputSymbolFlags.MemberContainer | OutputSymbolFlags.Member
+    this.#namePolicy = options.namePolicy;
+
+    if (typeof name === "string") {
+      this.#ignoreNameConflict = !!options.ignoreNameConflict;
+      this.#ignoreNamePolicy = !!options.ignoreNamePolicy;
+      this.name = name;
+      this.#originalName = name;
+      this.#refkeys = shallowReactive(
+        this.#normalizeRefkeyOption(options.refkeys),
       );
+    } else {
+      this.#ignoreNameConflict =
+        name.options.ignoreNameConflict ?? !!options.ignoreNameConflict;
+      this.#ignoreNamePolicy =
+        name.options.ignoreNamePolicy ?? !!options.ignoreNamePolicy;
+      this.name = name.name;
+      this.#originalName = name.name;
+      this.#refkeys = shallowReactive([
+        name,
+        ...this.#normalizeRefkeyOption(options.refkeys),
+      ]);
     }
-    this.#refkeys = shallowReactive(
-      Array.isArray(options.refkeys) ? options.refkeys
-      : isRefkey(options.refkeys) ? [options.refkeys]
-      : [],
-    );
+
+    this.#id = symbolCount++;
+    this.#spaces =
+      Array.isArray(spaces) ? spaces
+      : spaces === undefined ? []
+      : [spaces];
+    this.#aliasTarget = options.aliasTarget;
     this.#metadata = reactive(options.metadata ?? {});
-    this.#createInstanceMemberScope();
-    this.#createStaticMemberScope();
-    this.#handleNewScope(this.#scope);
+    this.#isTransient = !!options.transient;
+    this.#isTyped = !!options.type;
+    this.type = options.type;
+
+    this.#handleNewSpaces(this.#spaces);
+    const constructor = this.constructor as typeof OutputSymbol;
+    this.#memberSpaces = Object.fromEntries(
+      constructor.memberSpaces.map((spaceKey) => [
+        spaceKey,
+        new OutputMemberSpace(this, spaceKey, this.#binder),
+      ]),
+    );
 
     trace(TracePhase.symbol.create, () => `${formatSymbol(this)}`);
     traceEffect(TracePhase.symbol.update, () => {
@@ -280,104 +519,72 @@ export class OutputSymbol {
     this.#binder?.notifySymbolCreated(this);
   }
 
+  #normalizeRefkeyOption(refkeys: Refkey | Refkey[] | undefined) {
+    if (refkeys === undefined) {
+      return [];
+    } else if (Array.isArray(refkeys)) {
+      return refkeys;
+    } else {
+      return [refkeys];
+    }
+  }
+
   delete() {
     trace(TracePhase.symbol.delete, () => `${formatSymbolName(this)}`);
-    if (this.#scope) {
-      this.#scope.symbols.delete(this);
+    if (this.#spaces) {
+      this.#spaces.forEach((space) => space.delete(this));
     }
 
     this.#binder?.notifySymbolDeleted(this);
   }
 
   /**
-   * Takes the instance members or static members on this symbol and creates
-   * corresponding static members on the target symbol. Instance or static
-   * members of instantiated symbols are copied. The refkey of any instantiated
-   * symbols are set to a composite refkey of the target symbol's refkey and the
-   * instantiated symbol's refkey.
+   * Move member symbols from this transient symbol to the target symbol. This is reactive -
+   * whenever a member is added to this symbol, it will be moved to the target
+   * symbol.
    */
-  instantiateTo(targetSymbol: OutputSymbol): void {
+  moveMembersTo(targetSymbol: OutputSymbol): void {
     if (this.#aliasTarget) {
-      return this.#aliasTarget.instantiateTo(targetSymbol);
+      return this.#aliasTarget.moveMembersTo(targetSymbol);
     }
 
-    trace(TracePhase.symbol.instantiate, () => {
-      return `${formatSymbolName(this)} -> ${formatSymbolName(targetSymbol)}`;
-    });
-
-    const from = this.#instanceMemberScope ?? this.#staticMemberScope;
-
-    if (from) {
-      targetSymbol.flags |= OutputSymbolFlags.StaticMemberContainer;
-      targetSymbol.#createStaticMemberScope();
-      targetSymbol.#staticMemberScope!.copySymbolsFrom(from, {
-        onAdd: (symbol) => {
-          const clone = symbol.copyToScope(
-            targetSymbol.#staticMemberScope!,
-            targetSymbol,
-          );
-          clone.#flags &= ~OutputSymbolFlags.InstanceMember;
-          clone.#flags |= OutputSymbolFlags.StaticMember;
-          return clone;
-        },
-      });
+    if (!this.isTransient) {
+      throw new Error("Can only move members from transient symbols");
     }
-  }
 
-  #instantiationRk(base: OutputSymbol, member: OutputSymbol) {
-    const instantiationRks = [];
-    for (const baseRk of base.refkeys) {
-      for (const targetRk of member.refkeys) {
-        instantiationRks.push(refkey(baseRk, targetRk));
+    for (const sourceSpace of this.memberSpaces) {
+      const targetSpace = targetSymbol.memberSpaceFor(sourceSpace.key);
+      if (!targetSpace) {
+        throw new Error(
+          "Target symbol doesn't have member space " + sourceSpace.key,
+        );
       }
-    }
-
-    return instantiationRks;
-  }
 
-  /**
-   * Copy member symbols from the target symbol into the target symbol. The
-   * copied symbols have their refkey set to
-   * `refkey(targetSymbol.refkey, this.refkey)`.
-   */
-  copyTo(targetSymbol: OutputSymbol): void {
-    if (this.#aliasTarget) {
-      return this.#aliasTarget.copyTo(targetSymbol);
-    }
-    if (this.staticMemberScope) {
-      targetSymbol.flags |= OutputSymbolFlags.StaticMemberContainer;
-      targetSymbol.staticMemberScope!.copySymbolsFrom(this.staticMemberScope);
+      sourceSpace.moveTo(targetSpace);
     }
 
-    if (this.instanceMemberScope) {
-      targetSymbol.flags |= OutputSymbolFlags.InstanceMemberContainer;
-      targetSymbol.instanceMemberScope!.copySymbolsFrom(
-        this.instanceMemberScope,
-      );
-    }
+    this.#setMovedTo(targetSymbol);
   }
 
   /**
-   * Move member symbols from this transient symbol to the target symbol.
+   * Copy the members of this symbol to the target symbol. This is reactive -
+   * whenever a member is added to this symbol, it will be copied to the target
+   * symbol.
    */
-  moveTo(targetSymbol: OutputSymbol): void {
+  copyMembersTo(targetSymbol: OutputSymbol): void {
     if (this.#aliasTarget) {
-      return this.#aliasTarget.moveTo(targetSymbol);
+      return this.#aliasTarget.copyMembersTo(targetSymbol);
     }
 
-    if (!(this.flags & OutputSymbolFlags.Transient)) {
-      throw new Error("Can only move members from transient symbols");
-    }
-    if (this.staticMemberScope) {
-      targetSymbol.flags |= OutputSymbolFlags.StaticMemberContainer;
-      targetSymbol.staticMemberScope!.moveSymbolsFrom(this.staticMemberScope);
-    }
+    for (const sourceSpace of this.memberSpaces) {
+      const targetSpace = targetSymbol.memberSpaceFor(sourceSpace.key);
+      if (!targetSpace) {
+        throw new Error(
+          "Target symbol doesn't have member space " + sourceSpace.key,
+        );
+      }
 
-    if (this.instanceMemberScope) {
-      targetSymbol.flags |= OutputSymbolFlags.InstanceMemberContainer;
-      targetSymbol.instanceMemberScope!.moveSymbolsFrom(
-        this.instanceMemberScope,
-      );
+      sourceSpace.copyTo(targetSpace);
     }
   }
 
@@ -394,66 +601,35 @@ export class OutputSymbol {
    *
    * @param newScope - The scope to use for the copy.
    */
-  copyToScope(newScope: OutputScope, baseSymbol?: OutputSymbol): OutputSymbol {
-    if (this.#aliasTarget) {
-      return this.#aliasTarget.copyToScope(newScope, baseSymbol);
-    }
-    trace(TracePhase.symbol.clone, () => {
-      return `${formatSymbolName(this)} -> ${formatScopeName(newScope)}`;
-    });
-    const clone = new OutputSymbol(this.#name, {
-      binder: this.#binder,
-      scope: newScope,
-      flags: this.#flags,
-      refkeys: baseSymbol ? this.#instantiationRk(baseSymbol, this) : [],
-      metadata: this.#metadata,
-    });
+  abstract copy(): OutputSymbol;
+
+  protected getCopyOptions() {
+    return {
+      binder: this.binder,
+      aliasTarget: this.aliasTarget,
+      metadata: this.metadata,
+      transient: this.isTransient,
+    };
+  }
 
-    if (this.instanceMemberScope) {
-      clone.#instanceMemberScope = this.instanceMemberScope.clone({
-        owner: clone,
-      });
-    }
+  protected initializeCopy(copy: OutputSymbol) {
+    for (const sourceSpace of this.memberSpaces) {
+      const targetSpace = copy.memberSpaceFor(sourceSpace.key);
 
-    if (this.staticMemberScope) {
-      clone.#staticMemberScope = this.staticMemberScope.clone({ owner: clone });
+      if (!targetSpace) {
+        throw new Error("Target doesn't have space " + sourceSpace.key);
+      }
+
+      sourceSpace.copyTo(targetSpace);
     }
 
     watch(
       () => this.name,
-      (newName) => (clone.name = newName),
-    );
-    watch(
-      () => this.flags,
-      (newFlags) => (clone.flags = newFlags),
+      (newName) => (copy.name = newName),
     );
-
-    return clone;
   }
 
-  #defaultScope() {
-    if ((this.#flags & OutputSymbolFlags.Member) === 0) {
-      return useScope();
-    } else {
-      const memberScope = useMemberScope();
-      if (!memberScope) {
-        throw new Error("Cannot declare member symbols without a member scope");
-      }
-      if (this.#flags & OutputSymbolFlags.InstanceMember) {
-        if (!memberScope.instanceMembers) {
-          throw new Error(
-            "Cannot declare instance member symbols without an instance member scope",
-          );
-        }
-        return memberScope.instanceMembers;
-      } else {
-        if (!memberScope.staticMembers) {
-          throw new Error(
-            "Cannot declare static member symbols without a static member scope",
-          );
-        }
-        return memberScope.staticMembers;
-      }
-    }
+  [inspect.custom]() {
+    return untrack(() => `${this.constructor.name} "${this.name}"[${this.id}]`);
   }
 }