@alloy-js/csharp 0.18.0-dev.2 → 0.18.0-dev.21

package/test/class-declaration.test.tsx

@@ -0,0 +1,418 @@
+import * as core from "@alloy-js/core";
+import { List, refkey } from "@alloy-js/core";
+import * as coretest from "@alloy-js/core/testing";
+import { describe, expect, it } from "vitest";
+import { TypeParameterProps } from "../src/components/type-parameters/type-parameter.jsx";
+import * as csharp from "../src/index.js";
+import {
+  ClassDeclaration,
+  ClassMember,
+  Property,
+  SourceFile,
+} from "../src/index.js";
+import * as utils from "./utils.jsx";
+
+it("declares class with no members", () => {
+  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;
+    `);
+  });
+});
+
+describe("base", () => {
+  it("define base class", () => {
+    expect(
+      <utils.TestNamespace>
+        <csharp.ClassDeclaration name="TestClass" baseType="Foo" />
+      </utils.TestNamespace>,
+    ).toRenderTo(`
+        class TestClass : Foo;
+    `);
+  });
+
+  it("define multiple interface types", () => {
+    expect(
+      <utils.TestNamespace>
+        <csharp.ClassDeclaration
+          name="TestClass"
+          interfaceTypes={["Foo", "Bar"]}
+        />
+      </utils.TestNamespace>,
+    ).toRenderTo(`
+        class TestClass : Foo, Bar;
+    `);
+  });
+
+  it("define base class and multiple interface types", () => {
+    expect(
+      <utils.TestNamespace>
+        <csharp.ClassDeclaration
+          name="TestClass"
+          baseType="BaseClass"
+          interfaceTypes={["Foo", "Bar"]}
+        />
+      </utils.TestNamespace>,
+    ).toRenderTo(`
+        class TestClass : BaseClass, Foo, Bar;
+    `);
+  });
+});
+
+it("declares class with some members", () => {
+  const res = utils.toSourceText(
+    <csharp.ClassDeclaration public name="TestClass">
+      <core.StatementList>
+        <csharp.ClassMember public name="MemberOne" type="string" />
+        <csharp.ClassMember private name="MemberTwo" type="int" />
+      </core.StatementList>
+    </csharp.ClassDeclaration>,
+  );
+
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+        public class TestClass
+        {
+            public string MemberOne;
+            private int memberTwo;
+        }
+    }
+  `);
+});
+
+it("declares class with some methods", () => {
+  const res = utils.toSourceText(
+    <csharp.ClassDeclaration public name="TestClass">
+      <core.List>
+        <csharp.ClassMethod public name="MethodOne" />
+        <csharp.ClassMethod private virtual name="MethodTwo" />
+      </core.List>
+    </csharp.ClassDeclaration>,
+  );
+
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+        public class TestClass
+        {
+            public void MethodOne() {}
+            private virtual void MethodTwo() {}
+        }
+    }
+  `);
+});
+
+it("uses refkeys for members, params, and return type", () => {
+  const inputTypeRefkey = core.refkey();
+  const testResultTypeRefkey = core.refkey();
+  const enumTypeRefkey = core.refkey();
+
+  const params = [
+    {
+      name: "IntParam",
+      type: "int",
+    },
+    {
+      name: "BodyParam",
+      type: inputTypeRefkey,
+    },
+  ];
+
+  const res = core.render(
+    <core.Output namePolicy={csharp.createCSharpNamePolicy()}>
+      <csharp.Namespace name="TestCode">
+        <csharp.SourceFile path="Test.cs">
+          <csharp.EnumDeclaration
+            public
+            name="TestEnum"
+            refkey={enumTypeRefkey}
+          >
+            <core.List comma hardline>
+              <csharp.EnumMember name="One" />
+              <csharp.EnumMember name="Two" />
+            </core.List>
+          </csharp.EnumDeclaration>
+          <hbr />
+          <csharp.ClassDeclaration
+            public
+            name="TestInput"
+            refkey={inputTypeRefkey}
+          />
+          <hbr />
+          <csharp.ClassDeclaration
+            public
+            name="TestResult"
+            refkey={testResultTypeRefkey}
+          />
+          <hbr />
+          <csharp.ClassDeclaration public name="TestClass">
+            <csharp.ClassMember
+              private
+              name="MemberOne"
+              type={enumTypeRefkey}
+            />
+            ;
+            <hbr />
+            <csharp.ClassMethod
+              public
+              name="MethodOne"
+              parameters={params}
+              returns={testResultTypeRefkey}
+            >
+              return new {testResultTypeRefkey}();
+            </csharp.ClassMethod>
+          </csharp.ClassDeclaration>
+        </csharp.SourceFile>
+      </csharp.Namespace>
+    </core.Output>,
+  );
+
+  expect(res.contents[0].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+        public enum TestEnum
+        {
+            One,
+            Two
+        }
+        public class TestInput;
+        public class TestResult;
+        public class TestClass
+        {
+            private TestEnum memberOne;
+            public TestResult MethodOne(int intParam, TestInput bodyParam)
+            {
+                return new TestResult();
+            }
+        }
+    }
+  `);
+});
+
+describe("with type parameters", () => {
+  it("reference parameters", () => {
+    const typeParameters: TypeParameterProps[] = [
+      {
+        name: "T",
+        refkey: refkey(),
+      },
+      {
+        name: "U",
+        refkey: refkey(),
+      },
+    ];
+
+    expect(
+      <utils.TestNamespace>
+        <SourceFile path="Test.cs">
+          <ClassDeclaration
+            public
+            name="TestClass"
+            typeParameters={typeParameters}
+          >
+            <List>
+              <Property name="PropA" type={typeParameters[0].refkey} get set />
+              <Property name="PropB" type={typeParameters[1].refkey} get set />
+            </List>
+          </ClassDeclaration>
+        </SourceFile>
+      </utils.TestNamespace>,
+    ).toRenderTo(`
+      namespace TestCode
+      {
+        public class TestClass<T, U>
+        {
+          T PropA { get; set; }
+          U PropB { get; set; }
+        }
+      }
+    `);
+  });
+
+  it("defines with constraints", () => {
+    const typeParameters: TypeParameterProps[] = [
+      {
+        name: "T",
+        constraints: "IFoo",
+      },
+      {
+        name: "U",
+        constraints: "IBar",
+      },
+    ];
+
+    expect(
+      <utils.TestNamespace>
+        <ClassDeclaration
+          public
+          name="TestClass"
+          typeParameters={typeParameters}
+        >
+          // Body
+        </ClassDeclaration>
+      </utils.TestNamespace>,
+    ).toRenderTo(`
+      public class TestClass<T, U>
+        where T : IFoo
+        where U : IBar
+      {
+        // Body
+      }
+    `);
+  });
+});
+
+it("declares class with invalid members", () => {
+  const decl = (
+    <csharp.ClassDeclaration public name="TestClass">
+      <csharp.EnumMember name="One" />,<hbr />
+      <csharp.EnumMember name="Two" />
+    </csharp.ClassDeclaration>
+  );
+
+  expect(() => utils.toSourceText(decl)).toThrow(
+    "can't define an enum member outside of an enum-decl scope",
+  );
+});
+
+it("declares class with constructor", () => {
+  const res = utils.toSourceText(
+    <csharp.ClassDeclaration public name="TestClass">
+      <csharp.ClassConstructor public />
+    </csharp.ClassDeclaration>,
+  );
+
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+        public class TestClass
+        {
+            public TestClass() {}
+        }
+    }
+  `);
+});
+
+it("declares class with constructor params and assigns values to fields", () => {
+  const thisNameRefkey = core.refkey();
+  const thisSizeRefkey = core.refkey();
+  const paramNameRefkey = core.refkey();
+  const paramSizeRefkey = core.refkey();
+
+  const ctorParams = [
+    {
+      name: "name",
+      type: "string",
+      refkey: paramNameRefkey,
+    },
+    {
+      name: "size",
+      type: "int",
+      refkey: paramSizeRefkey,
+    },
+  ];
+
+  const res = utils.toSourceText(
+    <csharp.ClassDeclaration public name="TestClass">
+      <csharp.ClassMember
+        private
+        name="name"
+        type="string"
+        refkey={thisNameRefkey}
+      />
+      ;<hbr />
+      <csharp.ClassMember
+        private
+        name="size"
+        type="int"
+        refkey={thisSizeRefkey}
+      />
+      ;<hbr />
+      <csharp.ClassConstructor public parameters={ctorParams}>
+        {thisNameRefkey} = {paramNameRefkey};<hbr />
+        {thisSizeRefkey} = {paramSizeRefkey};
+      </csharp.ClassConstructor>
+    </csharp.ClassDeclaration>,
+  );
+
+  // TODO: assignments to members should have this. prefix
+  // e.g. this.name = name;
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+        public class TestClass
+        {
+            private string name;
+            private int size;
+            public TestClass(string name, int size)
+            {
+                name = name;
+                size = size;
+            }
+        }
+    }
+  `);
+});
+
+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

