@alloy-js/csharp 0.18.0-dev.9 → 0.19.0-dev.0

package/src/components/interface/method.test.tsx

@@ -1,6 +1,10 @@
+import { 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";
+import { Attribute } from "../attributes/attributes.jsx";
+import { SourceFile } from "../SourceFile.jsx";
+import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
 import { InterfaceDeclaration } from "./declaration.jsx";
 import { InterfaceMethod } from "./method.jsx";
 
@@ -103,6 +107,58 @@ it("defines params and return type", () => {
   `);
 });
 
+it("defines optional param", () => {
+  const res = (
+    <Wrapper>
+      <InterfaceMethod
+        public
+        name="MethodOne"
+        parameters={[
+          {
+            name: "intParam",
+            type: "int",
+            optional: true,
+          },
+        ]}
+        returns="string"
+      />
+    </Wrapper>
+  );
+
+  expect(res).toRenderTo(`
+    public interface TestInterface
+    {
+      public string MethodOne(int? intParam);
+    }
+  `);
+});
+
+it("defines optional param with default", () => {
+  const res = (
+    <Wrapper>
+      <InterfaceMethod
+        public
+        name="MethodOne"
+        parameters={[
+          {
+            name: "intParam",
+            type: "int",
+            default: 12,
+          },
+        ]}
+        returns="string"
+      />
+    </Wrapper>
+  );
+
+  expect(res).toRenderTo(`
+    public interface TestInterface
+    {
+      public string MethodOne(int intParam = 12);
+    }
+  `);
+});
+
 it("specify doc comment", () => {
   expect(
     <TestNamespace>
@@ -118,3 +174,120 @@ it("specify doc comment", () => {
     }
   `);
 });
+
+it("specify attributes", () => {
+  expect(
+    <Wrapper>
+      <InterfaceMethod name="Test" attributes={[<Attribute name="Test" />]} />
+    </Wrapper>,
+  ).toRenderTo(`
+    public interface TestInterface
+    {
+      [Test]
+      void Test();
+    }
+  `);
+});
+
+describe("with type parameters", () => {
+  it("reference parameters", () => {
+    const typeParameters: TypeParameterProps[] = [
+      {
+        name: "T",
+        refkey: refkey(),
+      },
+      {
+        name: "U",
+        refkey: refkey(),
+      },
+    ];
+
+    expect(
+      <TestNamespace>
+        <SourceFile path="TestFile.cs">
+          <InterfaceDeclaration public name="TestInterface">
+            <InterfaceMethod
+              name="Test"
+              public
+              typeParameters={typeParameters}
+              parameters={[
+                {
+                  name: "paramA",
+                  type: typeParameters[0].refkey,
+                },
+              ]}
+              returns={typeParameters[0].refkey}
+            />
+          </InterfaceDeclaration>
+        </SourceFile>
+      </TestNamespace>,
+    ).toRenderTo(`
+      namespace TestCode
+      {
+        public interface TestInterface
+        {
+          public T Test<T, U>(T paramA);
+        }
+      }
+    `);
+  });
+
+  it("defines with constraints", () => {
+    const typeParameters: TypeParameterProps[] = [
+      {
+        name: "T",
+        constraints: "IFoo",
+      },
+      {
+        name: "U",
+        constraints: "IBar",
+      },
+    ];
+
+    expect(
+      <Wrapper>
+        <InterfaceMethod public name="Test" typeParameters={typeParameters}>
+          // Body
+        </InterfaceMethod>
+      </Wrapper>,
+    ).toRenderTo(`
+      public interface TestInterface
+      {
+        public void Test<T, U>()
+          where T : IFoo
+          where U : IBar
+        {
+          // Body
+        }
+      }
+    `);
+  });
+});
+
+describe("formatting", () => {
+  it("Split parameters before type parameters", () => {
+    expect(
+      <Wrapper>
+        <InterfaceMethod
+          public
+          name="Handle"
+          parameters={[
+            {
+              name: "message",
+              type: "Some.Quite.Long.Type.That.Will.Split",
+            },
+          ]}
+          typeParameters={["T"]}
+          returns="Some.Quite.Long.Type.That.Will.Split"
+        />
+      </Wrapper>,
+    ).toRenderTo(`
+      public interface TestInterface
+      {
+        public Some.Quite.Long.Type.That.Will.Split Handle<T>(
+          Some.Quite.Long.Type.That.Will.Split message
+        );
+      }
+    `);
+  });
+});

