@alloy-js/csharp 0.21.0-dev.16 → 0.21.0-dev.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alloy-js/csharp",
-  "version": "0.21.0-dev.16",
+  "version": "0.21.0-dev.18",
   "description": "Alloy components for CSharp language.",
   "exports": {
     ".": {

package/src/components/attributes/attributes.test.tsx

@@ -1,3 +1,4 @@
+import { namekey } from "@alloy-js/core";
 import { expect, it } from "vitest";
 import { Attribute, AttributeList } from "./attributes.jsx";
 
@@ -7,6 +8,15 @@ it("define attribute", () => {
   `);
 });
 
+it("define attribute whose name ending with 'Attribute'", () => {
+  expect(<Attribute name="TestAttribute" />).toRenderTo(`
+      [Test]
+  `);
+  expect(<Attribute name={namekey("TestAttribute")} />).toRenderTo(`
+      [Test]
+  `);
+});
+
 it("define attribute with single arg", () => {
   expect(<Attribute name="Test" args={[`"abc"`]} />).toRenderTo(`
       [Test("abc")]

package/src/components/attributes/attributes.tsx

@@ -3,6 +3,7 @@ import {
   findKeyedChildren,
   For,
   Indent,
+  Refkey,
   taggedComponent,
 } from "@alloy-js/core";
 
@@ -54,7 +55,7 @@ function renderAttribute(attr: string | AttributeProps | Children): Children {
 
 export interface AttributeProps {
   /** Attribute name */
-  name: Children;
+  name: string | Refkey;
 
   /** Argument */
   args?: Children[];
@@ -81,7 +82,7 @@ export const Attribute = taggedComponent(
   (props: AttributeProps) => {
     return (
       <group>
-        [{props.name}
+        [{normalizeAttributeName(props.name)}
         {props.args && props.args.length > 0 && (
           <>
             (
@@ -98,3 +99,15 @@ export const Attribute = taggedComponent(
     );
   },
 );
+
+function normalizeAttributeName(name: string | Refkey) {
+  const nameStr =
+    typeof name === "string" ? name
+    : typeof name === "object" && "name" in name ? name.name
+    : undefined;
+
+  if (nameStr !== undefined && nameStr.endsWith("Attribute")) {
+    return nameStr.substring(0, nameStr.length - "Attribute".length);
+  }
+  return name;
+}

package/src/components/parameters/parameters.test.tsx

@@ -148,3 +148,40 @@ it("can attach attributes", () => {
     }
   `);
 });
+
+it("can add modifiers: in | out | ref", () => {
+  expect(
+    <Wrapper>
+      <Method
+        name="MethodOne"
+        parameters={[
+          {
+            name: "param1",
+            type: "T1",
+            ref: true,
+          },
+          {
+            name: "param2",
+            type: "T2",
+            in: true,
+          },
+          {
+            name: "param3",
+            type: "T3",
+            out: true,
+          },
+          {
+            name: "param4",
+            type: "T4",
+            refReadonly: true,
+          },
+        ]}
+      />
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+        void MethodOne(ref T1 param1, in T2 param2, out T3 param3, ref readonly T4 param4) {}
+    }
+  `);
+});

package/src/components/parameters/parameters.tsx

@@ -22,6 +22,27 @@ export interface ParameterProps {
 
   refkey?: Refkey;
 
+  /**
+   * Parameter modifier: The argument must be initialized before calling the method. The method can't assign a new value to the parameter. The compiler might create a temporary variable to hold a copy of the argument to in parameters.
+   * @see https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/method-parameters#in-parameter-modifier
+   * */
+  in?: boolean;
+  /**
+   * Parameter modifier: The calling method isn't required to initialize the argument before calling the method. The method must assign a value to the parameter.
+   * @see https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/method-parameters#out-parameter-modifier
+   * */
+  out?: boolean;
+  /**
+   * Parameter modifier: The argument must be initialized before calling the method. The method can assign a new value to the parameter, but isn't required to do so.
+   * @see https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/method-parameters#ref-parameter-modifier
+   */
+  ref?: boolean;
+  /**
+   * Parameter modifier: The argument must be initialized before calling the method. The method can't assign a new value to the parameter.
+   * @see https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/method-parameters#ref-readonly-modifier
+   */
+  refReadonly?: boolean;
+
   /**
    * Define attributes to attach
    * @example
@@ -48,9 +69,26 @@ export function Parameter(props: ParameterProps) {
     isNullable: props.optional,
   });
 
+  // Only one of in, out, ref, ref readonly can be specified
+  const modifiers: (keyof ParameterProps)[] = (
+    ["in", "out", "ref", "refReadonly"] as (keyof ParameterProps)[]
+  ).filter((k) => props[k]);
+
+  if (modifiers.length > 1) {
+    throw new Error(
+      `Only one of 'in', 'out', 'ref', 'ref readonly' can be specified for parameter '${
+        typeof props.name === "string" ? props.name : props.name.name
+      }'`,
+    );
+  }
+  const modifier =
+    modifiers.length === 0 ? ""
+    : modifiers[0] === "refReadonly" ? "ref readonly "
+    : modifiers[0] + " ";
   return (
     <Declaration symbol={memberSymbol}>
       <AttributeList attributes={props.attributes} endline />
+      <>{modifier}</>
       <TypeSlot>{props.type}</TypeSlot>
       {props.optional ? "?" : ""} <Name />
       {props.default ? code` = ${props.default}` : ""}

package/src/create-library.test.tsx

@@ -191,3 +191,23 @@ it("has built-ins available", () => {
     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

@@ -1,6 +1,7 @@
 import {
   Binder,
   LibrarySymbolReference,
+  namekey,
   refkey,
   REFKEYABLE,
   TO_SYMBOL,
@@ -96,16 +97,15 @@ export type LibraryFrom<T> = {
 } & LibrarySymbolReference;
 
 interface InternalContext {
-  binder(): Binder;
-  ownerSymbol(): NamedTypeSymbol;
+  ownerSymbol(binder: Binder | undefined): 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 ownerSymbolPerBinder = new WeakMap<Binder, NamespaceSymbol>();
+
   const namespaceNames = rootNs.split(".");
 
   return createSymbolEntry(
@@ -115,33 +115,24 @@ export function createLibrary<T extends Record<string, Descriptor>>(
       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(),
-            });
+      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;
+          return ownerSymbol;
+        });
       },
     },
   ) as LibraryFrom<T>;
@@ -152,24 +143,26 @@ function createSymbolEntry(
   descriptor: Descriptor,
   context: InternalContext,
 ): LibrarySymbolReference {
-  let symbol: CSharpSymbol | undefined = undefined;
+  const symbols = new WeakMap<Binder, CSharpSymbol>();
 
-  function getSymbol() {
-    if (symbol) return symbol;
-
-    symbol = createSymbolFromDescriptor(
-      name,
-      descriptor,
-      context,
-      initializeMembers,
+  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,
+      ),
     );
-    return symbol;
   }
 
   const newContext: InternalContext = {
-    binder: context.binder,
-    ownerSymbol() {
-      return getSymbol() as NamedTypeSymbol;
+    ownerSymbol(binder) {
+      return getSymbol(binder) as NamedTypeSymbol;
     },
   };
 
@@ -182,10 +175,10 @@ function createSymbolEntry(
 
   const obj: LibrarySymbolReference & Record<string, unknown> = {
     [REFKEYABLE]() {
-      return getSymbol().refkeys[0];
+      return getSymbol(useBinder()).refkeys[0];
     },
     [TO_SYMBOL]() {
-      return getSymbol();
+      return getSymbol(useBinder());
     },
   };
 
@@ -209,36 +202,45 @@ function createSymbolEntry(
 
 function createSymbolFromDescriptor(
   name: string,
+  binder: Binder | undefined,
   descriptor: Descriptor,
   context: InternalContext,
   lazyMemberInitializer: () => void,
 ): CSharpSymbol {
-  const ownerSymbol = context.ownerSymbol();
-  const binder = context.binder();
+  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(name, ownerSymbol as NamespaceSymbol, {
-        binder,
-        refkeys: refkey(),
-        lazyMemberInitializer,
-      });
+      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(name, ownerSymbol.members, descriptor.kind, {
-        binder,
-        refkeys: refkey(),
-        lazyMemberInitializer,
-      });
+      return new NamedTypeSymbol(
+        namekey(name),
+        ownerSymbol.members,
+        descriptor.kind,
+        {
+          binder,
+          refkeys: refkey(),
+          lazyMemberInitializer,
+        },
+      );
     case "method":
       return new MethodSymbol(
-        name,
+        namekey(name),
         ownerSymbol.members,
         descriptor.methodKind,
         {
@@ -248,7 +250,7 @@ function createSymbolFromDescriptor(
       );
     case "field":
     case "property":
-      return new CSharpSymbol(name, ownerSymbol.members, {
+      return new CSharpSymbol(namekey(name), ownerSymbol.members, {
         binder,
         refkeys: refkey(),
         type:
@@ -260,7 +262,7 @@ function createSymbolFromDescriptor(
         lazyMemberInitializer,
       });
     case "generic":
-      return new CSharpSymbol(name, ownerSymbol.members, {
+      return new CSharpSymbol(namekey(name), ownerSymbol.members, {
         binder,
         refkeys: refkey(),
       });
@@ -268,3 +270,37 @@ function createSymbolFromDescriptor(
       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/temp/api.json

@@ -1857,10 +1857,14 @@
                   "kind": "Content",
                   "text": "name: "
                 },
+                {
+                  "kind": "Content",
+                  "text": "string | "
+                },
                 {
                   "kind": "Reference",
-                  "text": "Children",
-                  "canonicalReference": "@alloy-js/core!Children:type"
+                  "text": "Refkey",
+                  "canonicalReference": "@alloy-js/core!Refkey:type"
                 },
                 {
                   "kind": "Content",
@@ -1873,7 +1877,7 @@
               "name": "name",
               "propertyTypeTokenRange": {
                 "startIndex": 1,
-                "endIndex": 2
+                "endIndex": 3
               }
             }
           ],
@@ -13690,6 +13694,33 @@
                 "endIndex": 2
               }
             },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@alloy-js/csharp!ParameterProps#in:member",
+              "docComment": "/**\n * Parameter modifier: The argument must be initialized before calling the method. The method can't assign a new value to the parameter. The compiler might create a temporary variable to hold a copy of the argument to in parameters.\n *\n * @see\n *\n *  https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/method-parameters#in-parameter-modifier\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "in?: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": false,
+              "isOptional": true,
+              "releaseTag": "Public",
+              "name": "in",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
+            },
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/csharp!ParameterProps#name:member",
@@ -13749,6 +13780,60 @@
                 "endIndex": 2
               }
             },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@alloy-js/csharp!ParameterProps#out:member",
+              "docComment": "/**\n * Parameter modifier: The calling method isn't required to initialize the argument before calling the method. The method must assign a value to the parameter.\n *\n * @see\n *\n *  https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/method-parameters#out-parameter-modifier\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "out?: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": false,
+              "isOptional": true,
+              "releaseTag": "Public",
+              "name": "out",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
+            },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@alloy-js/csharp!ParameterProps#ref:member",
+              "docComment": "/**\n * Parameter modifier: The argument must be initialized before calling the method. The method can assign a new value to the parameter, but isn't required to do so.\n *\n * @see\n *\n *  https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/method-parameters#ref-parameter-modifier\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "ref?: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": false,
+              "isOptional": true,
+              "releaseTag": "Public",
+              "name": "ref",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
+            },
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/csharp!ParameterProps#refkey:member",
@@ -13777,6 +13862,33 @@
                 "endIndex": 2
               }
             },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@alloy-js/csharp!ParameterProps#refReadonly:member",
+              "docComment": "/**\n * Parameter modifier: The argument must be initialized before calling the method. The method can't assign a new value to the parameter.\n *\n * @see\n *\n *  https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/method-parameters#ref-readonly-modifier\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "refReadonly?: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": false,
+              "isOptional": true,
+              "releaseTag": "Public",
+              "name": "refReadonly",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
+            },
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/csharp!ParameterProps#type:member",