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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alloy-js/csharp",
-  "version": "0.21.0-dev.1",
+  "version": "0.21.0-dev.3",
   "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.ref.test.tsx

@@ -1,4 +1,4 @@
-import { Namespace } from "#components/namespace.jsx";
+import { Namespace } from "#components/namespace/namespace.jsx";
 import { SourceFile } from "#components/source-file/source-file.jsx";
 import { Output, refkey } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";

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/index.ts

@@ -15,7 +15,7 @@ export * from "./lexical-scope.jsx";
 export * from "./method-scope.jsx";
 export * from "./method/method.jsx";
 export * from "./Name.js";
-export * from "./namespace.js";
+export { Namespace, type NamespaceProps } from "./namespace/namespace.jsx";
 export * from "./parameters/parameters.jsx";
 export * from "./ProjectDirectory.js";
 export * from "./property/property.jsx";

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/namespace-name.tsx

@@ -0,0 +1,31 @@
+import { useNamespaceContext } from "../../contexts/namespace.js";
+import { NamespaceSymbol } from "../../symbols/namespace.js";
+
+/** @internal */
+export interface NamespaceNameProps {
+  symbol: NamespaceSymbol;
+
+  /** If it should print relative to the parent context */
+  relative?: boolean;
+}
+
+/** @internal */
+export function NamespaceName(props: NamespaceNameProps) {
+  const names = [props.symbol.name];
+  const parent = props.relative ? useNamespaceContext()?.symbol : undefined;
+
+  let current = props.symbol.ownerSymbol;
+  while (current) {
+    if (
+      current === parent ||
+      !(current instanceof NamespaceSymbol) ||
+      current.isGlobal
+    ) {
+      break;
+    }
+    names.unshift(current.name);
+    current = current.ownerSymbol;
+  }
+
+  return names.join(".");
+}

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

@@ -0,0 +1,145 @@
+import { TestNamespace } from "#test/utils.jsx";
+import { Output } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import { ClassDeclaration } from "../class/declaration.jsx";
+import { SourceFile } from "../source-file/source-file.jsx";
+import { Namespace } from "./namespace.jsx";
+
+it("defines multiple namespaces and source files with unique content", () => {
+  const tree = (
+    <Output>
+      <Namespace name="Namespace1">
+        <SourceFile path="Model1.cs">
+          <ClassDeclaration public name="Model1" />
+        </SourceFile>
+        <SourceFile path="Model2.cs">
+          <ClassDeclaration public name="Model2" />
+        </SourceFile>
+      </Namespace>
+      <Namespace name="Namespace2">
+        <SourceFile path="Model3.cs">
+          <ClassDeclaration public name="Model3" />
+        </SourceFile>
+        <SourceFile path="Model4.cs">
+          <ClassDeclaration public name="Model4" />
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo({
+    "Model1.cs": d`
+      namespace Namespace1;
+
+      public class Model1;
+    `,
+    "Model2.cs": d`
+      namespace Namespace1;
+
+      public class Model2;
+    `,
+    "Model3.cs": d`
+      namespace Namespace2;
+      
+      public class Model3;
+    `,
+    "Model4.cs": d`
+      namespace Namespace2;
+      
+      public class Model4;
+    `,
+  });
+});
+
+it("nest namespaces", () => {
+  const tree = (
+    <Output>
+      <Namespace name={["Namespace1"]}>
+        <Namespace name={["Namespace2"]}>
+          <SourceFile path="Model1.cs">
+            <ClassDeclaration public name="Model1" />
+          </SourceFile>
+        </Namespace>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(`
+    namespace Namespace1.Namespace2;
+
+    public class Model1;
+  `);
+});
+
+it("define nested namespace directly with array", () => {
+  const tree = (
+    <Output>
+      <Namespace name={["Namespace1", "Namespace2"]}>
+        <SourceFile path="Model1.cs">
+          <ClassDeclaration public name="Model1" />
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(`
+    namespace Namespace1.Namespace2;
+
+    public class Model1;
+  `);
+});
+
+it("define nested namespace directly as dotted notation", () => {
+  const tree = (
+    <Output>
+      <Namespace name="Namespace1.Namespace2">
+        <SourceFile path="Model1.cs">
+          <ClassDeclaration public name="Model1" />
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo({
+    "Model1.cs": d`
+      namespace Namespace1.Namespace2;
+
+      public class Model1;
+    `,
+  });
+});
+
+it("uses a name policy", () => {
+  expect(
+    <TestNamespace>
+      <Namespace name="my-namespace" />
+    </TestNamespace>,
+  ).toRenderTo(`
+    namespace MyNamespace {
+
+    }
+  `);
+});
+
+it("define nested namespace in sourcefile", () => {
+  const tree = (
+    <Output>
+      <Namespace name="Base">
+        <SourceFile path="Model1.cs">
+          <Namespace name="Namespace1.Namespace2">
+            <ClassDeclaration public name="Model1" />
+          </Namespace>
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(`
+    namespace Base {
+        namespace Namespace1.Namespace2 {
+            public class Model1;
+        }
+    }
+  `);
+});

package/src/components/{namespace.tsx → namespace/namespace.tsx}

@@ -1,17 +1,21 @@
-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";
-import { createNamespaceSymbol } from "../symbols/factories.js";
-import { NamespaceScope } from "./namespace-scopes.jsx";
+import { NamespaceContext } from "../../contexts/namespace.js";
+import { useSourceFileScope } from "../../scopes/source-file.js";
+import { createNamespaceSymbol } from "../../symbols/factories.js";
+import { NamespaceScope } from "../namespace-scopes.jsx";
+import { NamespaceName } from "./namespace-name.jsx";
 
 export interface NamespaceProps {
-  name: string;
+  name: string | Namekey | (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) {
@@ -24,7 +28,7 @@ export function Namespace(props: NamespaceProps) {
     sfScope.hasBlockNamespace = true;
     return (
       <>
-        namespace {namespaceSymbol.name}{" "}
+        namespace <NamespaceName symbol={namespaceSymbol} relative />{" "}
         <Block>
           <NamespaceContext.Provider value={{ symbol: namespaceSymbol }}>
             <NamespaceScope symbol={namespaceSymbol}>
@@ -36,10 +40,3 @@ export function Namespace(props: NamespaceProps) {
     );
   }
 }
-
-/*
-  const scope = createCSharpNamespaceScope(namespaceSymbol);
-
-  return <Scope value={scope}>{props.children}</Scope>;
-}
-  */

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

@@ -1,8 +1,7 @@
-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";
+import { Namespace } from "./namespace/namespace.jsx";
 import { SourceFile } from "./source-file/source-file.jsx";
 
 it("references types in the same namespace", () => {
@@ -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/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(