@alloy-js/csharp 0.17.0 → 0.18.0-dev.11

package/test/{class.test.tsx → class-declaration.test.tsx}

@@ -1,38 +1,60 @@
 import * as core from "@alloy-js/core";
 import * as coretest from "@alloy-js/core/testing";
-import { expect, it } from "vitest";
+import { describe, expect, it } from "vitest";
 import * as csharp from "../src/index.js";
-import * as utils from "./utils.js";
+import { ClassDeclaration, ClassMember } from "../src/index.js";
+import * as utils from "./utils.jsx";
 
 it("declares class with no members", () => {
-  const res = utils.toSourceText(
-    <csharp.Class accessModifier="public" name="TestClass" />,
-  );
-
-  expect(res).toBe(coretest.d`
-    namespace TestCode
-    {
-        public class TestClass;
-    }
+  expect(
+    <utils.TestNamespace>
+      <ClassDeclaration name="TestClass" />
+    </utils.TestNamespace>,
+  ).toRenderTo(`
+      class TestClass;
   `);
 });
 
+describe("modifiers", () => {
+  it.each(["public", "private"])("%s", (mod) => {
+    expect(
+      <utils.TestNamespace>
+        <ClassDeclaration {...{ [mod]: true }} name="TestClass" />
+      </utils.TestNamespace>,
+    ).toRenderTo(`
+        ${mod} class TestClass;
+    `);
+  });
+
+  it.each(["partial", "abstract", "static", "sealed"])("%s", (mod) => {
+    expect(
+      <utils.TestNamespace>
+        <ClassDeclaration {...{ [mod]: true }} name="TestClass" />
+      </utils.TestNamespace>,
+    ).toRenderTo(`
+        ${mod} class TestClass;
+    `);
+  });
+
+  it("combines modifiers", () => {
+    expect(
+      <utils.TestNamespace>
+        <ClassDeclaration public abstract partial name="TestClass" />
+      </utils.TestNamespace>,
+    ).toRenderTo(`
+        public abstract partial class TestClass;
+    `);
+  });
+});
+
 it("declares class with some members", () => {
   const res = utils.toSourceText(
-    <csharp.Class accessModifier="public" name="TestClass">
+    <csharp.ClassDeclaration public name="TestClass">
       <core.StatementList>
-        <csharp.ClassMember
-          accessModifier="public"
-          name="MemberOne"
-          type="string"
-        />
-        <csharp.ClassMember
-          accessModifier="private"
-          name="MemberTwo"
-          type="int"
-        />
+        <csharp.ClassMember public name="MemberOne" type="string" />
+        <csharp.ClassMember private name="MemberTwo" type="int" />
       </core.StatementList>
-    </csharp.Class>,
+    </csharp.ClassDeclaration>,
   );
 
   expect(res).toBe(coretest.d`
@@ -49,16 +71,12 @@ it("declares class with some members", () => {
 
 it("declares class with some methods", () => {
   const res = utils.toSourceText(
-    <csharp.Class accessModifier="public" name="TestClass">
+    <csharp.ClassDeclaration public name="TestClass">
       <core.List>
-        <csharp.ClassMethod accessModifier="public" name="MethodOne" />
-        <csharp.ClassMethod
-          accessModifier="private"
-          methodModifier="virtual"
-          name="MethodTwo"
-        />
+        <csharp.ClassMethod public name="MethodOne" />
+        <csharp.ClassMethod private virtual name="MethodTwo" />
       </core.List>
-    </csharp.Class>,
+    </csharp.ClassDeclaration>,
   );
 
   expect(res).toBe(coretest.d`
@@ -73,39 +91,6 @@ it("declares class with some methods", () => {
   `);
 });
 
-it("declares class with params and return type", () => {
-  const params = [
-    {
-      name: "IntParam",
-      type: "int",
-    },
-    {
-      name: "StringParam",
-      type: "string",
-    },
-  ];
-  const res = utils.toSourceText(
-    <csharp.Class accessModifier="public" name="TestClass">
-      <csharp.ClassMethod
-        accessModifier="public"
-        name="MethodOne"
-        parameters={params}
-        returns="string"
-      />
-    </csharp.Class>,
-  );
-
-  expect(res).toBe(coretest.d`
-    namespace TestCode
-    {
-        public class TestClass
-        {
-            public string MethodOne(int intParam, string stringParam) {}
-        }
-    }
-  `);
-});
-
 it("uses refkeys for members, params, and return type", () => {
   const inputTypeRefkey = core.refkey();
   const testResultTypeRefkey = core.refkey();
@@ -126,8 +111,8 @@ it("uses refkeys for members, params, and return type", () => {
     <core.Output namePolicy={csharp.createCSharpNamePolicy()}>
       <csharp.Namespace name="TestCode">
         <csharp.SourceFile path="Test.cs">
-          <csharp.Enum
-            accessModifier="public"
+          <csharp.EnumDeclaration
+            public
             name="TestEnum"
             refkey={enumTypeRefkey}
           >
@@ -135,37 +120,37 @@ it("uses refkeys for members, params, and return type", () => {
               <csharp.EnumMember name="One" />
               <csharp.EnumMember name="Two" />
             </core.List>
-          </csharp.Enum>
+          </csharp.EnumDeclaration>
           <hbr />
-          <csharp.Class
-            accessModifier="public"
+          <csharp.ClassDeclaration
+            public
             name="TestInput"
             refkey={inputTypeRefkey}
           />
           <hbr />
-          <csharp.Class
-            accessModifier="public"
+          <csharp.ClassDeclaration
+            public
             name="TestResult"
             refkey={testResultTypeRefkey}
           />
           <hbr />
-          <csharp.Class accessModifier="public" name="TestClass">
+          <csharp.ClassDeclaration public name="TestClass">
             <csharp.ClassMember
-              accessModifier="private"
+              private
               name="MemberOne"
               type={enumTypeRefkey}
             />
             ;
             <hbr />
             <csharp.ClassMethod
-              accessModifier="public"
+              public
               name="MethodOne"
               parameters={params}
               returns={testResultTypeRefkey}
             >
               return new {testResultTypeRefkey}();
             </csharp.ClassMethod>
-          </csharp.Class>
+          </csharp.ClassDeclaration>
         </csharp.SourceFile>
       </csharp.Namespace>
     </core.Output>,
@@ -200,24 +185,15 @@ it("declares class with generic parameters", () => {
   };
 
   const res = utils.toSourceText(
-    <csharp.Class
-      accessModifier="public"
+    <csharp.ClassDeclaration
+      public
       name="TestClass"
       typeParameters={typeParameters}
     >
-      <csharp.ClassMember
-        accessModifier="public"
-        name="memberOne"
-        type={typeParameters.T}
-      />
+      <csharp.ClassMember public name="memberOne" type={typeParameters.T} />
       ;<hbr />
-      <csharp.ClassMember
-        accessModifier="private"
-        name="memberTwo"
-        type={typeParameters.U}
-      />
-      ;
-    </csharp.Class>,
+      <csharp.ClassMember private name="memberTwo" type={typeParameters.U} />;
+    </csharp.ClassDeclaration>,
   );
 
   expect(res).toBe(coretest.d`
@@ -234,10 +210,10 @@ it("declares class with generic parameters", () => {
 
 it("declares class with invalid members", () => {
   const decl = (
-    <csharp.Class accessModifier="public" name="TestClass">
+    <csharp.ClassDeclaration public name="TestClass">
       <csharp.EnumMember name="One" />,<hbr />
       <csharp.EnumMember name="Two" />
-    </csharp.Class>
+    </csharp.ClassDeclaration>
   );
 
   expect(() => utils.toSourceText(decl)).toThrow(
@@ -247,9 +223,9 @@ it("declares class with invalid members", () => {
 
 it("declares class with constructor", () => {
   const res = utils.toSourceText(
-    <csharp.Class accessModifier="public" name="TestClass">
-      <csharp.ClassConstructor accessModifier="public" />
-    </csharp.Class>,
+    <csharp.ClassDeclaration public name="TestClass">
+      <csharp.ClassConstructor public />
+    </csharp.ClassDeclaration>,
   );
 
   expect(res).toBe(coretest.d`
@@ -283,26 +259,26 @@ it("declares class with constructor params and assigns values to fields", () =>
   ];
 
   const res = utils.toSourceText(
-    <csharp.Class accessModifier="public" name="TestClass">
+    <csharp.ClassDeclaration public name="TestClass">
       <csharp.ClassMember
-        accessModifier="private"
+        private
         name="name"
         type="string"
         refkey={thisNameRefkey}
       />
       ;<hbr />
       <csharp.ClassMember
-        accessModifier="private"
+        private
         name="size"
         type="int"
         refkey={thisSizeRefkey}
       />
       ;<hbr />
-      <csharp.ClassConstructor accessModifier="public" parameters={ctorParams}>
+      <csharp.ClassConstructor public parameters={ctorParams}>
         {thisNameRefkey} = {paramNameRefkey};<hbr />
         {thisSizeRefkey} = {paramSizeRefkey};
       </csharp.ClassConstructor>
-    </csharp.Class>,
+    </csharp.ClassDeclaration>,
   );
 
   // TODO: assignments to members should have this. prefix
@@ -323,3 +299,31 @@ it("declares class with constructor params and assigns values to fields", () =>
     }
   `);
 });
+
+it("specify doc comment", () => {
+  expect(
+    <utils.TestNamespace>
+      <ClassDeclaration name="Test" doc="This is a test" />
+    </utils.TestNamespace>,
+  ).toRenderTo(`
+    /// This is a test
+    class Test;
+  `);
+});
+
+it("supports class member doc comments", () => {
+  expect(
+    <utils.TestNamespace>
+      <ClassDeclaration name="Test" doc="This is a test">
+        <ClassMember name="Member" public type="int" doc="This is a member" />
+      </ClassDeclaration>
+    </utils.TestNamespace>,
+  ).toRenderTo(`
+    /// This is a test
+    class Test
+    {
+      /// This is a member
+      public int Member
+    }
+  `);
+});

package/test/class-method.test.tsx

@@ -0,0 +1,147 @@
+import { Children } from "@alloy-js/core/jsx-runtime";
+import { describe, expect, it } from "vitest";
+import { ClassDeclaration, ClassMethod } from "../src/index.js";
+import { TestNamespace } from "./utils.jsx";
+
+const Wrapper = (props: { children: Children }) => (
+  <TestNamespace>
+    <ClassDeclaration public name="TestClass">
+      {props.children}
+    </ClassDeclaration>
+  </TestNamespace>
+);
+
+describe("modifiers", () => {
+  describe("access modifiers", () => {
+    it.each(["public", "private", "protected", "internal"] as const)(
+      "%s",
+      (accessModifier) => {
+        expect(
+          <Wrapper>
+            <ClassMethod {...{ [accessModifier]: true }} name="MethodOne" />
+          </Wrapper>,
+        ).toRenderTo(`
+        public class TestClass
+        {
+          ${accessModifier} void MethodOne() {}
+        }
+      `);
+      },
+    );
+  });
+
+  describe("method modifiers", () => {
+    it.each(["static", "virtual", "sealed"] as const)(
+      "%s",
+      (methodModifier) => {
+        expect(
+          <Wrapper>
+            <ClassMethod {...{ [methodModifier]: true }} name="MethodOne" />
+          </Wrapper>,
+        ).toRenderTo(`
+        public class TestClass
+        {
+          ${methodModifier} void MethodOne() {}
+        }
+      `);
+      },
+    );
+
+    it("abstract exclude body", () => {
+      expect(
+        <Wrapper>
+          <ClassMethod abstract name="MethodOne" />
+        </Wrapper>,
+      ).toRenderTo(`
+        public class TestClass
+        {
+          abstract void MethodOne();
+        }
+      `);
+    });
+  });
+
+  it("mark method async", () => {
+    expect(
+      <Wrapper>
+        <ClassMethod async name="MethodOne" />
+      </Wrapper>,
+    ).toRenderTo(`
+        public class TestClass
+        {
+          async Task MethodOne() {}
+        }
+      `);
+  });
+
+  it("combine modifiers", () => {
+    expect(
+      <Wrapper>
+        <ClassMethod async returns="Task" public abstract name="MethodOne" />
+      </Wrapper>,
+    ).toRenderTo(`
+        public class TestClass
+        {
+          public abstract async Task MethodOne();
+        }
+      `);
+  });
+});
+
+it("applies PascalCase naming policy", () => {
+  expect(
+    <Wrapper>
+      <ClassMethod name="method_one" />
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+      void MethodOne() {}
+    }
+`);
+});
+it("defines params and return type", () => {
+  const params = [
+    {
+      name: "intParam",
+      type: "int",
+    },
+    {
+      name: "stringParam",
+      type: "string",
+    },
+  ];
+  const res = (
+    <Wrapper>
+      <ClassMethod
+        public
+        name="MethodOne"
+        parameters={params}
+        returns="string"
+      />
+    </Wrapper>
+  );
+
+  expect(res).toRenderTo(`
+    public class TestClass
+    {
+      public string MethodOne(int intParam, string stringParam) {}
+    }
+  `);
+});
+
+it("specify doc comment", () => {
+  expect(
+    <TestNamespace>
+      <ClassDeclaration name="Test">
+        <ClassMethod name="Method" doc="This is a test" />
+      </ClassDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+    class Test
+    {
+      /// This is a test
+      void Method() {}
+    }
+  `);
+});

package/test/enum.test.tsx

@@ -6,7 +6,7 @@ import * as utils from "./utils.js";
 
 it("declares enum with no members", () => {
   const res = utils.toSourceText(
-    <csharp.Enum accessModifier="public" name="TestEnum" />,
+    <csharp.EnumDeclaration public name="TestEnum" />,
   );
 
   expect(res).toBe(coretest.d`
@@ -19,10 +19,10 @@ it("declares enum with no members", () => {
 
 it("declares enum with members", () => {
   const res = utils.toSourceText(
-    <csharp.Enum accessModifier="public" name="TestEnum">
+    <csharp.EnumDeclaration public name="TestEnum">
       <csharp.EnumMember name="One" />,<hbr />
       <csharp.EnumMember name="Two" />
-    </csharp.Enum>,
+    </csharp.EnumDeclaration>,
   );
 
   expect(res).toBe(coretest.d`
@@ -39,10 +39,10 @@ it("declares enum with members", () => {
 
 it("applies naming policy to enum and members", () => {
   const res = utils.toSourceText(
-    <csharp.Enum accessModifier="public" name="testEnum">
+    <csharp.EnumDeclaration public name="testEnum">
       <csharp.EnumMember name="one" />,<hbr />
       <csharp.EnumMember name="two" />
-    </csharp.Enum>,
+    </csharp.EnumDeclaration>,
   );
 
   expect(res).toBe(coretest.d`
@@ -65,10 +65,10 @@ it("can reference things by refkey", () => {
     <core.Output>
       <csharp.Namespace name="TestCode">
         <csharp.SourceFile path="Test.cs">
-          <csharp.Enum accessModifier="public" name="TestEnum" refkey={enumRK}>
+          <csharp.EnumDeclaration public name="TestEnum" refkey={enumRK}>
             <csharp.EnumMember name="One" />,<hbr />
             <csharp.EnumMember name="Two" refkey={twoRK} />
-          </csharp.Enum>
+          </csharp.EnumDeclaration>
           <hbr />
           {enumRK};<hbr />
           {twoRK};
@@ -99,19 +99,19 @@ it("can reference things by refkey across files", () => {
     <core.Output>
       <csharp.Namespace name="TestCode">
         <csharp.SourceFile path="Test.cs">
-          <csharp.Enum accessModifier="public" name="TestEnum">
+          <csharp.EnumDeclaration public name="TestEnum">
             <csharp.EnumMember name="One" />,<hbr />
             <csharp.EnumMember name="Two" />
-          </csharp.Enum>
+          </csharp.EnumDeclaration>
           <hbr />
           {enumRK};<hbr />
           {barRK};
         </csharp.SourceFile>
         <csharp.SourceFile path="Other.cs">
-          <csharp.Enum accessModifier="public" name="OtherEnum" refkey={enumRK}>
+          <csharp.EnumDeclaration public name="OtherEnum" refkey={enumRK}>
             <csharp.EnumMember name="Foo" />,<hbr />
             <csharp.EnumMember name="Bar" refkey={barRK} />
-          </csharp.Enum>
+          </csharp.EnumDeclaration>
           <hbr />
           {enumRK};<hbr />
           {barRK};

package/test/namespace.test.tsx

@@ -8,18 +8,18 @@ it("defines multiple namespaces and source files with unique content", () => {
     <core.Output>
       <csharp.Namespace name="Namespace1">
         <csharp.SourceFile path="Model1.cs">
-          <csharp.Class accessModifier="public" name="Model1" />
+          <csharp.ClassDeclaration public name="Model1" />
         </csharp.SourceFile>
         <csharp.SourceFile path="Model2.cs">
-          <csharp.Class accessModifier="public" name="Model2" />
+          <csharp.ClassDeclaration public name="Model2" />
         </csharp.SourceFile>
       </csharp.Namespace>
       <csharp.Namespace name="Namespace2">
         <csharp.SourceFile path="Model3.cs">
-          <csharp.Class accessModifier="public" name="Model3" />
+          <csharp.ClassDeclaration public name="Model3" />
         </csharp.SourceFile>
         <csharp.SourceFile path="Model4.cs">
-          <csharp.Class accessModifier="public" name="Model4" />
+          <csharp.ClassDeclaration public name="Model4" />
         </csharp.SourceFile>
       </csharp.Namespace>
     </core.Output>,

package/test/{projectdirectory.test.tsx → project-directory.test.tsx}

@@ -14,10 +14,10 @@ it("defines a project directory file with multiple source files", () => {
       >
         <csharp.Namespace name="TestCode">
           <csharp.SourceFile path="Test1.cs">
-            <csharp.Class accessModifier="public" name="TestClass1" />
+            <csharp.ClassDeclaration public name="TestClass1" />
           </csharp.SourceFile>
           <csharp.SourceFile path="Test2.cs">
-            <csharp.Class accessModifier="public" name="TestClass2" />
+            <csharp.ClassDeclaration public name="TestClass2" />
           </csharp.SourceFile>
         </csharp.Namespace>
       </csharp.ProjectDirectory>
@@ -71,10 +71,10 @@ it("defines a project directory file with multiple source files and a custom TFM
       >
         <csharp.Namespace name="TestCode">
           <csharp.SourceFile path="Test1.cs">
-            <csharp.Class accessModifier="public" name="TestClass1" />
+            <csharp.ClassDeclaration public name="TestClass1" />
           </csharp.SourceFile>
           <csharp.SourceFile path="Test2.cs">
-            <csharp.Class accessModifier="public" name="TestClass2" />
+            <csharp.ClassDeclaration public name="TestClass2" />
           </csharp.SourceFile>
         </csharp.Namespace>
       </csharp.ProjectDirectory>

package/test/sourcefile.test.tsx

@@ -8,10 +8,10 @@ it("defines multiple source files with unique content", () => {
     <core.Output>
       <csharp.Namespace name="TestCode">
         <csharp.SourceFile path="Test1.cs">
-          <csharp.Class accessModifier="public" name="TestClass1" />
+          <csharp.ClassDeclaration public name="TestClass1" />
         </csharp.SourceFile>
         <csharp.SourceFile path="Test2.cs">
-          <csharp.Class accessModifier="public" name="TestClass2" />
+          <csharp.ClassDeclaration public name="TestClass2" />
         </csharp.SourceFile>
       </csharp.Namespace>
     </core.Output>,

package/test/using.test.tsx

@@ -52,34 +52,34 @@ it("adds using statement across namespaces", () => {
     <core.Output namePolicy={csharp.createCSharpNamePolicy()}>
       <csharp.Namespace name="Models">
         <csharp.SourceFile path="Models.cs">
-          <csharp.Class
-            accessModifier="public"
+          <csharp.ClassDeclaration
+            public
             name="Input"
             refkey={inputTypeRefkey}
           />
           <hbr />
-          <csharp.Class
-            accessModifier="public"
+          <csharp.ClassDeclaration
+            public
             name="Output"
             refkey={outputTypeRefkey}
           />
           <hbr />
-          <csharp.Enum accessModifier="public" name="TestEnum">
+          <csharp.EnumDeclaration public name="TestEnum">
             <csharp.EnumMember name="One" />,<hbr />
             <csharp.EnumMember name="Two" refkey={twoValRefkey} />
-          </csharp.Enum>
+          </csharp.EnumDeclaration>
         </csharp.SourceFile>
       </csharp.Namespace>
       <csharp.Namespace name="Client">
         <csharp.SourceFile path="Client.cs" using={["System"]}>
-          <csharp.Class accessModifier="public" name="Client">
+          <csharp.ClassDeclaration public name="Client">
             <csharp.ClassMethod
-              accessModifier="public"
+              public
               name="MethodOne"
               parameters={params}
               returns={outputTypeRefkey}
             />
-          </csharp.Class>
+          </csharp.ClassDeclaration>
           <hbr />
           {twoValRefkey};
         </csharp.SourceFile>

package/test/utils.tsx

@@ -3,6 +3,15 @@ import * as coretest from "@alloy-js/core/testing";
 import { expect } from "vitest";
 import * as csharp from "../src/index.js";
 
+export function TestNamespace(props: {
+  children: core.Children;
+}): core.Children {
+  return (
+    <core.Output namePolicy={csharp.createCSharpNamePolicy()}>
+      <csharp.Namespace name="TestCode">{props.children}</csharp.Namespace>
+    </core.Output>
+  );
+}
 export function toSourceText(c: core.Children): string {
   const res = core.render(
     <core.Output namePolicy={csharp.createCSharpNamePolicy()}>

package/test/vitest.setup.ts

@@ -0,0 +1 @@
+import "@alloy-js/core/testing";

package/tsconfig.json

@@ -3,7 +3,8 @@
   "compilerOptions": {
     "emitDeclarationOnly": true,
     "declaration": true,
-    "outDir": "dist"
+    "outDir": "dist",
+    "types": ["@alloy-js/core/testing/matchers"]
   },
   "references": [{ "path": "../core" }],
   "include": ["src/**/*.ts", "src/**/*.tsx", "test/**/*.ts", "test/**/*.tsx"],