@alloy-js/csharp 0.21.0-dev.0 → 0.21.0-dev.12

package/src/create-library.test.tsx

@@ -0,0 +1,202 @@
+import { VarDeclaration } from "#components/index.js";
+import { InvocationExpression } from "#components/invocation-expression/invocation-expression.jsx";
+import { TestNamespace } from "#test/utils.jsx";
+import { List, memberRefkey, namekey, toRefkey } from "@alloy-js/core";
+import { beforeEach, expect, it } from "vitest";
+import { IO } from "./builtins/System/index.js";
+import {
+  getGlobalNamespace,
+  resetGlobalNamespace,
+} from "./contexts/global-namespace.js";
+import { createLibrary } from "./create-library.js";
+import { NamespaceSymbol } from "./symbols/namespace.js";
+
+beforeEach(() => {
+  resetGlobalNamespace();
+});
+
+it("Creates symbols on demand", () => {
+  const System = createLibrary("System", {
+    String: {
+      kind: "class",
+      members: {
+        Special: { kind: "class", members: { BeSpecial: { kind: "field" } } },
+        Substring: { kind: "method" },
+        Length: { kind: "field" },
+        Empty: { kind: "field", isStatic: true },
+      },
+    },
+  });
+
+  const globalNamespace = getGlobalNamespace(undefined);
+  const systemNs = globalNamespace.members.symbolNames.get("System")!;
+  expect(systemNs).toBeUndefined();
+  const _ = toRefkey(System);
+  const systemNs2 = globalNamespace.members.symbolNames.get("System")!;
+  expect(systemNs2).toBeDefined();
+});
+
+it("Can reference types which haven't been created yet", () => {
+  const System = createLibrary("System", {
+    String: {
+      kind: "class",
+      members: {
+        Special: { kind: "property", type: () => SomeNs.SomeType },
+      },
+    },
+  });
+
+  const SomeNs = createLibrary("SomeNs", {
+    SomeType: {
+      kind: "class",
+      members: {},
+    },
+  });
+
+  const globalNamespace = getGlobalNamespace(undefined);
+  const _ = toRefkey(System.String.Special);
+  const systemNs2 = globalNamespace.members.symbolNames.get("System")!;
+  expect(systemNs2).toBeDefined();
+  const someNs = globalNamespace.members.symbolNames.get("SomeNs")!;
+  expect(someNs).toBeDefined();
+});
+
+it("Works with nested namespaces", () => {
+  const IO = createLibrary("System.IO", {
+    BinaryReader: {
+      kind: "class",
+      members: {},
+    },
+  });
+
+  const globalNamespace = getGlobalNamespace(undefined);
+  const systemNs = globalNamespace.members.symbolNames.get("System")!;
+  expect(systemNs).toBeUndefined();
+  const _ = toRefkey(IO.BinaryReader);
+  const systemNs2 = globalNamespace.members.symbolNames.get("System")!;
+  expect(systemNs2).toBeDefined();
+});
+
+it("Doesn't create duplicate namespaces", () => {
+  const IO = createLibrary("System.IO", {
+    BinaryReader: { kind: "class", members: {} },
+    BinaryWriter: { kind: "class", members: {} },
+  });
+
+  const Collections = createLibrary("System.Collections", {
+    ArrayList: { kind: "class", members: {} },
+  });
+
+  const _refkeys = [
+    toRefkey(IO.BinaryReader),
+    toRefkey(IO.BinaryWriter),
+    toRefkey(Collections.ArrayList),
+  ];
+
+  const globalNamespace = getGlobalNamespace(undefined);
+  const systemNs = globalNamespace.members.symbolNames.get(
+    "System",
+  )! as NamespaceSymbol;
+  expect(systemNs).toBeDefined();
+  const ioNs = systemNs.members.symbolNames.get("IO")!;
+  expect(ioNs).toBeDefined();
+  const collectionsNs = systemNs.members.symbolNames.get("Collections")!;
+  expect(collectionsNs).toBeDefined();
+});
+
+it("renders as a refkey", () => {
+  const IO = createLibrary("System.IO", {
+    BinaryReader: {
+      kind: "class",
+      members: {},
+    },
+  });
+
+  expect(
+    <TestNamespace>
+      new <InvocationExpression target={IO.BinaryReader} />;
+    </TestNamespace>,
+  ).toRenderTo(`
+    using System.IO;
+
+    new BinaryReader();
+  `);
+});
+
+it("has a refkey getter", () => {
+  const IO = createLibrary("System.IO", {
+    BinaryReader: {
+      kind: "class",
+      members: {},
+    },
+  });
+
+  const ioKey = toRefkey(IO);
+  expect(ioKey).toBeDefined();
+  const brKey = toRefkey(IO.BinaryReader);
+  expect(brKey).toBeDefined();
+});
+
+it("works to reference members", () => {
+  const IO = createLibrary("System.IO", {
+    BinaryReader: {
+      kind: "class",
+      members: {
+        ReadString: { kind: "method" },
+      },
+    },
+  });
+
+  const reader = namekey("reader");
+
+  expect(
+    <TestNamespace>
+      <VarDeclaration name={reader} type={IO.BinaryReader}>
+        new <InvocationExpression target={IO.BinaryReader} />
+      </VarDeclaration>
+      <hbr />
+      <InvocationExpression
+        target={memberRefkey(reader, IO.BinaryReader.ReadString)}
+      />
+      ;
+    </TestNamespace>,
+  ).toRenderTo(`
+    using System.IO;
+
+    BinaryReader reader = new BinaryReader();
+    reader.ReadString();
+  `);
+});
+
+it("has built-ins available", () => {
+  const info = namekey("info");
+
+  const template = (
+    <TestNamespace>
+      <List>
+        <VarDeclaration name={info}>
+          new {IO.FileInfo}("test.txt")
+        </VarDeclaration>
+        <VarDeclaration name="directoryName">
+          {memberRefkey(info, "DirectoryName", "Length")}
+        </VarDeclaration>
+      </List>
+    </TestNamespace>
+  );
+
+  expect(template).toRenderTo(`
+    using System.IO;
+
+    var info = new FileInfo("test.txt");
+    var directoryName = info.DirectoryName?.Length;
+  `);
+});
+
+/**
+        <VarDeclaration name={info}>
+          new {IO.FileInfo}("test.txt")
+        </VarDeclaration>
+        <VarDeclaration name="directoryName">
+          {access(info, "DirectoryName", "Length")}
+        </VarDeclaration>
+ */

