@alloy-js/csharp 0.20.0-dev.2 → 0.20.0-dev.4

package/src/symbols/namespace.ts

@@ -0,0 +1,62 @@
+import { OutputSymbolOptions } from "@alloy-js/core";
+import { NamedTypeSymbol } from "./named-type.js";
+
+export interface NamespaceSymbolOptions extends OutputSymbolOptions {
+  isGlobal?: boolean;
+}
+
+/**
+ * A symbol for a namespace in C#.
+ */
+export class NamespaceSymbol extends NamedTypeSymbol {
+  public readonly symbolKind = "namespace";
+  constructor(
+    name: string,
+    parentNamespace?: NamespaceSymbol,
+    options?: NamespaceSymbolOptions,
+  ) {
+    const space = parentNamespace?.members;
+
+    super(name, space, "namespace", options);
+
+    this.#isGlobal = !!options?.isGlobal;
+  }
+
+  #isGlobal: boolean;
+  /**
+   * Whether this symbol is the global namespace symbol.
+   */
+  get isGlobal() {
+    return this.#isGlobal;
+  }
+
+  getFullyQualifiedName(options: { omitGlobal?: boolean } = {}): string {
+    const parts = [];
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    let current: NamespaceSymbol | undefined = this;
+
+    while (current && !current.isGlobal) {
+      parts.unshift(current.name);
+      current = current.ownerSymbol as NamespaceSymbol | undefined;
+    }
+
+    const idPart = parts.join(".");
+
+    if (options.omitGlobal) {
+      return idPart;
+    } else {
+      return `global::${idPart}`;
+    }
+  }
+
+  copy() {
+    const options = this.getCopyOptions();
+    const copy = new NamespaceSymbol(this.name, undefined, {
+      ...options,
+      isGlobal: this.#isGlobal,
+    });
+    this.initializeCopy(copy);
+    return copy;
+  }
+}

package/src/symbols/reference.ts

@@ -1,65 +1,62 @@
-import * as core from "@alloy-js/core";
-import { useNamespace } from "../components/Namespace.jsx";
-import { useSourceFile } from "../components/SourceFile.jsx";
-import { CSharpOutputSymbol } from "./csharp-output-symbol.js";
-import { CSharpOutputScope } from "./scopes.js";
-
-// when resolving references across source files, the last element
-// in pathDown will be the containing source file. we only need this
-// here so we can find and remove this scope as it's not useful
-// when building the reference
-interface SourceFileScope extends core.OutputScope {
-  kind: "source-file";
-}
-
-type ReferenceScope = CSharpOutputScope | SourceFileScope;
+import { memo, OutputSymbol, Refkey, resolve } from "@alloy-js/core";
+import { CSharpScope } from "../scopes/csharp.js";
+import { CSharpNamespaceScope } from "../scopes/namespace.js";
+import { useSourceFileScope } from "../scopes/source-file.js";
+import { CSharpSymbol } from "./csharp.js";
+import { NamespaceSymbol } from "./namespace.js";
 
 // converts a refkey to its fully qualified name
 // e.g. if refkey is for bar in enum type foo, and
 // foo is in the same namespace as the refkey, then
 // the result would be foo.bar.
-export function ref(refkey: core.Refkey): () => string {
-  const targetNamespaceCtx = useNamespace();
-  const resolveResult = core.resolve<ReferenceScope, CSharpOutputSymbol>(
-    refkey as core.Refkey,
-  );
+export function ref(refkey: Refkey): () => [string, OutputSymbol | undefined] {
+  const refSfScope = useSourceFileScope()!;
+  const resolveResult = resolve<CSharpScope, CSharpSymbol>(refkey as Refkey);
 
-  return core.memo(() => {
+  return memo(() => {
     if (resolveResult.value === undefined) {
-      return "<Unresolved Symbol>";
+      return ["<Unresolved Symbol>", undefined];
     }
 
-    // targetDeclaration is the symbol with the refkey
-    // pathDown is an array of scopes to that symbol and can be empty.
-    // the entries are top-down, so namespace, source-file, member
-    //  - referencing a type within the same namespace will have an empty path
-    //  - referencing a member (e.g. enum value) within the same namespace will
-    //    have a single path entry that contains the owning type
-    //  - referencing a type within the same namespace but in a different source
-    //    file will have at least a source-file entry
-    //  - referencing a symbol outside the current namespace will have at least
-    //    two entries, namespace, source-file
-    const { targetDeclaration, pathDown } = resolveResult.value;
+    const result = resolveResult.value;
+    const { commonScope, pathDown, memberPath } = result;
+    let { lexicalDeclaration } = result;
+
+    const parts = [];
+    if (!commonScope) {
+      // this shouldn't be possible in csharp.
+      return ["<Unresolved Symbol>", undefined];
+    }
 
-    const sourceNamespace = pathDown.find((v) => {
-      return v.kind === "namespace";
-    });
-    if (sourceNamespace && sourceNamespace.name !== targetNamespaceCtx!.name) {
-      // the source symbol is in a different namespace that the target refkey.
-      // add the applicable using statement to the target's source file.
-      const targetSrc = useSourceFile();
-      targetSrc!.addUsing(sourceNamespace.name);
+    if (
+      commonScope instanceof CSharpNamespaceScope &&
+      commonScope.ownerSymbol.isGlobal &&
+      lexicalDeclaration.symbolKind === "namespace" &&
+      memberPath.length > 0
+    ) {
+      // we need to using the namespace
+      let nsToUse: NamespaceSymbol;
+      while (
+        lexicalDeclaration.symbolKind === "namespace" &&
+        memberPath.length > 0
+      ) {
+        nsToUse = lexicalDeclaration as NamespaceSymbol;
+        lexicalDeclaration = memberPath.shift()!;
+      }
+
+      refSfScope.addUsing(nsToUse!);
     }
 
-    // we only need to build the fully-qualified name for members
-    // TODO: possibly a subset of members
-    const syms = (pathDown as ReferenceScope[])
-      .filter((v) => {
-        return v.kind === "member";
-      })
-      .map((s) => s.owner!);
-    syms.push(targetDeclaration);
+    for (const nsScope of pathDown) {
+      parts.push(nsScope.ownerSymbol!.name);
+    }
+
+    parts.push(lexicalDeclaration.name);
+
+    for (const member of memberPath) {
+      parts.push(member.name);
+    }
 
-    return syms.map((sym) => sym.name).join(".");
+    return [parts.join("."), result.symbol];
   });
 }