@alloy-js/csharp 0.20.0-dev.3 → 0.20.0-dev.5

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];
   });
 }