@alloy-js/csharp 0.21.0-dev.9 → 0.22.0-dev.0

package/src/create-library.test.tsx

@@ -0,0 +1,213 @@
+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;
+  `);
+});
+
+it("can render multiple times", () => {
+  const System = createLibrary("System", {
+    String: {
+      kind: "class",
+      members: {},
+    },
+  });
+  expect(<TestNamespace>{System.String}</TestNamespace>).toRenderTo(`
+    using System;
+
+    String
+  `);
+
+  expect(<TestNamespace>{System.String}</TestNamespace>).toRenderTo(`
+    using System;
+
+    String
+  `);
+});

package/src/create-library.ts

@@ -0,0 +1,306 @@
+import {
+  Binder,
+  LibrarySymbolReference,
+  namekey,
+  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 {
+  ownerSymbol(binder: Binder | undefined): NamedTypeSymbol;
+}
+
+export function createLibrary<T extends Record<string, Descriptor>>(
+  rootNs: string,
+  props: T,
+): LibraryFrom<T> {
+  const ownerSymbolPerBinder = new WeakMap<Binder, NamespaceSymbol>();
+
+  const namespaceNames = rootNs.split(".");
+
+  return createSymbolEntry(
+    namespaceNames.at(-1)!,
+    {
+      kind: "namespace",
+      members: props,
+    },
+    {
+      ownerSymbol(binder: Binder | undefined) {
+        return mapGet(ownerSymbolPerBinder, binder, () => {
+          let 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(namekey(name), ownerSymbol!, {
+                binder,
+                refkeys: refkey(),
+              });
+            }
+          }
+
+          return ownerSymbol;
+        });
+      },
+    },
+  ) as LibraryFrom<T>;
+}
+
+function createSymbolEntry(
+  name: string,
+  descriptor: Descriptor,
+  context: InternalContext,
+): LibrarySymbolReference {
+  const symbols = new WeakMap<Binder, CSharpSymbol>();
+
+  function getSymbol(binder: Binder | undefined) {
+    // We cache symbols per binder to ensure we only create one symbol. We also
+    // track an unbound symbol for cases where there is no binder (mostly
+    // tests).
+    return mapGet(symbols, binder, () =>
+      createSymbolFromDescriptor(
+        name,
+        binder,
+        descriptor,
+        context,
+        initializeMembers,
+      ),
+    );
+  }
+
+  const newContext: InternalContext = {
+    ownerSymbol(binder) {
+      return getSymbol(binder) 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(useBinder()).refkeys[0];
+    },
+    [TO_SYMBOL]() {
+      return getSymbol(useBinder());
+    },
+  };
+
+  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,
+  binder: Binder | undefined,
+  descriptor: Descriptor,
+  context: InternalContext,
+  lazyMemberInitializer: () => void,
+): CSharpSymbol {
+  const ownerSymbol = context.ownerSymbol(binder);
+
+  switch (descriptor.kind) {
+    case "namespace":
+      if (ownerSymbol.members.symbolNames.has(name)) {
+        return ownerSymbol.members.symbolNames.get(name)! as NamespaceSymbol;
+      }
+      return new NamespaceSymbol(
+        namekey(name),
+        ownerSymbol as NamespaceSymbol,
+        {
+          binder,
+          refkeys: refkey(),
+          lazyMemberInitializer,
+        },
+      );
+    case "class":
+    case "enum":
+    case "interface":
+    case "struct":
+    case "record":
+      return new NamedTypeSymbol(
+        namekey(name),
+        ownerSymbol.members,
+        descriptor.kind,
+        {
+          binder,
+          refkeys: refkey(),
+          lazyMemberInitializer,
+        },
+      );
+    case "method":
+      return new MethodSymbol(
+        namekey(name),
+        ownerSymbol.members,
+        descriptor.methodKind,
+        {
+          binder,
+          refkeys: refkey(),
+        },
+      );
+    case "field":
+    case "property":
+      return new CSharpSymbol(namekey(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(namekey(name), ownerSymbol.members, {
+        binder,
+        refkeys: refkey(),
+      });
+    default:
+      throw "Unsupported";
+  }
+}
+
+const defaultsPerMap = new WeakMap<object, unknown>();
+
+function mapGet<T extends WeakKey, V>(
+  map: WeakMap<T, V>,
+  key: T | undefined,
+): V | undefined;
+function mapGet<T extends WeakKey, V>(
+  map: WeakMap<T, V>,
+  key: T | undefined,
+  init: () => V,
+): V;
+function mapGet<T extends WeakKey, V>(
+  map: WeakMap<T, V>,
+  key: T | undefined,
+  init?: () => V,
+): V | undefined {
+  if (key === undefined) {
+    // Use a per-map default store when callers request a value for an undefined key.
+    let value = defaultsPerMap.get(map as unknown as object) as V | undefined;
+    if (value === undefined && init) {
+      value = init();
+      defaultsPerMap.set(map as unknown as object, value);
+    }
+    return value;
+  }
+
+  let value = map.get(key);
+  if (value === undefined && init) {
+    value = init();
+    map.set(key, value);
+  }
+  return value;
+}

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/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/reference.tsx

@@ -1,5 +1,13 @@
 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 { useReferenceContext } from "../contexts/reference-context.js";
 import { CSharpScope } from "../scopes/csharp.js";
 import { CSharpNamespaceScope } from "../scopes/namespace.js";
 import { useSourceFileScope } from "../scopes/source-file.js";
@@ -17,7 +25,7 @@ export function ref(
   const resolveResult = resolve<CSharpScope, CSharpSymbol>(refkey as Refkey);
   return memo(() => {
     if (resolveResult.value === undefined) {
-      return [`unresolvedRefkey(refkey)`, undefined];
+      return [unresolvedRefkey(refkey), undefined];
     }
 
     const result = resolveResult.value;
@@ -26,7 +34,7 @@ export function ref(
 
     if (!commonScope) {
       // this shouldn't be possible in csharp.
-      return [`unresolvedRefkey(refkey)`, undefined];
+      return [unresolvedRefkey(refkey), undefined];
     }
 
     if (
@@ -49,12 +57,19 @@ export function ref(
     }
 
     const parts = [];
+    const referenceContext = useReferenceContext();
 
     for (const nsScope of pathDown) {
       parts.push(<AccessExpression.Part symbol={nsScope.ownerSymbol!} />);
     }
 
-    parts.push(<AccessExpression.Part symbol={lexicalDeclaration} />);
+    parts.push(
+      <AccessExpression.Part
+        symbol={lexicalDeclaration}
+        attribute={referenceContext === "attribute"}
+      />,
+    );
+
     for (const member of memberPath) {
       parts.push(<AccessExpression.Part symbol={member} />);
     }