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

package/src/symbols/symbol-flow.ts

@@ -1,9 +1,9 @@
 import { isRef, Ref, shallowReactive } from "@vue/reactivity";
 import { Context, effect, getContext, onCleanup } from "../reactivity.js";
 
-import { MemberScopeContext } from "../context/member-scope.js";
+import { MemberContext } from "../context/member-scope.js";
 import { ScopeContext } from "../context/scope.js";
-import { OutputSymbolFlags } from "./flags.js";
+import { formatSymbolName, trace, TracePhase } from "../tracer.js";
 import { OutputSymbol } from "./output-symbol.js";
 
 export interface TakeSymbolCallback {
@@ -36,6 +36,15 @@ export function takeSymbols(cb?: (symbol: OutputSymbol) => void) {
 export function emitSymbol(
   symbol: OutputSymbol | Ref<OutputSymbol | undefined>,
 ) {
+  if (isRef(symbol)) {
+    trace(TracePhase.symbol.flow, () => `Emitting ref to symbol`);
+  } else {
+    trace(
+      TracePhase.symbol.flow,
+      () => `Emitting symbol ${formatSymbolName(symbol)}`,
+    );
+  }
+
   let symbolTaker: Context | undefined;
   let context = getContext()!.owner;
   while (context) {
@@ -46,10 +55,13 @@ export function emitSymbol(
 
     if (
       context.context &&
-      (context.context[ScopeContext.id] ||
-        context.context[MemberScopeContext.id])
+      (context.context[ScopeContext.id] || context.context[MemberContext.id])
     ) {
       // don't cross scope boundaries.
+      trace(
+        TracePhase.symbol.flow,
+        () => `Not emitting symbol across scope boundary`,
+      );
       break;
     }
 
@@ -57,6 +69,7 @@ export function emitSymbol(
   }
 
   if (!symbolTaker) {
+    trace(TracePhase.symbol.flow, () => `No symbol taker found, not emitting`);
     return;
   }
 
@@ -76,6 +89,11 @@ export function emitSymbol(
       }
     });
   } else {
+    trace(
+      TracePhase.symbol.flow,
+      () =>
+        `Emitting symbol ${formatSymbolName(symbol)} taken by ${symbolTaker.componentOwner?.name ?? "unknown component"}`,
+    );
     symbolTaker.takenSymbols!.add(symbol);
     onCleanup(() => {
       context!.takenSymbols!.delete(symbol);
@@ -85,16 +103,27 @@ export function emitSymbol(
 
 export function moveTakenMembersTo(baseSymbol: OutputSymbol) {
   const taken = takeSymbols();
-
   effect(() => {
     for (const symbol of taken) {
-      if (symbol.flags & OutputSymbolFlags.Transient) {
-        symbol.moveTo(baseSymbol);
+      if (symbol.isTransient) {
+        symbol.moveMembersTo(baseSymbol);
+      }
+
+      for (const refkey of symbol.refkeys) {
+        if (!baseSymbol.refkeys.includes(refkey)) {
+          baseSymbol.refkeys.push(refkey);
+        }
       }
     }
   });
 }
 
-export function instantiateTakenMembersTo(baseSymbol: OutputSymbol) {
-  takeSymbols((symbol) => symbol.instantiateTo(baseSymbol));
+export function instantiateTakenMembersTo(
+  baseSymbol: OutputSymbol,
+  toSpaceKey: string,
+  fromSpaceKey: string,
+) {
+  takeSymbols((symbol) => {
+    baseSymbol.type = symbol;
+  });
 }

package/src/symbols/symbol-slot.tsx

@@ -1,10 +1,37 @@
 import { Ref, ShallowReactive, shallowRef } from "@vue/reactivity";
 import { effect, onCleanup } from "../reactivity.js";
-import type { Children } from "../runtime/component.js";
+import type { Children, Component } from "../runtime/component.js";
 import { OutputSymbol } from "./output-symbol.js";
 import { takeSymbols } from "./symbol-flow.js";
 
-export function createSymbolSlot() {
+export interface SymbolSlot extends Component<{}> {
+  /**
+   * A ref for the set of symbols taken by this slot. Undefined when the Slot component
+   * has not been rendered yet.
+   */
+  ref: Ref<ShallowReactive<Set<OutputSymbol>> | undefined>;
+  /**
+   * A ref for the first symbol taken by this slot. Undefined when the Slot component
+   * has not been rendered yet or has not taken any symbols.
+   */
+  firstSymbol: Ref<OutputSymbol | undefined>;
+
+  /**
+   * Copy any members from taken symbols to the given symbol.
+   */
+  copyMembersTo(baseSymbol: OutputSymbol): void;
+
+  /**
+   * Move any members from transient taken symbols to the given symbol.
+   */
+  moveMembersTo(baseSymbol: OutputSymbol): void;
+}
+/**
+ * Create a component which accepts emitted symbols. The returned component has
+ * a `ref` property which is a ref to a reactive set of all symbols emitted by
+ * children of the component.
+ */
+export function createSymbolSlot(): SymbolSlot {
   const symbolSlotRef: Ref<ShallowReactive<Set<OutputSymbol>> | undefined> =
     shallowRef();
   function SymbolSlot(props: { children: Children }) {
@@ -20,29 +47,40 @@ export function createSymbolSlot() {
 
   SymbolSlot.ref = symbolSlotRef;
 
-  SymbolSlot.instantiateInto = (baseSymbol: OutputSymbol) => {
+  Object.defineProperty(SymbolSlot, "firstSymbol", {
+    get() {
+      const ref = shallowRef();
+      effect(() => {
+        ref.value = symbolSlotRef.value?.values().next().value;
+      });
+      return ref;
+    },
+  });
+
+  SymbolSlot.copyMembersTo = (baseSymbol: OutputSymbol) => {
     effect(() => {
       if (!symbolSlotRef.value) {
         return;
       }
 
       for (const symbol of symbolSlotRef.value) {
-        symbol.instantiateTo(baseSymbol);
+        symbol.copyMembersTo(baseSymbol);
       }
     });
   };
 
-  SymbolSlot.copyInto = (baseSymbol: OutputSymbol) => {
+  SymbolSlot.moveMembersTo = (baseSymbol: OutputSymbol) => {
     effect(() => {
       if (!symbolSlotRef.value) {
         return;
       }
-
       for (const symbol of symbolSlotRef.value) {
-        symbol.copyTo(baseSymbol);
+        if (symbol.isTransient) {
+          symbol.moveMembersTo(baseSymbol);
+        }
       }
     });
   };
 
-  return SymbolSlot;
+  return SymbolSlot as any;
 }

package/src/symbols/symbol-table.ts

@@ -1,34 +1,64 @@
-import type { NameConflictResolver } from "../binder.js";
+import type { Binder, NameConflictResolver } from "../binder.js";
 import { ReactiveUnionSet } from "../reactive-union-set.js";
+import { Refkey } from "../refkey.js";
 import { queueJob } from "../scheduler.js";
 import {
-  formatScopeName,
   formatSymbolName,
+  formatSymbolTableName,
   trace,
   TracePhase,
 } from "../tracer.js";
-import type { OutputScope } from "./output-scope.js";
+import { OutputSpace } from "./output-space.js";
 import type { OutputSymbol } from "./output-symbol.js";
 
-export class SymbolTable extends ReactiveUnionSet<OutputSymbol> {
-  private _namesToDeconflict: Set<string> = new Set();
-  private _nameConflictResolver?: NameConflictResolver;
-  private _deconflictNames = () => {
-    for (const name of this._namesToDeconflict) {
+export abstract class SymbolTable extends ReactiveUnionSet<OutputSymbol> {
+  #namesToDeconflict: Set<string> = new Set();
+  #nameConflictResolver?: NameConflictResolver;
+  #deconflictNames = () => {
+    for (const name of this.#namesToDeconflict) {
       const conflictedSymbols = [...this].filter(
-        (sym) => sym.originalName === name,
+        (sym) => sym.originalName === name && !sym.ignoreNameConflict,
       );
-      if (this._nameConflictResolver) {
-        this._nameConflictResolver(name, conflictedSymbols);
+      if (this.#nameConflictResolver) {
+        this.#nameConflictResolver(name, conflictedSymbols);
       } else {
         defaultConflictHandler(name, conflictedSymbols);
       }
-      this._namesToDeconflict.delete(name);
+      this.#namesToDeconflict.delete(name);
     }
   };
-  public scope;
+
+  #binder: Binder | undefined;
+
+  get binder() {
+    return this.#binder;
+  }
+
+  #key: string;
+
+  /**
+   * The key of this symbol table, e.g. "static" or "instance".
+   */
+  get key() {
+    return this.#key;
+  }
+
+  #symbolsByRefkey: ReadonlyMap<Refkey, OutputSymbol>;
+  /**
+   * The symbols defined within this scope, indexed by refkey.
+   */
+  get symbolsByRefkey() {
+    return this.#symbolsByRefkey;
+  }
+
+  #symbolNames: ReadonlyMap<string, OutputSymbol>;
+  get symbolNames() {
+    return this.#symbolNames;
+  }
+
   constructor(
-    scope: OutputScope,
+    key: string,
+    binder?: Binder,
     options: {
       nameConflictResolver?: NameConflictResolver;
     } = {},
@@ -37,26 +67,70 @@ export class SymbolTable extends ReactiveUnionSet<OutputSymbol> {
       onAdd: (symbol) => {
         trace(
           TracePhase.symbol.addToScope,
-          () => `${formatSymbolName(symbol)} -> ${formatScopeName(scope)}`,
+          () =>
+            `${formatSymbolName(symbol)} added to ${formatSymbolTableName(this)}`,
         );
 
-        this._namesToDeconflict.add(symbol.name);
+        this.#namesToDeconflict.add(symbol.name);
 
-        queueJob(this._deconflictNames);
+        queueJob(this.#deconflictNames);
 
         return symbol;
       },
-      onDelete(symbol) {
+      onDelete: (symbol) => {
         trace(
           TracePhase.symbol.removeFromScope,
-          () => `${formatSymbolName(symbol)} -> ${formatScopeName(scope)}`,
+          () =>
+            `${formatSymbolName(symbol)} removed from ${formatSymbolTableName(this)}`,
         );
       },
     });
 
-    this.scope = scope;
+    this.#nameConflictResolver =
+      options.nameConflictResolver ?? binder?.nameConflictResolver;
+    this.#binder = binder;
+    this.#key = key;
+    this.#symbolsByRefkey = this.createIndex((s) => s.refkeys);
+    this.#symbolNames = this.createIndex((s) => {
+      return s.name;
+    });
+  }
+
+  moveTo(target: SymbolTable): void {
+    trace(
+      TracePhase.scope.moveSymbols,
+      () =>
+        `${formatSymbolTableName(this)} -> ${formatSymbolTableName(target)}`,
+    );
+
+    target.addSubset(this, {
+      onAdd: (symbol) => {
+        symbol.spaces = [target as OutputSpace];
+        return symbol;
+      },
+    });
+  }
+
+  copyTo(
+    target: SymbolTable,
+    options: {
+      createRefkeys?(sourceSymbol: OutputSymbol): Refkey[];
+    } = {},
+  ): void {
+    trace(
+      TracePhase.scope.copySymbols,
+      () =>
+        `${formatSymbolTableName(this)} copied to ${formatSymbolTableName(target)}`,
+    );
 
-    this._nameConflictResolver = options.nameConflictResolver;
+    target.addSubset(this, {
+      onAdd: (symbol) => {
+        const copy = symbol.copy();
+        copy.spaces = [target as OutputSpace];
+        copy.refkeys = options.createRefkeys?.(symbol) ?? [];
+        return copy;
+      },
+    });
   }
 }
 

package/src/tracer.ts

@@ -1,10 +1,14 @@
 import { effect, ReactiveEffectRunner } from "@vue/reactivity";
 import { untrack } from "./reactivity.js";
-import type { Refkey } from "./refkey.js";
+import { isMemberRefkey, type Refkey } from "./refkey.js";
 import { scheduler } from "./scheduler.js";
-import { OutputScopeFlags, OutputSymbolFlags } from "./symbols/flags.js";
 import { type OutputScope } from "./symbols/output-scope.js";
+import type {
+  OutputDeclarationSpace,
+  OutputMemberSpace,
+} from "./symbols/output-space.js";
 import { type OutputSymbol } from "./symbols/output-symbol.js";
+import { SymbolTable } from "./symbols/symbol-table.js";
 
 // enable tracing for specific phases using a comma separated list of
 // dotted identifiers, e.g. `scope.update,symbol.create`.
@@ -47,6 +51,11 @@ export const TracePhase = {
       subarea: "copySymbols",
       bg: { r: 0, g: 100, b: 100 },
     },
+    moveSymbols: {
+      area: "scope",
+      subarea: "moveSymbols",
+      bg: { r: 0, g: 100, b: 100 },
+    },
   },
   symbol: {
     update: {
@@ -274,24 +283,6 @@ function colorText(text: string, fmt?: TextFormat): string {
   return `${prefix}${text}${reset}`;
 }
 
-/**
- * Format flag values in a concise way, showing only the flags that are set
- * @param flags The numeric flags value to format
- * @param flagEnum The enum containing flag definitions
- * @returns An array of flag names that are set
- */
-function formatFlags<T extends Record<string, string | number>>(
-  flags: number,
-  flagEnum: T,
-): string[] {
-  return Object.entries(flagEnum)
-    .filter(
-      ([name, value]) =>
-        typeof value === "number" && value !== 0 && (flags & value) === value,
-    )
-    .map(([name]) => name);
-}
-
 /**
  * Format a symbol name with its ID in a blue-green color
  * @param symbol The symbol to format
@@ -307,21 +298,6 @@ export function formatSymbolName(symbol: OutputSymbol): string {
   });
 }
 
-/**
- * Format the symbols in a member scope, showing their names and IDs
- * @param scope The member scope containing the symbols to format
- * @returns A formatted string representation of the member scope symbols
- */
-function formatMemberScopeSymbols(scope: OutputScope): string {
-  if (!scope || scope.symbols.size === 0) {
-    return "none";
-  }
-
-  return Array.from(scope.symbols)
-    .map((symbol) => formatSymbolName(symbol))
-    .join(", ");
-}
-
 export function formatSymbol(symbol: OutputSymbol): string {
   // Base display with name and ID
   let result = formatSymbolName(symbol);
@@ -333,35 +309,19 @@ export function formatSymbol(symbol: OutputSymbol): string {
     details.push(colorText("  !UNBOUND", { fg: { r: 255, g: 0, b: 0 } }));
   }
 
-  // Show only enabled flags
-  const flagsInfo = formatFlags(symbol.flags, OutputSymbolFlags);
-
-  if (flagsInfo.length > 0) {
-    details.push(`  flags: ${flagsInfo.join(", ")}`);
-  }
-
   // Show scope info with formatted name
   if (symbol.scope) {
     details.push(untrack(() => `  scope: ${formatScopeName(symbol.scope)}`));
   }
 
-  // Show member scopes if present
-  if (symbol.instanceMemberScope) {
-    untrack(() => {
-      const memberCount = symbol.instanceMemberScope!.symbols.size;
-      details.push(
-        `  instance members: ${memberCount} - ${formatMemberScopeSymbols(symbol.instanceMemberScope!)}`,
-      );
-    });
+  for (const space of symbol.memberSpaces) {
+    details.push(untrack(() => formatSpaceSymbols(space)));
   }
 
-  if (symbol.staticMemberScope) {
-    untrack(() => {
-      const memberCount = symbol.staticMemberScope!.symbols.size;
-      details.push(
-        `  static members: ${memberCount} - ${formatMemberScopeSymbols(symbol.staticMemberScope!)}`,
-      );
-    });
+  if (symbol.ownerSymbol) {
+    details.push(
+      untrack(() => `  ownerSymbol: ${formatSymbolName(symbol.ownerSymbol!)}`),
+    );
   }
 
   // Show all refkeys with proper formatting
@@ -376,20 +336,37 @@ export function formatSymbol(symbol: OutputSymbol): string {
   return result;
 }
 
-export function formatScopeName(scope: OutputScope): string {
-  let text = colorText(`${scope.name}[${scope.id}]`, {
+export function formatSpaceSymbols(space: SymbolTable) {
+  return `  ${space.key} symbols (${space.size}): ${[...space].map((s) => s.name).join(", ")}`;
+}
+
+export function formatScopeName(scope: OutputScope | undefined): string {
+  if (!scope) {
+    return "no scope";
+  }
+
+  return colorText(`${scope.name}[${scope.id}]`, {
     fg: {
       r: 0,
       g: 150,
       b: 50,
     },
   });
+}
 
-  if (scope.owner) {
-    text += untrack(() => ` of ${formatSymbolName(scope.owner!)}`);
-  }
-
-  return text;
+export function formatSymbolTableName(table: SymbolTable): string {
+  // avoid instance of checks here in order to not create circular module imports.
+  const name =
+    "symbol" in table ?
+      formatSymbolName((table as OutputMemberSpace).symbol)
+    : formatScopeName((table as OutputDeclarationSpace).scope);
+  return colorText(`${name}:${table.key}`, {
+    fg: {
+      r: 0,
+      g: 125,
+      b: 25,
+    },
+  });
 }
 
 /**
@@ -397,7 +374,7 @@ export function formatScopeName(scope: OutputScope): string {
  * @param scope The scope to format
  * @returns A formatted string representation of the scope
  */
-export function formatScope(scope: OutputSymbol["scope"]): string {
+export function formatScope(scope: OutputScope): string {
   if (!scope) {
     return "!Undefined scope!";
   }
@@ -416,34 +393,22 @@ export function formatScope(scope: OutputSymbol["scope"]): string {
   if (!scope.binder) {
     details.push(colorText("  !UNBOUND", { fg: { r: 255, g: 0, b: 0 } }));
   }
-  // Show only enabled flags
-  const flagsInfo = formatFlags(scope.flags, OutputScopeFlags);
-
-  if (flagsInfo.length > 0) {
-    details.push(`  flags: ${flagsInfo.join(", ")}`);
-  }
-
-  // Show symbol count
-  const symbolCount = scope.symbols.size;
-  if (symbolCount > 0) {
-    details.push(`  symbols: ${symbolCount}`);
-  }
 
   // Show parent scope if present
   if (scope.parent) {
     details.push(`  parent: ${formatScopeName(scope.parent)}`);
   }
 
-  // Show owner if present (for member scopes)
-  if (scope.owner) {
-    details.push(`  owner: ${formatSymbolName(scope.owner)}`);
-  }
-
   // Show child scopes if present
   if (scope.children && scope.children.size > 0) {
     details.push(`  children: ${scope.children.size}`);
   }
 
+  // Show declaration spaces
+  for (const space of scope.spaces) {
+    details.push(`  ${untrack(() => formatSpaceSymbols(space))}`);
+  }
+
   if (details.length > 0) {
     result += "\n" + details.join("\n");
   }
@@ -464,7 +429,12 @@ export function formatRefkeys(refkeys: Refkey[] | Refkey | undefined) {
 }
 
 function formatRefkey(refkey: Refkey): string {
-  return colorText(`refkey[${refkey.key}]`, {
+  const text =
+    isMemberRefkey(refkey) ?
+      `memberRefkey[${formatRefkey(refkey.base)} -> ${formatRefkey(refkey.member)}]`
+    : `refkey[${refkey.key}]`;
+
+  return colorText(text, {
     fg: {
       r: 150,
       g: 0,

package/src/utils.tsx

@@ -311,16 +311,16 @@ export interface OutputVisitor {
  * @param sourceDirectory - The root directory to traverse.
  * @param visitor - The visitor to call for each file and directory.
  */
-export function traverseOutput(
+export async function traverseOutput(
   sourceDirectory: OutputDirectory,
   visitor: OutputVisitor,
 ) {
-  visitor.visitDirectory(sourceDirectory);
+  await visitor.visitDirectory(sourceDirectory);
   for (const item of sourceDirectory.contents) {
     if (item.kind === "directory") {
-      traverseOutput(item, visitor);
+      await traverseOutput(item, visitor);
     } else {
-      visitor.visitFile(item);
+      await visitor.visitFile(item);
     }
   }
 }

package/src/write-output.ts

@@ -10,54 +10,42 @@ export async function writeOutput(
   output: OutputDirectory,
   basePath: string = "",
 ) {
-  const ops: Promise<void>[] = [];
-
-  traverseOutput(output, {
-    visitDirectory(directory) {
-      ops.push(
-        (async () => {
-          const path = resolve(basePath, directory.path);
-          if (await AlloyHost.exists(path)) {
-            return;
-          }
+  return await traverseOutput(output, {
+    async visitDirectory(directory) {
+      const path = resolve(basePath, directory.path);
+      if (await AlloyHost.exists(path)) {
+        return;
+      }
+      // eslint-disable-next-line no-console
+      console.log("create", relative(process.cwd(), path));
+      await AlloyHost.mkdir(path);
+    },
+    async visitFile(file) {
+      if ("contents" in file) {
+        const path = resolve(basePath, file.path);
+        if (await AlloyHost.exists(path)) {
+          // eslint-disable-next-line no-console
+          console.log("overwrite", relative(process.cwd(), path));
+        } else {
           // eslint-disable-next-line no-console
           console.log("create", relative(process.cwd(), path));
-          await AlloyHost.mkdir(path);
-        })(),
-      );
-    },
-    visitFile(file) {
-      ops.push(
-        (async () => {
-          if ("contents" in file) {
-            const path = resolve(basePath, file.path);
-            if (await AlloyHost.exists(path)) {
-              // eslint-disable-next-line no-console
-              console.log("overwrite", relative(process.cwd(), path));
-            } else {
-              // eslint-disable-next-line no-console
-              console.log("create", relative(process.cwd(), path));
-            }
+        }
 
-            await AlloyHost.write(path, file.contents);
-          } else {
-            // copy file
-            const source = resolve(basePath, file.sourcePath);
-            const target = resolve(basePath, file.path);
-            if (await AlloyHost.exists(target)) {
-              // eslint-disable-next-line no-console
-              console.log("copy over", relative(process.cwd(), target));
-            } else {
-              // eslint-disable-next-line no-console
-              console.log("copy", relative(process.cwd(), target));
-            }
-            await AlloyHost.mkdir(dirname(target));
-            await AlloyHost.write(target, AlloyHost.read(source).stream());
-          }
-        })(),
-      );
+        await AlloyHost.write(path, file.contents);
+      } else {
+        // copy file
+        const source = resolve(basePath, file.sourcePath);
+        const target = resolve(basePath, file.path);
+        if (await AlloyHost.exists(target)) {
+          // eslint-disable-next-line no-console
+          console.log("copy over", relative(process.cwd(), target));
+        } else {
+          // eslint-disable-next-line no-console
+          console.log("copy", relative(process.cwd(), target));
+        }
+        await AlloyHost.mkdir(dirname(target));
+        await AlloyHost.write(target, AlloyHost.read(source).stream());
+      }
     },
   });
-
-  return Promise.all(ops);
 }