@@ -1,13 +1,13 @@
 import { Children } from "@alloy-js/core/jsx-runtime";
 import { describe, expect, it } from "vitest";
-import { Class, ClassMethod } from "../src/index.js";
+import { ClassDeclaration, ClassMethod } from "../src/index.js";
 import { TestNamespace } from "./utils.jsx";
 
 const Wrapper = (props: { children: Children }) => (
   <TestNamespace>
-    <Class accessModifier="public" name="TestClass">
+    <ClassDeclaration public name="TestClass">
       {props.children}
-    </Class>
+    </ClassDeclaration>
   </TestNamespace>
 );
 
@@ -18,7 +18,7 @@ describe("modifiers", () => {
       (accessModifier) => {
         expect(
           <Wrapper>
-            <ClassMethod accessModifier={accessModifier} name="MethodOne" />
+            <ClassMethod {...{ [accessModifier]: true }} name="MethodOne" />
           </Wrapper>,
         ).toRenderTo(`
         public class TestClass
@@ -36,7 +36,7 @@ describe("modifiers", () => {
       (methodModifier) => {
         expect(
           <Wrapper>
-            <ClassMethod methodModifier={methodModifier} name="MethodOne" />
+            <ClassMethod {...{ [methodModifier]: true }} name="MethodOne" />
           </Wrapper>,
         ).toRenderTo(`
         public class TestClass
@@ -50,7 +50,7 @@ describe("modifiers", () => {
     it("abstract exclude body", () => {
       expect(
         <Wrapper>
-          <ClassMethod methodModifier="abstract" name="MethodOne" />
+          <ClassMethod abstract name="MethodOne" />
         </Wrapper>,
       ).toRenderTo(`
         public class TestClass
@@ -77,13 +77,7 @@ describe("modifiers", () => {
   it("combine modifiers", () => {
     expect(
       <Wrapper>
-        <ClassMethod
-          async
-          returns="Task"
-          accessModifier="public"
-          methodModifier="abstract"
-          name="MethodOne"
-        />
+        <ClassMethod async returns="Task" public abstract name="MethodOne" />
       </Wrapper>,
     ).toRenderTo(`
         public class TestClass
@@ -120,7 +114,7 @@ it("defines params and return type", () => {
   const res = (
     <Wrapper>
       <ClassMethod
-        accessModifier="public"
+        public
         name="MethodOne"
         parameters={params}
         returns="string"
@@ -135,3 +129,19 @@ it("defines params and return type", () => {
     }
   `);
 });
+
+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/vitest.setup.ts

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