package/src/create-library.ts

@@ -0,0 +1,270 @@
+import {
+  Binder,
+  LibrarySymbolReference,
+  refkey,
+  REFKEYABLE,
+  TO_SYMBOL,
+  useBinder,
+} from "@alloy-js/core";
+import { getGlobalNamespace } from "./contexts/global-namespace.js";
+import { MethodKinds, MethodSymbol } from "./index.js";
+import { CSharpSymbol } from "./symbols/csharp.js";
+import { NamedTypeSymbol } from "./symbols/named-type.js";
+import { NamespaceSymbol } from "./symbols/namespace.js";
+
+export interface MemberDescriptor {
+  kind: string;
+  type?: LibrarySymbolReference | (() => LibrarySymbolReference);
+  isOverride?: boolean;
+  isAbstract?: boolean;
+  isVirtual?: boolean;
+  isStatic?: boolean;
+  isSealed?: boolean;
+  isExtern?: boolean;
+  isReadOnly?: boolean;
+  isNullable?: boolean;
+}
+
+export interface NamespaceDescriptor<M> {
+  kind: "namespace";
+  members: M;
+}
+
+export interface FieldDescriptor extends MemberDescriptor {
+  kind: "field";
+}
+
+export interface MethodDescriptor extends MemberDescriptor {
+  kind: "method";
+  methodKind: MethodKinds;
+}
+
+export interface NamedTypeDescriptor<M> {
+  kind: string;
+  members: M;
+  isAbstract?: boolean;
+  isStatic?: boolean;
+  isSealed?: boolean;
+}
+export interface ClassDescriptor<M> extends NamedTypeDescriptor<M> {
+  kind: "class";
+}
+
+export interface PropertyDescriptor extends MemberDescriptor {
+  kind: "property";
+}
+
+export interface InterfaceDescriptor<M> extends NamedTypeDescriptor<M> {
+  kind: "interface";
+}
+
+export interface EnumDescriptor<M> extends NamedTypeDescriptor<M> {
+  kind: "enum";
+}
+
+export interface StructDescriptor<M> extends NamedTypeDescriptor<M> {
+  kind: "struct";
+}
+
+export interface RecordDescriptor<M> extends NamedTypeDescriptor<M> {
+  kind: "record";
+}
+
+export interface GenericDescriptor {
+  kind: "generic";
+}
+
+export type Descriptor =
+  | FieldDescriptor
+  | MethodDescriptor
+  | PropertyDescriptor
+  | NamespaceDescriptor<any>
+  | ClassDescriptor<any>
+  | InterfaceDescriptor<any>
+  | EnumDescriptor<any>
+  | StructDescriptor<any>
+  | RecordDescriptor<any>
+  | GenericDescriptor;
+
+export type ResolveDescriptor<D> =
+  D extends NamedTypeDescriptor<infer M> ?
+    LibrarySymbolReference & { [K in keyof M]: ResolveDescriptor<M[K]> }
+  : LibrarySymbolReference;
+
+export type LibraryFrom<T> = {
+  [K in keyof T]: ResolveDescriptor<T[K]>;
+} & LibrarySymbolReference;
+
+interface InternalContext {
+  binder(): Binder;
+  ownerSymbol(): NamedTypeSymbol;
+}
+
+export function createLibrary<T extends Record<string, Descriptor>>(
+  rootNs: string,
+  props: T,
+): LibraryFrom<T> {
+  let binder: Binder | undefined = undefined;
+  let ownerSymbol: NamespaceSymbol | undefined = undefined;
+  const namespaceNames = rootNs.split(".");
+
+  return createSymbolEntry(
+    namespaceNames.at(-1)!,
+    {
+      kind: "namespace",
+      members: props,
+    },
+    {
+      binder() {
+        if (!binder) {
+          binder = useBinder();
+        }
+        return binder!;
+      },
+      ownerSymbol() {
+        if (ownerSymbol) {
+          return ownerSymbol;
+        }
+
+        const binder = this.binder();
+        ownerSymbol = getGlobalNamespace(binder);
+        for (const name of namespaceNames.slice(0, -1)) {
+          if (ownerSymbol!.members.symbolNames.has(name)) {
+            ownerSymbol = ownerSymbol!.members.symbolNames.get(
+              name,
+            )! as NamespaceSymbol;
+          } else {
+            ownerSymbol = new NamespaceSymbol(name, ownerSymbol!, {
+              binder,
+              refkeys: refkey(),
+            });
+          }
+        }
+
+        return ownerSymbol;
+      },
+    },
+  ) as LibraryFrom<T>;
+}
+
+function createSymbolEntry(
+  name: string,
+  descriptor: Descriptor,
+  context: InternalContext,
+): LibrarySymbolReference {
+  let symbol: CSharpSymbol | undefined = undefined;
+
+  function getSymbol() {
+    if (symbol) return symbol;
+
+    symbol = createSymbolFromDescriptor(
+      name,
+      descriptor,
+      context,
+      initializeMembers,
+    );
+    return symbol;
+  }
+
+  const newContext: InternalContext = {
+    binder: context.binder,
+    ownerSymbol() {
+      return getSymbol() as NamedTypeSymbol;
+    },
+  };
+
+  function initializeMembers() {
+    for (const key of Object.keys(obj)) {
+      if (typeof key === "symbol") continue;
+      (obj as any)[key][TO_SYMBOL]();
+    }
+  }
+
+  const obj: LibrarySymbolReference & Record<string, unknown> = {
+    [REFKEYABLE]() {
+      return getSymbol().refkeys[0];
+    },
+    [TO_SYMBOL]() {
+      return getSymbol();
+    },
+  };
+
+  switch (descriptor.kind) {
+    case "class":
+    case "namespace":
+    case "interface":
+    case "enum":
+    case "struct":
+    case "record":
+      for (const [memberName, memberDesc] of Object.entries(
+        descriptor.members,
+      ) as any) {
+        obj[memberName] = createSymbolEntry(memberName, memberDesc, newContext);
+      }
+      break;
+  }
+
+  return obj;
+}
+
+function createSymbolFromDescriptor(
+  name: string,
+  descriptor: Descriptor,
+  context: InternalContext,
+  lazyMemberInitializer: () => void,
+): CSharpSymbol {
+  const ownerSymbol = context.ownerSymbol();
+  const binder = context.binder();
+
+  switch (descriptor.kind) {
+    case "namespace":
+      if (ownerSymbol.members.symbolNames.has(name)) {
+        return ownerSymbol.members.symbolNames.get(name)! as NamespaceSymbol;
+      }
+      return new NamespaceSymbol(name, ownerSymbol as NamespaceSymbol, {
+        binder,
+        refkeys: refkey(),
+        lazyMemberInitializer,
+      });
+    case "class":
+    case "enum":
+    case "interface":
+    case "struct":
+    case "record":
+      return new NamedTypeSymbol(name, ownerSymbol.members, descriptor.kind, {
+        binder,
+        refkeys: refkey(),
+        lazyMemberInitializer,
+      });
+    case "method":
+      return new MethodSymbol(
+        name,
+        ownerSymbol.members,
+        descriptor.methodKind,
+        {
+          binder,
+          refkeys: refkey(),
+        },
+      );
+    case "field":
+    case "property":
+      return new CSharpSymbol(name, ownerSymbol.members, {
+        binder,
+        refkeys: refkey(),
+        type:
+          descriptor.type === undefined ? undefined
+          : typeof descriptor.type === "function" ?
+            descriptor.type()[TO_SYMBOL]()
+          : descriptor.type[TO_SYMBOL](),
+        isNullable: descriptor.isNullable,
+        lazyMemberInitializer,
+      });
+    case "generic":
+      return new CSharpSymbol(name, ownerSymbol.members, {
+        binder,
+        refkeys: refkey(),
+      });
+    default:
+      throw "Unsupported";
+  }
+}

