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

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

@@ -24,5 +24,5 @@ export * from "./Reference.js";
 export * from "./source-file/source-file.jsx";
 export * from "./struct/declaration.jsx";
 export type { TypeParameterProps } from "./type-parameters/type-parameter.jsx";
-export * from "./UsingDirective.js";
+export * from "./using/using.jsx";
 export * from "./var/declaration.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.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/source-file/source-file.tsx

@@ -1,6 +1,6 @@
 import { NamespaceScopes } from "#components/namespace-scopes.jsx";
 import { Reference } from "#components/Reference.jsx";
-import { UsingDirective } from "#components/UsingDirective.jsx";
+import { Usings } from "#components/using/using.jsx";
 import {
   Block,
   Children,
@@ -70,7 +70,7 @@ export function SourceFile(props: SourceFileProps) {
         {(sourceFileScope.usings.size > 0 ||
           (props.using && props.using.length > 0)) && (
           <>
-            <UsingDirective namespaces={usings.value} />
+            <Usings namespaces={usings.value} />
             <hbr />
             <hbr />
           </>

package/src/components/source-file/using.test.tsx

@@ -0,0 +1,94 @@
+import { ClassDeclaration } from "#components/class/declaration.jsx";
+import { EnumDeclaration } from "#components/enum/declaration.jsx";
+import { EnumMember } from "#components/enum/member.jsx";
+import { Method } from "#components/method/method.jsx";
+import { Namespace } from "#components/namespace.jsx";
+import { SourceFile } from "#components/source-file/source-file.jsx";
+import { Output, refkey } from "@alloy-js/core";
+import * as coretest from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import { createCSharpNamePolicy } from "../../name-policy.js";
+
+it("using on source file are placed above file namespace statement", () => {
+  expect(
+    <Output>
+      <Namespace name="TestCode">
+        <SourceFile path="Test1.cs" using={["Foo"]} />
+      </Namespace>
+    </Output>,
+  ).toRenderTo(`
+    using Foo;
+
+    namespace TestCode;
+
+    
+  `);
+});
+
+it("adds using statement across namespaces", () => {
+  const inputTypeRefkey = refkey();
+  const outputTypeRefkey = refkey();
+  const twoValRefkey = refkey();
+
+  const params = [
+    {
+      name: "BodyParam",
+      type: inputTypeRefkey,
+    },
+  ];
+
+  expect(
+    <Output namePolicy={createCSharpNamePolicy()}>
+      <Namespace name="Models">
+        <SourceFile path="Models.cs">
+          <ClassDeclaration public name="Input" refkey={inputTypeRefkey} />
+          <hbr />
+          <ClassDeclaration public name="Output" refkey={outputTypeRefkey} />
+          <hbr />
+          <EnumDeclaration public name="TestEnum">
+            <EnumMember name="One" />,<hbr />
+            <EnumMember name="Two" refkey={twoValRefkey} />
+          </EnumDeclaration>
+        </SourceFile>
+      </Namespace>
+      <Namespace name="Client">
+        <SourceFile path="Client.cs" using={["System"]}>
+          <ClassDeclaration public name="Client">
+            <Method
+              public
+              name="MethodOne"
+              parameters={params}
+              returns={outputTypeRefkey}
+            />
+          </ClassDeclaration>
+          <hbr />
+          {twoValRefkey};
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  ).toRenderTo({
+    "Models.cs": coretest.d`
+      namespace Models;
+
+      public class Input;
+      public class Output;
+      public enum TestEnum
+      {
+          One,
+          Two
+      }
+    `,
+    "Client.cs": coretest.d`
+      using Models;
+      using System;
+
+      namespace Client;
+      
+      public class Client
+      {
+          public Output MethodOne(Input bodyParam) {}
+      }
+      TestEnum.Two;
+    `,
+  });
+});

package/src/components/stc/index.ts

@@ -10,5 +10,5 @@ export const EnumMember = core.stc(base.EnumMember);
 export const Parameter = core.stc(base.Parameter);
 export const Parameters = core.stc(base.Parameters);
 export const ProjectDirectory = core.stc(base.ProjectDirectory);
-export const UsingDirective = core.stc(base.UsingDirective);
+export const UsingDirective = core.stc(base.Usings);
 export const StructDeclaration = core.stc(base.StructDeclaration);

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>`);
+});