@alloy-js/csharp 0.1.0

package/src/symbols/csharp-output-symbol.ts

@@ -0,0 +1,26 @@
+import * as core from "@alloy-js/core";
+import { useNamespace } from "../components/Namespace.jsx";
+import { CSharpOutputScope } from "./scopes.js";
+
+// represents a symbol from a .cs file. Class, enum, interface etc.
+export interface CSharpOutputSymbol extends core.OutputSymbol {
+  scope: CSharpOutputScope;
+}
+
+// creates a new C# symbol
+export function createCSharpSymbol(props: core.DeclarationProps) {
+  const scope = core.useScope() as CSharpOutputScope;
+
+  const namespaceCtx = useNamespace();
+  if (!namespaceCtx) {
+    throw new Error("symbol must be declared inside a namespace");
+  }
+
+  const sym = scope.binder.createSymbol<CSharpOutputSymbol>({
+    name: props.name!,
+    scope,
+    refkey: props.refkey ?? core.refkey(props.name),
+  });
+
+  return sym;
+}

package/src/symbols/index.ts

@@ -0,0 +1,3 @@
+export * from "./csharp-output-symbol.js";
+export * from "./reference.js";
+export * from "./scopes.js";

package/src/symbols/reference.ts

@@ -0,0 +1,65 @@
+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;
+
+// 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,
+  );
+
+  return core.memo(() => {
+    if (resolveResult.value === undefined) {
+      return "<Unresolved Symbol>";
+    }
+
+    // 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 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);
+    }
+
+    // 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);
+
+    return syms.map((sym) => sym.name).join(".");
+  });
+}

package/src/symbols/scopes.ts

@@ -0,0 +1,60 @@
+import * as core from "@alloy-js/core";
+import { CSharpOutputSymbol } from "./csharp-output-symbol.js";
+
+// indicates that the scope for a symbols is at the namespace level
+export interface CSharpNamespaceScope extends core.OutputScope {
+  kind: "namespace";
+}
+
+// creates a new namespace scope
+export function createCSharpNamespaceScope(
+  binder: core.Binder,
+  parent: core.OutputScope | undefined,
+  name: string,
+): CSharpNamespaceScope {
+  return binder.createScope<CSharpNamespaceScope>({
+    kind: "namespace",
+    name,
+    parent,
+  });
+}
+
+// the kind of member scope. i.e. are we in an enum, class, etc
+export type CSharpMemberScopeName =
+  | "class-decl"
+  | "constructor-decl"
+  | "enum-decl"
+  | "method-decl";
+
+// indicates that the scope for a symbol resides within a type
+// e.g. for an enum value, class field etc, these would have
+// member scope where the owner is the containing type.
+export interface CSharpMemberScope extends core.OutputScope {
+  kind: "member";
+  name: CSharpMemberScopeName;
+  owner: CSharpOutputSymbol;
+}
+
+// creates a new member scope.
+// parent is the owning symbol.
+export function createCSharpMemberScope(
+  binder: core.Binder,
+  parent: core.OutputScope,
+  owner: CSharpOutputSymbol,
+  name: CSharpMemberScopeName,
+): CSharpMemberScope {
+  return binder.createScope<CSharpMemberScope>({
+    kind: "member",
+    name: name,
+    owner,
+    parent,
+  });
+}
+
+// contains the possible scopes where a declaration can reside
+export type CSharpOutputScope = CSharpMemberScope | CSharpNamespaceScope;
+
+// returns the current C# scope
+export function useCSharpScope(): CSharpOutputScope {
+  return core.useScope() as CSharpOutputScope;
+}