package/src/components/interface/method.tsx

@@ -15,8 +15,12 @@ import {
 import { useCSharpNamePolicy } from "../../name-policy.js";
 import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
 import { CSharpMemberScope, useCSharpScope } from "../../symbols/scopes.js";
-import { ParameterProps, Parameters } from "../Parameters.jsx";
+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";
 
 /** Method modifiers. Can only be one. */
 export interface InterfaceMethodModifiers {
@@ -33,10 +37,41 @@ export interface InterfaceMethodProps
   refkey?: Refkey;
   children?: Children;
   parameters?: Array<ParameterProps>;
+  /**
+   * Type parameters for the method
+   *
+   * @example
+   * ```tsx
+   * <InterfaceMethod name="Test" typeParameters={["T"]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * public void Test<T>()
+   * ```
+   */
+  typeParameters?: (TypeParameterProps | string)[];
   returns?: Children;
 
   /** Doc comment */
   doc?: Children;
+
+  /**
+   * Define attributes to attach
+   * @example
+   * ```tsx
+   * <InterfaceMethod name="MyMethod" attributes={[
+   *  <Attribute name="Test" />
+   *  <Attribute name="Test2" args={["arg1", "arg2"]} />
+   * ]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * [Test]
+   * [Test2("arg1", "arg2")]
+   * void MyMethod();
+   * ```
+   */
+  attributes?: AttributesProp;
 }
 
 // a C# interface method
@@ -59,9 +94,6 @@ export function InterfaceMethod(props: InterfaceMethodProps) {
     owner: methodSymbol,
   });
 
