@alloy-js/csharp 0.21.0-dev.15 → 0.21.0-dev.17

package/package.json

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

package/src/components/var/declaration.test.tsx

@@ -1,5 +1,5 @@
 import { List, namekey, refkey } from "@alloy-js/core";
-import { expect, it } from "vitest";
+import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { VarDeclaration } from "./declaration.jsx";
 
@@ -66,3 +66,17 @@ it("links namekey", () => {
       var testVar2 = testVar;
   `);
 });
+
+describe("modifiers", () => {
+  it.each(["const", "using"])("%s", (mod) => {
+    expect(
+      <TestNamespace>
+        <VarDeclaration {...{ [mod]: true }} name="test" type="object">
+          a
+        </VarDeclaration>
+      </TestNamespace>,
+    ).toRenderTo(`
+        ${mod} object test = a;
+    `);
+  });
+});

package/src/components/var/declaration.tsx

@@ -7,11 +7,13 @@ import {
   Namekey,
   Refkey,
 } from "@alloy-js/core";
+import { computeModifiersPrefix, makeModifiers } from "../../modifiers.js";
 import { createVariableSymbol } from "../../symbols/factories.js";
 
 /** Props for {@link VarDeclaration} component */
 export interface VarDeclarationProps
-  extends Omit<DeclarationProps, "nameKind"> {
+  extends Omit<DeclarationProps, "nameKind">,
+    VarModifiers {
   /** Variable name */
   name: string | Namekey;
   /** Type of the variable declaration. If not specified, defaults to "var" */
@@ -20,11 +22,18 @@ export interface VarDeclarationProps
   refkey?: Refkey;
   /** Variable value */
   children?: Children;
+}
 
+export interface VarModifiers {
   /** Constant variable. Add the const modifier. */
-  const?: boolean;
+  readonly const?: boolean;
+
+  /** Disposable variable. Add the using modifier. */
+  readonly using?: boolean;
 }
 
+const getModifiers = makeModifiers<VarModifiers>(["const", "using"]);
+
 /**
  * Render a variable declaration
  *
@@ -60,7 +69,7 @@ export function VarDeclaration(props: VarDeclarationProps) {
   }
   return (
     <Declaration symbol={sym}>
-      {props.const ? "const " : ""}
+      {computeModifiersPrefix([getModifiers(props)])}
       <TypeSlot>{props.type ?? "var"}</TypeSlot> <Name /> ={" "}
       <ValueSlot>{props.children}</ValueSlot>;
     </Declaration>

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

@@ -96,16 +96,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 +114,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(name, ownerSymbol!, {
+                binder,
+                refkeys: refkey(),
+              });
+            }
           }
-        }
 
-        return ownerSymbol;
+          return ownerSymbol;
+        });
       },
     },
   ) as LibraryFrom<T>;
@@ -152,24 +142,26 @@ function createSymbolEntry(
   descriptor: Descriptor,
   context: InternalContext,
 ): LibrarySymbolReference {
-  let symbol: CSharpSymbol | undefined = undefined;
-
-  function getSymbol() {
-    if (symbol) return symbol;
+  const symbols = new WeakMap<Binder, CSharpSymbol>();
 
-    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 +174,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,12 +201,12 @@ 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":
@@ -268,3 +260,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

@@ -16856,6 +16856,15 @@
               "kind": "Content",
               "text": ", \"nameKind\">"
             },
+            {
+              "kind": "Content",
+              "text": ", "
+            },
+            {
+              "kind": "Reference",
+              "text": "VarModifiers",
+              "canonicalReference": "@alloy-js/csharp!VarModifiers:interface"
+            },
             {
               "kind": "Content",
               "text": " "
@@ -16894,33 +16903,6 @@
                 "endIndex": 2
               }
             },
-            {
-              "kind": "PropertySignature",
-              "canonicalReference": "@alloy-js/csharp!VarDeclarationProps#const:member",
-              "docComment": "/**\n * Constant variable. Add the const modifier.\n */\n",
-              "excerptTokens": [
-                {
-                  "kind": "Content",
-                  "text": "const?: "
-                },
-                {
-                  "kind": "Content",
-                  "text": "boolean"
-                },
-                {
-                  "kind": "Content",
-                  "text": ";"
-                }
-              ],
-              "isReadonly": false,
-              "isOptional": true,
-              "releaseTag": "Public",
-              "name": "const",
-              "propertyTypeTokenRange": {
-                "startIndex": 1,
-                "endIndex": 2
-              }
-            },
             {
               "kind": "PropertySignature",
               "canonicalReference": "@alloy-js/csharp!VarDeclarationProps#name:member",
@@ -17014,8 +16996,84 @@
             {
               "startIndex": 1,
               "endIndex": 5
+            },
+            {
+              "startIndex": 6,
+              "endIndex": 7
             }
           ]
+        },
+        {
+          "kind": "Interface",
+          "canonicalReference": "@alloy-js/csharp!VarModifiers:interface",
+          "docComment": "",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export interface VarModifiers "
+            }
+          ],
+          "fileUrlPath": "src/components/var/declaration.tsx",
+          "releaseTag": "Public",
+          "name": "VarModifiers",
+          "preserveMemberOrder": false,
+          "members": [
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@alloy-js/csharp!VarModifiers#const:member",
+              "docComment": "/**\n * Constant variable. Add the const modifier.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "readonly const?: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": true,
+              "isOptional": true,
+              "releaseTag": "Public",
+              "name": "const",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
+            },
+            {
+              "kind": "PropertySignature",
+              "canonicalReference": "@alloy-js/csharp!VarModifiers#using:member",
+              "docComment": "/**\n * Disposable variable. Add the using modifier.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "readonly using?: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": true,
+              "isOptional": true,
+              "releaseTag": "Public",
+              "name": "using",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              }
+            }
+          ],
+          "extendsTokenRanges": []
         }
       ]
     }