@alloy-js/csharp 0.21.0-dev.1 → 0.21.0-dev.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alloy-js/csharp",
-  "version": "0.21.0-dev.1",
+  "version": "0.21.0-dev.2",
   "description": "Alloy components for CSharp language.",
   "exports": {
     ".": {
@@ -20,7 +20,7 @@
   "author": "jhendrix@microsoft.com",
   "license": "MIT",
   "dependencies": {
-    "@alloy-js/core": "~0.20.0 || >= 0.21.0-dev.0",
+    "@alloy-js/core": "~0.20.0 || >= 0.21.0-dev.1",
     "change-case": "^5.4.4",
     "marked": "^16.1.1",
     "pathe": "^2.0.3"

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

@@ -1,4 +1,5 @@
-import { toSourceText } from "#test/utils.jsx";
+import { TestNamespace, toSourceText } from "#test/utils.jsx";
+import { namekey } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";
 import { expect, it } from "vitest";
 import { EnumDeclaration } from "./declaration.jsx";
@@ -32,3 +33,15 @@ it("applies naming policy to enum and members", () => {
     }
   `);
 });
+
+it("takes a namekey", () => {
+  const key = namekey("my-enum");
+  const tree = (
+    <TestNamespace>
+      <EnumDeclaration name={key} />
+    </TestNamespace>
+  );
+  expect(tree).toRenderTo(`
+    enum MyEnum;
+  `);
+});

package/src/components/enum/declaration.tsx

@@ -3,6 +3,7 @@ import {
   Children,
   Declaration,
   MemberScope,
+  Namekey,
   Refkey,
 } from "@alloy-js/core";
 import {
@@ -17,7 +18,7 @@ import { Name } from "../Name.jsx";
 
 // properties for creating an enum
 export interface EnumDeclarationProps extends AccessModifiers {
-  name: string;
+  name: string | Namekey;
   refkey?: Refkey | Refkey[];
   children?: Children;
 }
@@ -43,9 +44,9 @@ export interface EnumDeclarationProps extends AccessModifiers {
  * ```
  */
 export function EnumDeclaration(props: EnumDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name!, "enum");
-  const symbol = createNamedTypeSymbol(name, "enum", {
+  const symbol = createNamedTypeSymbol(props.name, "enum", {
     refkeys: props.refkey,
+    namePolicy: useCSharpNamePolicy().for("enum"),
   });
   const scope = createNamedTypeScope(symbol);
 

package/src/components/enum/member.test.tsx

@@ -1,4 +1,5 @@
-import { toSourceText } from "#test/utils.jsx";
+import { TestNamespace, toSourceText } from "#test/utils.jsx";
+import { namekey } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";
 import { expect, it } from "vitest";
 import { EnumDeclaration } from "./declaration.jsx";
@@ -22,3 +23,23 @@ it("declares enum with members", () => {
     }
   `);
 });
+
+it("takes a namekey", () => {
+  const memberKey = namekey("MyMember");
+  const tree = (
+    <TestNamespace>
+      <EnumDeclaration name="Foo">
+        <EnumMember name={memberKey} />
+      </EnumDeclaration>
+      <hbr />
+      {memberKey};
+    </TestNamespace>
+  );
+  expect(tree).toRenderTo(`
+    enum Foo
+    {
+        MyMember
+    }
+    Foo.MyMember;
+  `);
+});

package/src/components/enum/member.tsx

@@ -1,11 +1,11 @@
-import { MemberDeclaration, MemberName, Refkey } from "@alloy-js/core";
+import { MemberDeclaration, MemberName, Namekey, Refkey } from "@alloy-js/core";
 import { useCSharpNamePolicy } from "../../name-policy.js";
 import { useNamedTypeScope } from "../../scopes/contexts.js";
 import { CSharpSymbol } from "../../symbols/csharp.js";
 
 // properties for creating a C# enum member
 export interface EnumMemberProps {
-  name: string;
+  name: string | Namekey;
   refkey?: Refkey;
 }
 
@@ -23,9 +23,9 @@ export function EnumMember(props: EnumMemberProps) {
     throw new Error("EnumMember must be used within an EnumDeclaration.");
   }
 
-  const name = useCSharpNamePolicy().getName(props.name, "enum-member");
-  const thisEnumValueSymbol = new CSharpSymbol(name, symbol.members, {
+  const thisEnumValueSymbol = new CSharpSymbol(props.name, symbol.members, {
     refkeys: props.refkey,
+    namePolicy: useCSharpNamePolicy().for("enum-member"),
   });
 
   return (

package/src/components/field/field.test.tsx

@@ -1,4 +1,4 @@
-import { List } from "@alloy-js/core";
+import { List, namekey } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { ClassDeclaration } from "../class/declaration.jsx";
@@ -30,6 +30,19 @@ it("declares multiple fields", () => {
   `);
 });
 
+it("takes a namekey", () => {
+  expect(
+    <Wrapper>
+      <Field name={namekey("my-field")} type="string" public />
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+        public string MyField;
+    }
+  `);
+});
+
 describe("modifiers", () => {
   describe("access modifiers", () => {
     it.each(["public", "private", "protected", "internal"] as const)(

package/src/components/field/field.tsx

@@ -1,4 +1,4 @@
-import { Children, Declaration, Name, Refkey } from "@alloy-js/core";
+import { Children, Declaration, Name, Namekey, Refkey } from "@alloy-js/core";
 import {
   AccessModifiers,
   computeModifiersPrefix,
@@ -28,7 +28,7 @@ const getModifiers = makeModifiers<FieldModifiers>([
 ]);
 
 export interface FieldProps extends AccessModifiers, FieldModifiers {
-  name: string;
+  name: string | Namekey;
   type: Children;
   refkey?: Refkey;
   /** Doc comment */

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

@@ -1,4 +1,4 @@
-import { List, refkey } from "@alloy-js/core";
+import { List, namekey, refkey } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { Attribute } from "../attributes/attributes.jsx";
@@ -59,6 +59,16 @@ it("specify doc comment", () => {
   `);
 });
 
+it("takes a namekey", () => {
+  expect(
+    <TestNamespace>
+      <InterfaceDeclaration name={namekey("my-interface")} />
+    </TestNamespace>,
+  ).toRenderTo(`
+    interface MyInterface;
+  `);
+});
+
 describe("with type parameters", () => {
   it("reference parameters", () => {
     const typeParameters: TypeParameterProps[] = [

package/src/components/interface/declaration.tsx

@@ -26,7 +26,7 @@ export interface InterfaceDeclarationProps
   extends Omit<core.DeclarationProps, "nameKind">,
     AccessModifiers,
     InterfaceModifiers {
-  name: string;
+  name: string | core.Namekey;
 
   /** Doc comment */
   doc?: core.Children;
@@ -86,10 +86,9 @@ export interface InterfaceDeclarationProps
  * ```
  */
 export function InterfaceDeclaration(props: InterfaceDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name!, "interface");
-
-  const symbol = createNamedTypeSymbol(name, "interface", {
+  const symbol = createNamedTypeSymbol(props.name!, "interface", {
     refkeys: props.refkey,
+    namePolicy: useCSharpNamePolicy().for("interface"),
   });
 
   // this creates a new scope for the interface definition.

package/src/components/interface/method.test.tsx

@@ -1,4 +1,4 @@
-import { refkey } from "@alloy-js/core";
+import { namekey, refkey } from "@alloy-js/core";
 import { Children } from "@alloy-js/core/jsx-runtime";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
@@ -188,6 +188,19 @@ it("specify attributes", () => {
   `);
 });
 
+it("takes a namekey", () => {
+  expect(
+    <Wrapper>
+      <InterfaceMethod name={namekey("my-method")} />
+    </Wrapper>,
+  ).toRenderTo(`
+    public interface TestInterface
+    {
+        void MyMethod();
+    }
+  `);
+});
+
 describe("with type parameters", () => {
   it("reference parameters", () => {
     const typeParameters: TypeParameterProps[] = [

package/src/components/interface/method.tsx

@@ -3,6 +3,7 @@ import {
   Children,
   MemberDeclaration,
   MemberName,
+  Namekey,
   Refkey,
   Scope,
 } from "@alloy-js/core";
@@ -32,7 +33,7 @@ const getMethodModifier = makeModifiers<InterfaceMethodModifiers>(["new"]);
 export interface InterfaceMethodProps
   extends AccessModifiers,
     InterfaceMethodModifiers {
-  name: string;
+  name: string | Namekey;
   refkey?: Refkey;
   children?: Children;
   parameters?: Array<ParameterProps>;

package/src/components/interface/property.test.tsx

@@ -1,5 +1,6 @@
 import { Children } from "@alloy-js/core/jsx-runtime";
 import { describe, expect, it } from "vitest";
+import { namekey } from "../../../../core/src/refkey.js";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { Attribute } from "../attributes/attributes.jsx";
 import { InterfaceDeclaration } from "./declaration.jsx";
@@ -144,6 +145,18 @@ it("specify doc comment", () => {
   `);
 });
 
+it("takes a namekey", () => {
+  expect(
+    <Wrapper>
+      <InterfaceProperty name={namekey("my-property")} type="string" get />
+    </Wrapper>,
+  ).toRenderTo(`
+    public interface TestInterface
+    {
+        string MyProperty { get; }
+    }
+  `);
+});
 it("specify attributes", () => {
   expect(
     <Wrapper>

package/src/components/interface/property.tsx

@@ -4,6 +4,7 @@ import {
   List,
   MemberDeclaration,
   MemberName,
+  Namekey,
   Refkey,
 } from "@alloy-js/core";
 import {
@@ -27,7 +28,7 @@ const getModifiers = makeModifiers<InterfacePropertyModifiers>(["new"]);
 export interface InterfacePropertyProps
   extends AccessModifiers,
     InterfacePropertyModifiers {
-  name: string;
+  name: string | Namekey;
   refkey?: Refkey;
 
   /** Property type */

package/src/components/namespace.ref.test.tsx

@@ -1,5 +1,4 @@
-import { Output, refkey } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
+import { List, memberRefkey, namekey, Output, refkey } from "@alloy-js/core";
 import { expect, it } from "vitest";
 import { ClassDeclaration } from "./class/declaration.jsx";
 import { Namespace } from "./namespace.jsx";
@@ -20,7 +19,7 @@ it("references types in the same namespace", () => {
     </Output>
   );
 
-  expect(tree).toRenderTo(d`
+  expect(tree).toRenderTo(`
     namespace Test;
 
     class TestClass;
@@ -43,7 +42,7 @@ it("references types in a parent namespace", () => {
     </Output>
   );
 
-  expect(tree).toRenderTo(d`
+  expect(tree).toRenderTo(`
     namespace Test {
         class TestClass;
         namespace Nested {
@@ -69,7 +68,7 @@ it("references types in a child namespace", () => {
     </Output>
   );
 
-  expect(tree).toRenderTo(d`
+  expect(tree).toRenderTo(`
     namespace Test {
         Nested.TestClass;
         namespace Nested {
@@ -94,7 +93,7 @@ it("references types in a different top-level namespace declared in the same fil
     </Output>
   );
 
-  expect(tree).toRenderTo(d`
+  expect(tree).toRenderTo(`
     using TestCode2;
 
     namespace TestCode1 {
@@ -123,17 +122,43 @@ it("references types in a different top-level namespace declared in a different
   );
 
   expect(tree).toRenderTo({
-    "test.cs": d`
+    "test.cs": `
       using TestCode2;
 
       namespace TestCode1 {
           TestClass;
       }
     `,
-    "other.cs": d`
+    "other.cs": `
         namespace TestCode2 {
             class TestClass;
         }
       `,
   });
 });
+
+it("can be referenced by refkey", () => {
+  const classRef = namekey("TestClass");
+  const nsRef = namekey("TestCode2");
+  const tree = (
+    <Output>
+      <SourceFile path="other.cs">
+        <List>
+          <Namespace name={nsRef}>
+            <ClassDeclaration name={classRef} />
+          </Namespace>
+          <>{memberRefkey(nsRef, classRef)};</>
+        </List>
+      </SourceFile>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(`
+    using TestCode2;
+
+    namespace TestCode2 {
+        class TestClass;
+    }
+    TestClass;
+  `);
+});

package/src/components/namespace.test.tsx

@@ -1,3 +1,4 @@
+import { TestNamespace } from "#test/utils.jsx";
 import { Output } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";
 import { expect, it } from "vitest";
@@ -50,3 +51,15 @@ it("defines multiple namespaces and source files with unique content", () => {
     `,
   });
 });
+
+it("uses a name policy", () => {
+  expect(
+    <TestNamespace>
+      <Namespace name="my-namespace" />
+    </TestNamespace>,
+  ).toRenderTo(`
+    namespace MyNamespace {
+
+    }
+  `);
+});

package/src/components/namespace.tsx

@@ -1,4 +1,4 @@
-import { Block } from "@alloy-js/core";
+import { Block, Namekey, Refkey } from "@alloy-js/core";
 import { Children } from "@alloy-js/core/jsx-runtime";
 import { NamespaceContext } from "../contexts/namespace.js";
 import { useSourceFileScope } from "../scopes/source-file.js";
@@ -6,12 +6,15 @@ import { createNamespaceSymbol } from "../symbols/factories.js";
 import { NamespaceScope } from "./namespace-scopes.jsx";
 
 export interface NamespaceProps {
-  name: string;
+  name: string | Namekey;
+  refkey?: Refkey | Refkey[];
   children?: Children;
 }
 
 export function Namespace(props: NamespaceProps) {
-  const namespaceSymbol = createNamespaceSymbol(props.name);
+  const namespaceSymbol = createNamespaceSymbol(props.name, {
+    refkeys: props.refkey,
+  });
   const sfScope = useSourceFileScope();
 
   if (!sfScope) {

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

@@ -1,4 +1,4 @@
-import { Children, code, refkey } from "@alloy-js/core";
+import { Children, code, namekey, refkey } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { Property } from "../property/property.jsx";
@@ -19,6 +19,16 @@ it("declares record with no members", () => {
   `);
 });
 
+it("takes a namekey", () => {
+  expect(
+    <TestNamespace>
+      <RecordDeclaration name={namekey("my-record")} />
+    </TestNamespace>,
+  ).toRenderTo(`
+      record MyRecord;
+  `);
+});
+
 describe("modifiers", () => {
   it.each(["public", "private", "internal"])("%s", (mod) => {
     expect(

package/src/components/record/declaration.tsx

@@ -26,7 +26,7 @@ export interface RecordDeclarationProps
   extends Omit<core.DeclarationProps, "nameKind">,
     AccessModifiers,
     RecordModifiers {
-  name: string;
+  name: string | core.Namekey;
 
   /** Doc comment */
   doc?: core.Children;
@@ -73,12 +73,11 @@ export interface RecordDeclarationProps
  * ```
  */
 export function RecordDeclaration(props: RecordDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name!, "record");
-
   // records don't have their own type kind but instead use class or struct
   // depending on what kind of record we have.
-  const thisRecordSymbol = createNamedTypeSymbol(name, "record", {
+  const thisRecordSymbol = createNamedTypeSymbol(props.name, "record", {
     refkeys: props.refkey,
+    namePolicy: useCSharpNamePolicy().for("record"),
   });
 
   const thisRecordScope = createClassScope(thisRecordSymbol);

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

@@ -1,4 +1,4 @@
-import { List, refkey } from "@alloy-js/core";
+import { List, namekey, refkey } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { Attribute } from "../attributes/attributes.jsx";
@@ -19,6 +19,16 @@ it("declares struct with no members", () => {
   `);
 });
 
+it("takes a namekey", () => {
+  expect(
+    <TestNamespace>
+      <StructDeclaration name={namekey("my-struct")} />
+    </TestNamespace>,
+  ).toRenderTo(`
+      struct MyStruct;
+  `);
+});
+
 describe("modifiers", () => {
   it.each(["public", "private", "internal"])("%s", (mod) => {
     expect(

package/src/components/struct/declaration.tsx

@@ -35,7 +35,7 @@ export interface StructDeclarationProps
   extends Omit<core.DeclarationProps, "nameKind">,
     AccessModifiers,
     StructModifiers {
-  name: string;
+  name: string | core.Namekey;
 
   /** Doc comment */
   doc?: core.Children;
@@ -98,10 +98,9 @@ export interface StructDeclarationProps
  * ```
  */
 export function StructDeclaration(props: StructDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name!, "struct");
-
-  const thisStructSymbol = createNamedTypeSymbol(name, "struct", {
+  const thisStructSymbol = createNamedTypeSymbol(props.name, "struct", {
     refkeys: props.refkey,
+    namePolicy: useCSharpNamePolicy().for("struct"),
   });
 
   const thisStructScope = createNamedTypeScope(thisStructSymbol);

package/src/components/type-parameters/type-parameter.tsx

@@ -2,6 +2,7 @@ import {
   Children,
   MemberDeclaration,
   MemberName,
+  Namekey,
   Refkey,
 } from "@alloy-js/core";
 import { createTypeParameterSymbol } from "../../symbols/factories.js";
@@ -13,7 +14,7 @@ export interface TypeParameterProps {
   /**
    * The name of the type parameter.
    */
-  readonly name: string;
+  readonly name: string | Namekey;
 
   /**
    * The parameter constraint

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

@@ -1,3 +1,4 @@
+import { namekey } from "@alloy-js/core";
 import { expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { TypeParameters } from "./type-parameters.jsx";
@@ -44,3 +45,11 @@ it("declare type parameters using parameters", () => {
     </TestNamespace>,
   ).toRenderTo(`<A, B>`);
 });
+
+it("takes a namekey", () => {
+  expect(
+    <TestNamespace>
+      <TypeParameters parameters={[{ name: namekey("my-param") }]} />
+    </TestNamespace>,
+  ).toRenderTo(`<MyParam>`);
+});

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

@@ -1,4 +1,4 @@
-import { List, refkey } from "@alloy-js/core";
+import { List, namekey, refkey } from "@alloy-js/core";
 import { expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { VarDeclaration } from "./declaration.jsx";
@@ -51,3 +51,18 @@ it("links refkey", () => {
       var testVar2 = testVar;
   `);
 });
+
+it("links namekey", () => {
+  const key = namekey("test-var");
+  expect(
+    <TestNamespace>
+      <List>
+        <VarDeclaration name={key}>42</VarDeclaration>
+        <VarDeclaration name="testVar2">{key}</VarDeclaration>
+      </List>
+    </TestNamespace>,
+  ).toRenderTo(`
+      var testVar = 42;
+      var testVar2 = testVar;
+  `);
+});

package/src/components/var/declaration.tsx

@@ -3,6 +3,7 @@ import {
   Declaration,
   DeclarationProps,
   Name,
+  Namekey,
   Refkey,
 } from "@alloy-js/core";
 import { createVariableSymbol } from "../../symbols/factories.js";
@@ -11,7 +12,7 @@ import { createVariableSymbol } from "../../symbols/factories.js";
 export interface VarDeclarationProps
   extends Omit<DeclarationProps, "nameKind"> {
   /** Variable name */
-  name: string;
+  name: string | Namekey;
   /** Type of the variable declaration. If not specified, defaults to "var" */
   type?: Children;
   /** Variable refkey */

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

@@ -118,13 +118,21 @@ export function createNamedTypeSymbol(
   );
 }
 
-export function createNamespaceSymbol(name: string) {
+export function createNamespaceSymbol(
+  name: string | Namekey,
+  options: CSharpSymbolOptions = {},
+) {
   const scope = useEnclosingNamespaceScope();
   const nsSymbol = scope?.ownerSymbol ?? getGlobalNamespace(useBinder());
-  if (nsSymbol.members.symbolNames.has(name)) {
-    return nsSymbol.members.symbolNames.get(name)! as NamespaceSymbol;
+  const namePolicy =
+    options.namePolicy ?? useCSharpNamePolicy().for("namespace");
+  const expectedName = namePolicy(typeof name === "string" ? name : name.name);
+  if (nsSymbol.members.symbolNames.has(expectedName)) {
+    return nsSymbol.members.symbolNames.get(expectedName)! as NamespaceSymbol;
   }
-  return withCleanup(new NamespaceSymbol(name, nsSymbol));
+  return withCleanup(
+    new NamespaceSymbol(name, nsSymbol, withNamePolicy(options, "namespace")),
+  );
 }
 
 export interface CreateMethodSymbolOptions extends CSharpSymbolOptions {

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,
   ) {