-  const params =
-    props.parameters ? <Parameters parameters={props.parameters} /> : "";
-
   const modifiers = computeModifiersPrefix([
     getAccessModifier(props),
     getMethodModifier(props),
@@ -71,8 +103,16 @@ export function InterfaceMethod(props: InterfaceMethodProps) {
     <MemberDeclaration symbol={methodSymbol}>
       <Scope value={methodScope}>
         <DocWhen doc={props.doc} />
+        <AttributeList attributes={props.attributes} endline />
         {modifiers}
-        {props.returns ?? "void"} {name}({params})
+        {props.returns ?? "void"} {name}
+        {props.typeParameters && (
+          <TypeParameters parameters={props.typeParameters} />
+        )}
+        <Parameters parameters={props.parameters} />
+        {props.typeParameters && (
+          <TypeParameterConstraints parameters={props.typeParameters} />
+        )}
         {props.children ?
           <Block newline>{props.children}</Block>
         : ";"}

package/src/components/interface/property.test.tsx

@@ -1,6 +1,7 @@
 import { Children } from "@alloy-js/core/jsx-runtime";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
+import { Attribute } from "../attributes/attributes.jsx";
 import { InterfaceDeclaration } from "./declaration.jsx";
 import { InterfaceProperty } from "./property.jsx";
 
@@ -142,3 +143,23 @@ it("specify doc comment", () => {
     }
   `);
 });
+
+it("specify attributes", () => {
+  expect(
+    <Wrapper>
+      <InterfaceProperty
+        name="Test"
+        type="int"
+        attributes={[<Attribute name="Test" />]}
+        get
+        set
+      />
+    </Wrapper>,
+  ).toRenderTo(`
+    public interface TestInterface
+    {
+      [Test]
+      int Test { get; set; }
+    }
+  `);
+});

package/src/components/interface/property.tsx

@@ -16,6 +16,7 @@ import {
 import { useCSharpNamePolicy } from "../../name-policy.js";
 import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
 import { CSharpMemberScope, useCSharpScope } from "../../symbols/scopes.js";
+import { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
 import { DocWhen } from "../doc/comment.jsx";
 
 /** Method modifiers. Can only be one. */
@@ -23,9 +24,7 @@ export interface InterfacePropertyModifiers {
   readonly new?: boolean;
 }
 
-export const getMethodModifier = makeModifiers<InterfacePropertyModifiers>([
-  "new",
-]);
+const getModifiers = makeModifiers<InterfacePropertyModifiers>(["new"]);
 
 // properties for creating a method
 export interface InterfacePropertyProps
@@ -45,9 +44,45 @@ export interface InterfacePropertyProps
 
   /** Doc comment */
   doc?: Children;
+
+  /**
+   * Property initializer
+   * @example `<ClassProperty name="My" get set nullable />`
+   *
+   * ```cs
+   * int? My { get; set; };
+   * ```
+   */
+  nullable?: boolean;
+
+  /**
+   * Define attributes to attach
+   * @example
+   * ```tsx
+   * <InterfaceProperty name="MyProp" attributes={[
+   *  <Attribute name="Test" />
+   *  <Attribute name="Test2" args={["arg1", "arg2"]} />
+   * ]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * [Test]
+   * [Test2("arg1", "arg2")]
+   * int MyProp { get; set; }
+   * ```
+   */
+  attributes?: AttributesProp;
 }
 
-// a C# interface property
+/**
+ * Render a C# interface property.
+ *
+ * @example `<InterfaceProperty public name="My" get set  />`
+ *
+ * ```cs
+ * public int My { get; set; };
+ * ```
+ */
 export function InterfaceProperty(props: InterfacePropertyProps) {
   const name = useCSharpNamePolicy().getName(props.name, "class-property");
   const scope = useCSharpScope();
@@ -69,15 +104,17 @@ export function InterfaceProperty(props: InterfacePropertyProps) {
 
   const modifiers = computeModifiersPrefix([
     getAccessModifier(props),
-    getMethodModifier(props),
+    getModifiers(props),
   ]);
   // note that scope wraps the method decl so that the params get the correct scope
   return (
     <MemberDeclaration symbol={propertySymbol}>
       <Scope value={propertyScope}>
         <DocWhen doc={props.doc} />
+        <AttributeList attributes={props.attributes} endline />
         {modifiers}
-        {props.type} {name}{" "}
+        {props.type}
+        {props.nullable && "?"} {name}{" "}
         <Block newline inline>
           <List joiner=" ">
             {props.get && "get;"}

package/src/components/parameters/parameters.tsx

@@ -0,0 +1,74 @@
+import {
+  Children,
+  code,
+  Declaration,
+  For,
+  Indent,
+  OutputSymbol,
+  refkey,
+  Refkey,
+} from "@alloy-js/core";
+import { useCSharpNamePolicy } from "../../name-policy.js";
+import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
+import { useCSharpScope } from "../../symbols/scopes.js";
+import { Name } from "../Name.jsx";
+
+export interface ParameterProps {
+  name: string;
+  type: Children;
+  /** If the parmaeter is optional(without default value) */
+  optional?: boolean;
+  /** Default value for the parameter */
+  default?: Children;
+  refkey?: Refkey;
+  symbol?: OutputSymbol;
+}
+
+/** Define a parameter to be used in class or interface method. */
+export function Parameter(props: ParameterProps) {
+  const name = useCSharpNamePolicy().getName(props.name, "parameter");
+  const scope = useCSharpScope();
+  if (
+    scope.kind !== "member" ||
+    (scope.name !== "constructor-decl" && scope.name !== "method-decl")
+  ) {
+    throw new Error(
+      "can't define a parameter outside of a constructor-decl or method-decl scope",
+    );
+  }
+
+  const memberSymbol = new CSharpOutputSymbol(name, {
+    scope,
+    refkeys: props.refkey ?? refkey(props.name),
+  });
+
+  return (
+    <Declaration symbol={memberSymbol}>
+      {props.type}
+      {props.optional ? "?" : ""} <Name />
+      {props.default ? code` = ${props.default}` : ""}
+    </Declaration>
+  );
+}
+
+export interface ParametersProps {
+  parameters: ParameterProps[] | undefined;
+}
+
+/** Render a collection of parameters */
+export function Parameters(props: ParametersProps) {
+  return (
+    <group>
+      {"("}
+      {props.parameters && (
+        <Indent softline>
+          <For each={props.parameters} joiner={", "}>
+            {(param) => <Parameter {...param} />}
+          </For>
+        </Indent>
+      )}
+      <softline />
+      {")"}
+    </group>
+  );
+}

package/src/components/property/property.test.tsx

@@ -0,0 +1,209 @@
+import { Children } from "@alloy-js/core/jsx-runtime";
+import { describe, expect, it } from "vitest";
+import { TestNamespace } from "../../../test/utils.jsx";
+import { Attribute } from "../attributes/attributes.jsx";
+import { ClassDeclaration } from "../ClassDeclaration.jsx";
+import { Property } from "./property.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>
+            <Property
+              {...{ [accessModifier]: true }}
+              name="TestProp"
+              type="string"
+              get
+            />
+          </Wrapper>,
+        ).toRenderTo(`
+        public class TestClass
+        {
+          ${accessModifier} string TestProp { get; }
+        }
+      `);
+      },
+    );
+  });
+
+  describe("property modifiers", () => {
+    it.each([
+      "new",
+      "static",
+      "virtual",
+      "sealed",
+      "override",
+      "abstract",
+      "extern",
+      "readonly",
+      "required",
+    ] as const)("%s", (methodModifier) => {
+      expect(
+        <Wrapper>
+          <Property
+            {...{ [methodModifier]: true }}
+            name="TestProp"
+            type="string"
+            get
+          />
+        </Wrapper>,
+      ).toRenderTo(`
+        public class TestClass
+        {
+          ${methodModifier} string TestProp { get; }
+        }
+      `);
+    });
+  });
+
+  it("combine modifiers", () => {
+    expect(
+      <Wrapper>
+        <Property public new name="TestProp" type="string" get />
+      </Wrapper>,
+    ).toRenderTo(`
+        public class TestClass
+        {
+          public new string TestProp { get; }
+        }
+      `);
+  });
+});
+
+it("applies PascalCase naming policy", () => {
+  expect(
+    <Wrapper>
+      <Property name="test_prop" type="string" get />
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+      string TestProp { get; }
+    }
+`);
+});
+
+it("has getter only", () => {
+  expect(
+    <Wrapper>
+      <Property name="TestProp" type="string" get />
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+      string TestProp { get; }
+    }
+  `);
+});
+
+it("has setter only", () => {
+  expect(
+    <Wrapper>
+      <Property name="TestProp" type="string" set />
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+      string TestProp { set; }
+    }
+  `);
+});
+
+it("has getter and setter", () => {
+  expect(
+    <Wrapper>
+      <Property name="TestProp" type="string" get set />
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+      string TestProp { get; set; }
+    }
+  `);
+});
+
+it("has getter and init", () => {
+  expect(
+    <Wrapper>
+      <Property name="TestProp" type="string" get init />
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+      string TestProp { get; init; }
+    }
+  `);
+});
+
+it("specify doc comment", () => {
+  expect(
+    <TestNamespace>
+      <ClassDeclaration name="Test">
+        <Property name="Method" type="string" get set doc="This is a test" />
+      </ClassDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+    class Test
+    {
+      /// This is a test
+      string Method { get; set; }
+    }
+  `);
+});
+
+it("specify nullable property", () => {
+  expect(
+    <Wrapper>
+      <Property name="TestProp" type="string" nullable get set />
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+      string? TestProp { get; set; }
+    }
+  `);
+});
+
+it("specify initializer", () => {
+  expect(
+    <Wrapper>
+      <Property name="TestProp" type="string" get set initializer={`"abc"`} />
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+      string TestProp { get; set; } = "abc";
+    }
+  `);
+});
+
+it("specify attributes", () => {
+  expect(
+    <Wrapper>
+      <Property
+        name="Test"
+        type="int"
+        attributes={[<Attribute name="Test" />]}
+        get
+        set
+      />
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+      [Test]
+      int Test { get; set; }
+    }
+  `);
+});