@alloy-js/csharp 0.20.0-dev.0 → 0.20.0-dev.10

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

@@ -0,0 +1,484 @@
+import { Constructor } from "#components/constructor/constructor.jsx";
+import { EnumDeclaration } from "#components/enum/declaration.jsx";
+import { EnumMember } from "#components/enum/member.jsx";
+import {
+  Children,
+  code,
+  createNamePolicy,
+  List,
+  NamePolicyContext,
+  Output,
+  refkey,
+} from "@alloy-js/core";
+import * as coretest from "@alloy-js/core/testing";
+import { describe, expect, it } from "vitest";
+import { TestNamespace, toSourceText } from "../../../test/utils.jsx";
+import { createCSharpNamePolicy } from "../../name-policy.js";
+import { Attribute } from "../attributes/attributes.jsx";
+import { Field } from "../field/field.jsx";
+import { Method } from "../method/method.jsx";
+import { Property } from "../property/property.jsx";
+import { SourceFile } from "../source-file/source-file.jsx";
+import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
+import { ClassDeclaration } from "./declaration.jsx";
+
+function Wrapper({ children }: { children: Children }) {
+  return <TestNamespace>{children}</TestNamespace>;
+}
+
+it("declares class with no members", () => {
+  expect(
+    <TestNamespace>
+      <ClassDeclaration name="TestClass" />
+    </TestNamespace>,
+  ).toRenderTo(`
+      class TestClass;
+  `);
+});
+
+describe("modifiers", () => {
+  it.each(["public", "private"])("%s", (mod) => {
+    expect(
+      <TestNamespace>
+        <ClassDeclaration {...{ [mod]: true }} name="TestClass" />
+      </TestNamespace>,
+    ).toRenderTo(`
+        ${mod} class TestClass;
+    `);
+  });
+
+  it.each(["partial", "abstract", "static", "sealed"])("%s", (mod) => {
+    expect(
+      <TestNamespace>
+        <ClassDeclaration {...{ [mod]: true }} name="TestClass" />
+      </TestNamespace>,
+    ).toRenderTo(`
+        ${mod} class TestClass;
+    `);
+  });
+
+  it("combines modifiers", () => {
+    expect(
+      <TestNamespace>
+        <ClassDeclaration public abstract partial name="TestClass" />
+      </TestNamespace>,
+    ).toRenderTo(`
+        public abstract partial class TestClass;
+    `);
+  });
+
+  it("places visibility, attributes, and modifiers in the correct order", () => {
+    expect(
+      <TestNamespace>
+        <ClassDeclaration
+          partial
+          public
+          abstract
+          sealed
+          name="TestClass"
+          attributes={[<Attribute name="Test" />]}
+        />
+      </TestNamespace>,
+    ).toRenderTo(`
+        [Test]
+        public abstract sealed partial class TestClass;
+    `);
+  });
+});
+
+describe("base", () => {
+  it("define base class", () => {
+    expect(
+      <TestNamespace>
+        <ClassDeclaration name="TestClass" baseType="Foo" />
+      </TestNamespace>,
+    ).toRenderTo(`
+        class TestClass : Foo;
+    `);
+  });
+
+  it("define multiple interface types", () => {
+    expect(
+      <TestNamespace>
+        <ClassDeclaration name="TestClass" interfaceTypes={["Foo", "Bar"]} />
+      </TestNamespace>,
+    ).toRenderTo(`
+        class TestClass : Foo, Bar;
+    `);
+  });
+
+  it("define base class and multiple interface types", () => {
+    expect(
+      <TestNamespace>
+        <ClassDeclaration
+          name="TestClass"
+          baseType="BaseClass"
+          interfaceTypes={["Foo", "Bar"]}
+        />
+      </TestNamespace>,
+    ).toRenderTo(`
+        class TestClass : BaseClass, Foo, Bar;
+    `);
+  });
+});
+
+it("declares class with some members", () => {
+  const tree = (
+    <TestNamespace>
+      <ClassDeclaration public name="TestClass">
+        <List>
+          <Field public name="MemberOne" type="string" />
+          <Field public name="MemberTwo" type="int" />
+        </List>
+      </ClassDeclaration>
+    </TestNamespace>
+  );
+
+  expect(tree).toRenderTo(coretest.d`
+    public class TestClass
+    {
+        public string MemberOne;
+        public int MemberTwo;
+    }
+  `);
+});
+
+it("declares class with some methods", () => {
+  const tree = (
+    <TestNamespace>
+      <ClassDeclaration public name="TestClass">
+        <List>
+          <Method public name="MethodOne" />
+          <Method private virtual name="MethodTwo" />
+        </List>
+      </ClassDeclaration>
+    </TestNamespace>
+  );
+
+  expect(tree).toRenderTo(coretest.d`
+    public class TestClass
+    {
+        public void MethodOne() {}
+        private virtual void MethodTwo() {}
+    }
+  `);
+});
+
+it("uses refkeys for members, params, and return type", () => {
+  const inputTypeRefkey = refkey();
+  const testResultTypeRefkey = refkey();
+  const enumTypeRefkey = refkey();
+
+  const params = [
+    {
+      name: "IntParam",
+      type: "int",
+    },
+    {
+      name: "BodyParam",
+      type: inputTypeRefkey,
+    },
+  ];
+
+  expect(
+    <Output namePolicy={createCSharpNamePolicy()}>
+      <SourceFile path="Test.cs">
+        <EnumDeclaration public name="TestEnum" refkey={enumTypeRefkey}>
+          <List comma hardline>
+            <EnumMember name="One" />
+            <EnumMember name="Two" />
+          </List>
+        </EnumDeclaration>
+        <hbr />
+        <ClassDeclaration public name="TestInput" refkey={inputTypeRefkey} />
+        <hbr />
+        <ClassDeclaration
+          public
+          name="TestResult"
+          refkey={testResultTypeRefkey}
+        />
+        <hbr />
+        <ClassDeclaration public name="TestClass">
+          <Field private name="MemberOne" type={enumTypeRefkey} />
+          <hbr />
+          <Method
+            public
+            name="MethodOne"
+            parameters={params}
+            returns={testResultTypeRefkey}
+          >
+            return new {testResultTypeRefkey}();
+          </Method>
+        </ClassDeclaration>
+      </SourceFile>
+    </Output>,
+  ).toRenderTo(`
+    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(
+      <TestNamespace>
+        <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>
+      </TestNamespace>,
+    ).toRenderTo(`
+      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(
+      <TestNamespace>
+        <ClassDeclaration
+          public
+          name="TestClass"
+          typeParameters={typeParameters}
+        >
+          // Body
+        </ClassDeclaration>
+      </TestNamespace>,
+    ).toRenderTo(`
+      public class TestClass<T, U>
+          where T : IFoo
+          where U : IBar
+      {
+          // Body
+      }
+    `);
+  });
+});
+
+it("declares class with invalid members", () => {
+  const decl = (
+    <ClassDeclaration public name="TestClass">
+      <EnumMember name="One" />,<hbr />
+      <EnumMember name="Two" />
+    </ClassDeclaration>
+  );
+
+  expect(() => toSourceText(decl)).toThrow(
+    "EnumMember must be used within an EnumDeclaration.",
+  );
+});
+
+describe("constructor", () => {
+  it("declares with constructor", () => {
+    const tree = (
+      <TestNamespace>
+        <ClassDeclaration public name="TestClass">
+          <Constructor public />
+        </ClassDeclaration>
+      </TestNamespace>
+    );
+
+    expect(tree).toRenderTo(coretest.d`
+    public class TestClass
+    {
+        public TestClass() {}
+    }
+  `);
+  });
+
+  it("declares with constructor params and assigns values to fields", () => {
+    const thisNameRefkey = refkey();
+    const thisSizeRefkey = refkey();
+    const paramNameRefkey = refkey();
+    const paramSizeRefkey = refkey();
+
+    const ctorParams = [
+      {
+        name: "name",
+        type: "string",
+        refkey: paramNameRefkey,
+      },
+      {
+        name: "size",
+        type: "int",
+        refkey: paramSizeRefkey,
+      },
+    ];
+
+    const tree = (
+      <TestNamespace>
+        <ClassDeclaration public name="TestClass">
+          <Field private name="name" type="string" refkey={thisNameRefkey} />
+          <hbr />
+          <Field private name="size" type="int" refkey={thisSizeRefkey} />
+          <hbr />
+          <Constructor public parameters={ctorParams}>
+            {thisNameRefkey} = {paramNameRefkey};<hbr />
+            {thisSizeRefkey} = {paramSizeRefkey};
+          </Constructor>
+        </ClassDeclaration>
+      </TestNamespace>
+    );
+
+    // TODO: assignments to members should have this. prefix
+    // e.g. this.name = name;
+    expect(tree).toRenderTo(coretest.d`
+    public class TestClass
+    {
+        private string _name;
+        private int _size;
+        public TestClass(string name, int size)
+        {
+            _name = name;
+            _size = size;
+        }
+    }
+  `);
+  });
+
+  it("declares primary constructor with args", () => {
+    const paramNameRefkey = refkey();
+    const paramSizeRefkey = refkey();
+
+    const ctorParams = [
+      {
+        name: "name",
+        type: "string",
+        refkey: paramNameRefkey,
+      },
+      {
+        name: "size",
+        type: "int",
+        refkey: paramSizeRefkey,
+      },
+    ];
+
+    expect(
+      <Wrapper>
+        <ClassDeclaration
+          public
+          name="TestClass"
+          primaryConstructor={ctorParams}
+        >
+          <Property
+            name="PrettyName"
+            type="string"
+            get
+            initializer={code`$"{${paramNameRefkey}} {${paramSizeRefkey}}"`}
+          />
+        </ClassDeclaration>
+      </Wrapper>,
+    ).toRenderTo(`
+      public class TestClass(string name, int size)
+      {
+          string PrettyName { get; } = $"{name} {size}";
+      }
+  `);
+  });
+
+  it("primary constructor params conflict with method", () => {
+    const ctorParams = [{ name: "name", type: "string" }];
+
+    expect(
+      <Wrapper>
+        <NamePolicyContext.Provider value={createNamePolicy((x) => x)}>
+          <ClassDeclaration
+            public
+            name="TestClass"
+            primaryConstructor={ctorParams}
+          >
+            <Field name="name" type="string" />
+          </ClassDeclaration>
+        </NamePolicyContext.Provider>
+      </Wrapper>,
+    ).toRenderTo(`
+      public class TestClass(string name)
+      {
+          string name_2;
+      }
+  `);
+  });
+});
+
+it("specify doc comment", () => {
+  expect(
+    <TestNamespace>
+      <ClassDeclaration name="Test" doc="This is a test" />
+    </TestNamespace>,
+  ).toRenderTo(`
+    /// This is a test
+    class Test;
+  `);
+});
+
+it("supports class member doc comments", () => {
+  expect(
+    <TestNamespace>
+      <ClassDeclaration name="Test" doc="This is a test">
+        <Field name="Member" public type="int" doc="This is a member" />
+      </ClassDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+    /// This is a test
+    class Test
+    {
+        /// This is a member
+        public int Member;
+    }
+  `);
+});
+
+it("specify attributes", () => {
+  expect(
+    <TestNamespace>
+      <ClassDeclaration name="Test" attributes={[<Attribute name="Test" />]} />
+    </TestNamespace>,
+  ).toRenderTo(`
+    [Test]
+    class Test;
+  `);
+});

package/src/components/{ClassDeclaration.tsx → class/declaration.tsx}

@@ -1,20 +1,28 @@
-import * as core from "@alloy-js/core";
-import { join } from "@alloy-js/core";
+import {
+  Block,
+  Children,
+  Declaration,
+  DeclarationProps,
+  join,
+  Name,
+  Namekey,
+  Refkey,
+  Scope,
+} from "@alloy-js/core";
 import {
   AccessModifiers,
   computeModifiersPrefix,
   getAccessModifier,
   makeModifiers,
-} from "../modifiers.js";
-import { useCSharpNamePolicy } from "../name-policy.js";
-import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
-import { CSharpMemberScope } from "../symbols/scopes.js";
-import { AttributeList, AttributesProp } from "./attributes/attributes.jsx";
-import { DocWhen } from "./doc/comment.jsx";
-import { Name } from "./Name.jsx";
-import { TypeParameterConstraints } from "./type-parameters/type-parameter-constraints.jsx";
-import { TypeParameterProps } from "./type-parameters/type-parameter.jsx";
-import { TypeParameters } from "./type-parameters/type-parameters.jsx";
+} from "../../modifiers.js";
+import { createClassScope } from "../../scopes/factories.js";
+import { createNamedTypeSymbol } from "../../symbols/factories.js";
+import { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
+import { DocWhen } from "../doc/comment.jsx";
+import { ParameterProps, Parameters } from "../parameters/parameters.jsx";
+import { TypeParameterConstraints } from "../type-parameters/type-parameter-constraints.jsx";
+import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
+import { TypeParameters } from "../type-parameters/type-parameters.jsx";
 
 export interface ClassModifiers {
   readonly abstract?: boolean;
@@ -25,20 +33,20 @@ export interface ClassModifiers {
 
 const getClassModifiers = makeModifiers<ClassModifiers>([
   "abstract",
-  "partial",
   "sealed",
   "static",
+  "partial",
 ]);
 
 // properties for creating a class
 export interface ClassDeclarationProps
-  extends Omit<core.DeclarationProps, "nameKind">,
+  extends Omit<DeclarationProps, "nameKind">,
     AccessModifiers,
     ClassModifiers {
-  name: string;
+  name: string | Namekey;
   /** Doc comment */
-  doc?: core.Children;
-  refkey?: core.Refkey;
+  doc?: Children;
+  refkey?: Refkey;
 
   /**
    * Type parameters for the class
@@ -55,10 +63,10 @@ export interface ClassDeclarationProps
   typeParameters?: (string | TypeParameterProps)[];
 
   /** Base class that this class extends */
-  baseType?: core.Children;
+  baseType?: Children;
 
   /** Interfaces this class implements */
-  interfaceTypes?: core.Children[];
+  interfaceTypes?: Children[];
 
   /**
    * Define attributes to attach
@@ -77,6 +85,24 @@ export interface ClassDeclarationProps
    * ```
    */
   attributes?: AttributesProp;
+
+  /**
+   * Set the primary constructor parameters
+   * @example
+   * ```tsx
+   *  <ClassDeclaration name="MyClass" primaryConstructor={[
+   *    {name: "value", type: "int"}
+   *  ]}>
+   * ```
+   * This will produce:
+   * ```csharp
+   * public class MyClass(int value)
+   * {
+   *
+   * }
+   * ```
+   */
+  primaryConstructor?: ParameterProps[];
 }
 
 /**
@@ -104,19 +130,11 @@ export interface ClassDeclarationProps
  * ```
  */
 export function ClassDeclaration(props: ClassDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name!, "class");
-
-  const thisClassSymbol = new CSharpOutputSymbol(name, {
+  const thisClassSymbol = createNamedTypeSymbol(props.name, "class", {
     refkeys: props.refkey,
   });
 
-  // this creates a new scope for the class definition.
-  // members will automatically "inherit" this scope so
-  // that refkeys to them will produce the fully-qualified
-  // name e.g. Foo.Bar.
-  const thisClassScope = new CSharpMemberScope("class-decl", {
-    owner: thisClassSymbol,
-  });
+  const thisClassScope = createClassScope(thisClassSymbol);
 
   const bases = [
     ...(props.baseType ? [props.baseType] : []),
@@ -129,23 +147,24 @@ export function ClassDeclaration(props: ClassDeclarationProps) {
     getClassModifiers(props),
   ]);
   return (
-    <core.Declaration symbol={thisClassSymbol}>
+    <Declaration symbol={thisClassSymbol}>
       <DocWhen doc={props.doc} />
       <AttributeList attributes={props.attributes} endline />
       {modifiers}class <Name />
-      {props.typeParameters && (
-        <TypeParameters parameters={props.typeParameters} />
-      )}
-      {base}
-      {props.typeParameters && (
-        <TypeParameterConstraints parameters={props.typeParameters} />
-      )}
-      {!props.children && ";"}
-      {props.children && (
-        <core.Block newline>
-          <core.Scope value={thisClassScope}>{props.children}</core.Scope>
-        </core.Block>
-      )}
-    </core.Declaration>
+      <Scope value={thisClassScope}>
+        {props.typeParameters && (
+          <TypeParameters parameters={props.typeParameters} />
+        )}
+        {props.primaryConstructor && (
+          <Parameters parameters={props.primaryConstructor} />
+        )}
+        {base}
+        {props.typeParameters && (
+          <TypeParameterConstraints parameters={props.typeParameters} />
+        )}
+        {!props.children && ";"}
+        {props.children && <Block newline>{props.children}</Block>}
+      </Scope>
+    </Declaration>
   );
 }

package/src/components/constructor/constructor.test.tsx

@@ -1,8 +1,7 @@
 import { refkey } from "@alloy-js/core";
 import { expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
-import { ClassDeclaration } from "../ClassDeclaration.jsx";
-import { SourceFile } from "../SourceFile.jsx";
+import { ClassDeclaration } from "../class/declaration.jsx";
 import { Constructor } from "./constructor.jsx";
 
 it("reference constructor parameters in body", () => {
@@ -16,25 +15,20 @@ it("reference constructor parameters in body", () => {
 
   expect(
     <TestNamespace>
-      <SourceFile path="Test.cs">
-        <ClassDeclaration public name="TestClass">
-          <Constructor public parameters={ctorParams}>
-            {paramNameRefkey};<hbr />
-            {paramSizeRefkey};
-          </Constructor>
-        </ClassDeclaration>
-      </SourceFile>
+      <ClassDeclaration public name="TestClass">
+        <Constructor public parameters={ctorParams}>
+          {paramNameRefkey};<hbr />
+          {paramSizeRefkey};
+        </Constructor>
+      </ClassDeclaration>
     </TestNamespace>,
   ).toRenderTo(`
-    namespace TestCode
+    public class TestClass
     {
-        public class TestClass
+        public TestClass(string name, int size)
         {
-            public TestClass(string name, int size)
-            {
-                name;
-                size;
-            }
+            name;
+            size;
         }
     }
   `);