package/src/index.ts

@@ -1,5 +1,7 @@
+export * from "./access.jsx";
 export * from "./components/index.js";
 export * from "./contexts/format-options.js";
+export * from "./create-library.js";
 export * from "./modifiers.js";
 export * from "./name-policy.js";
 export * from "./scopes/index.js";

package/src/name-policy.ts

@@ -17,7 +17,8 @@ export type CSharpElements =
   | "class-method"
   | "class-property"
   | "parameter"
-  | "type-parameter";
+  | "type-parameter"
+  | "namespace";
 
 // creates the C# naming policy
 export function createCSharpNamePolicy(): core.NamePolicy<CSharpElements> {
@@ -33,6 +34,7 @@ export function createCSharpNamePolicy(): core.NamePolicy<CSharpElements> {
       case "class-method":
       case "type-parameter":
       case "class-property":
+      case "namespace":
         return changecase.pascalCase(name);
       case "constant":
         return changecase.constantCase(name);

package/src/symbols/factories.ts

@@ -6,6 +6,7 @@ import {
   useBinder,
 } from "@alloy-js/core";
 import { getGlobalNamespace } from "../contexts/global-namespace.js";
+import { useNamespaceContext } from "../contexts/namespace.js";
 import { CSharpElements, useCSharpNamePolicy } from "../name-policy.js";
 import { CSharpClassScope } from "../scopes/class.js";
 import { useCSharpScope, useNamedTypeScope } from "../scopes/contexts.js";
@@ -13,10 +14,7 @@ import { CSharpScope } from "../scopes/csharp.js";
 import { CSharpLexicalScope } from "../scopes/lexical.js";
 import { CSharpMethodScope } from "../scopes/method.js";
 import { CSharpNamedTypeScope } from "../scopes/named-type.js";
-import {
-  CSharpNamespaceScope,
-  useEnclosingNamespaceScope,
-} from "../scopes/namespace.js";
+import { CSharpNamespaceScope } from "../scopes/namespace.js";
 import { CSharpSourceFileScope } from "../scopes/source-file.js";
 import { CSharpSymbol, CSharpSymbolOptions } from "./csharp.js";
 import { MethodKinds, MethodSymbol } from "./method.js";
@@ -118,13 +116,52 @@ export function createNamedTypeSymbol(
   );
 }
 
-export function createNamespaceSymbol(name: string) {
-  const scope = useEnclosingNamespaceScope();
-  const nsSymbol = scope?.ownerSymbol ?? getGlobalNamespace(useBinder());
-  if (nsSymbol.members.symbolNames.has(name)) {
-    return nsSymbol.members.symbolNames.get(name)! as NamespaceSymbol;
+export function createNamespaceSymbol(
+  name: string | Namekey | (string | Namekey)[],
+  options: CSharpSymbolOptions = {},
+): NamespaceSymbol {
+  const scope = useNamespaceContext();
+  const parentSymbol = scope?.symbol ?? getGlobalNamespace(useBinder());
+  const names = normalizeNamespaceName(name);
+  let current = parentSymbol;
+  for (const name of names) {
+    current = createNamespaceSymbolInternal(name, current, options);
+  }
+  return current;
+}
+
+function normalizeNamespaceName(
+  name: string | Namekey | (string | Namekey)[],
+): (string | Namekey)[] {
+  if (Array.isArray(name)) {
+    return name;
+  }
+  if (typeof name === "string" && name.includes(".")) {
+    return name.split(".");
   }
-  return withCleanup(new NamespaceSymbol(name, nsSymbol));
+  return [name];
+}
+
+function createNamespaceSymbolInternal(
+  name: string | Namekey,
+  parentSymbol: NamespaceSymbol,
+  options: CSharpSymbolOptions = {},
+): NamespaceSymbol {
+  const namePolicy =
+    options.namePolicy ?? useCSharpNamePolicy().for("namespace");
+  const expectedName = namePolicy(typeof name === "string" ? name : name.name);
+  if (parentSymbol.members.symbolNames.has(expectedName)) {
+    return parentSymbol.members.symbolNames.get(
+      expectedName,
+    )! as NamespaceSymbol;
+  }
+  return withCleanup(
+    new NamespaceSymbol(
+      name,
+      parentSymbol,
+      withNamePolicy(options, "namespace"),
+    ),
+  );
 }
 
 export interface CreateMethodSymbolOptions extends CSharpSymbolOptions {

package/src/symbols/named-type.ts

@@ -1,5 +1,5 @@
-import { Namekey, OutputSpace, OutputSymbolOptions } from "@alloy-js/core";
-import { CSharpSymbol } from "./csharp.js";
+import { Namekey, OutputSpace } from "@alloy-js/core";
+import { CSharpSymbol, CSharpSymbolOptions } from "./csharp.js";
 
 // represents a symbol from a .cs file. Class, enum, interface etc.
 
@@ -25,7 +25,7 @@ export class NamedTypeSymbol extends CSharpSymbol {
     name: string | Namekey,
     spaces: OutputSpace[] | OutputSpace | undefined,
     kind: NamedTypeTypeKind,
-    options?: OutputSymbolOptions,
+    options?: CSharpSymbolOptions,
   ) {
     super(name, spaces, options);
     this.#typeKind = kind;

package/src/symbols/namespace.ts

@@ -1,4 +1,4 @@
-import { OutputSymbolOptions } from "@alloy-js/core";
+import { Namekey, OutputSymbolOptions } from "@alloy-js/core";
 import { NamedTypeSymbol } from "./named-type.js";
 
 export interface NamespaceSymbolOptions extends OutputSymbolOptions {
@@ -11,7 +11,7 @@ export interface NamespaceSymbolOptions extends OutputSymbolOptions {
 export class NamespaceSymbol extends NamedTypeSymbol {
   public readonly symbolKind = "namespace";
   constructor(
-    name: string,
+    name: string | Namekey,
     parentNamespace?: NamespaceSymbol,
     options?: NamespaceSymbolOptions,
   ) {

package/src/symbols/reference.tsx

@@ -1,5 +1,12 @@
 import { AccessExpression } from "#components/access-expression/access-expression.jsx";
-import { Children, memo, OutputSymbol, Refkey, resolve } from "@alloy-js/core";
+import {
+  Children,
+  memo,
+  OutputSymbol,
+  Refkey,
+  resolve,
+  unresolvedRefkey,
+} from "@alloy-js/core";
 import { CSharpScope } from "../scopes/csharp.js";
 import { CSharpNamespaceScope } from "../scopes/namespace.js";
 import { useSourceFileScope } from "../scopes/source-file.js";
@@ -17,7 +24,7 @@ export function ref(
   const resolveResult = resolve<CSharpScope, CSharpSymbol>(refkey as Refkey);
   return memo(() => {
     if (resolveResult.value === undefined) {
-      return ["<Unresolved Symbol>", undefined];
+      return [unresolvedRefkey(refkey), undefined];
     }
 
     const result = resolveResult.value;
@@ -26,7 +33,7 @@ export function ref(
 
     if (!commonScope) {
       // this shouldn't be possible in csharp.
-      return ["<Unresolved Symbol>", undefined];
+      return [unresolvedRefkey(refkey), undefined];
     }
 
     if (