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

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

@@ -0,0 +1,143 @@
+import { List, refkey } from "@alloy-js/core";
+import { describe, expect, it } from "vitest";
+import { TestNamespace } from "../../../test/utils.jsx";
+import { SourceFile } from "../SourceFile.jsx";
+import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
+import { InterfaceDeclaration } from "./declaration.jsx";
+import { InterfaceProperty } from "./property.jsx";
+
+it("declares class with no members", () => {
+  expect(
+    <TestNamespace>
+      <InterfaceDeclaration name="TestInterface" />
+    </TestNamespace>,
+  ).toRenderTo(`
+      interface TestInterface;
+  `);
+});
+
+describe("modifiers", () => {
+  it.each(["public", "private", "internal"])("%s", (mod) => {
+    expect(
+      <TestNamespace>
+        <InterfaceDeclaration {...{ [mod]: true }} name="TestInterface" />
+      </TestNamespace>,
+    ).toRenderTo(`
+        ${mod} interface TestInterface;
+    `);
+  });
+
+  it.each(["partial"])("%s", (mod) => {
+    expect(
+      <TestNamespace>
+        <InterfaceDeclaration {...{ [mod]: true }} name="TestInterface" />
+      </TestNamespace>,
+    ).toRenderTo(`
+        ${mod} interface TestInterface;
+    `);
+  });
+
+  it("combines modifiers", () => {
+    expect(
+      <TestNamespace>
+        <InterfaceDeclaration public partial name="TestInterface" />
+      </TestNamespace>,
+    ).toRenderTo(`
+        public partial interface TestInterface;
+    `);
+  });
+});
+
+it("specify doc comment", () => {
+  expect(
+    <TestNamespace>
+      <InterfaceDeclaration name="TestInterface" doc="This is a test" />
+    </TestNamespace>,
+  ).toRenderTo(`
+    /// This is a test
+    interface TestInterface;
+  `);
+});
+
+describe("with type parameters", () => {
+  it("reference parameters", () => {
+    const typeParameters: TypeParameterProps[] = [
+      {
+        name: "T",
+        refkey: refkey(),
+      },
+      {
+        name: "U",
+        refkey: refkey(),
+      },
+    ];
+
+    expect(
+      <TestNamespace>
+        <SourceFile path="Test.cs">
+          <InterfaceDeclaration
+            public
+            name="Test"
+            typeParameters={typeParameters}
+          >
+            <List>
+              <InterfaceProperty
+                name="PropA"
+                type={typeParameters[0].refkey}
+                get
+                set
+              />
+              <InterfaceProperty
+                name="PropB"
+                type={typeParameters[1].refkey}
+                get
+                set
+              />
+            </List>
+          </InterfaceDeclaration>
+        </SourceFile>
+      </TestNamespace>,
+    ).toRenderTo(`
+      namespace TestCode
+      {
+        public interface Test<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>
+        <InterfaceDeclaration
+          public
+          name="Test"
+          typeParameters={typeParameters}
+        >
+          // Body
+        </InterfaceDeclaration>
+      </TestNamespace>,
+    ).toRenderTo(`
+      public interface Test<T, U>
+        where T : IFoo
+        where U : IBar
+      {
+        // Body
+      }
+    `);
+  });
+});

package/src/components/interface/declaration.tsx

@@ -0,0 +1,105 @@
+import * as core 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 { 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";
+
+export interface InterfaceModifiers {
+  readonly partial?: boolean;
+}
+
+const getInterfaceModifiers = makeModifiers<InterfaceModifiers>(["partial"]);
+
+// properties for creating a class
+export interface InterfaceDeclarationProps
+  extends Omit<core.DeclarationProps, "nameKind">,
+    AccessModifiers,
+    InterfaceModifiers {
+  name: string;
+
+  /** Doc comment */
+  doc?: core.Children;
+  refkey?: core.Refkey;
+
+  /**
+   * Type parameters for the interface
+   *
+   * @example
+   * ```tsx
+   * <InterfaceDeclaration name="IList" typeParameters={["T"]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * public interface IList<T>
+   * ```
+   */
+  typeParameters?: (TypeParameterProps | string)[];
+}
+
+/**
+ * CSharp interface declaration.
+ * @example
+ * ```tsx
+ * <InterfaceDeclaration public name="IMyInterface">
+ *   <InterfaceMember public name="MyProperty" type="int" />
+ *   <InterfaceMethod public name="MyMethod" returnType="void">
+ *     <Parameter name="value" type="int" />
+ *   </InterfaceMethod>
+ * </InterfaceDeclaration>
+ * ```
+ * This will produce:
+ * ```csharp
+ * public interface MyIface
+ * {
+ *   public int MyProperty { get; set; }
+ *   public void MyMethod(int value);
+ * }
+ * ```
+ */
+export function InterfaceDeclaration(props: InterfaceDeclarationProps) {
+  const name = useCSharpNamePolicy().getName(props.name!, "interface");
+
+  const thisInterfaceSymbol = new CSharpOutputSymbol(name, {
+    refkeys: props.refkey,
+  });
+
+  // this creates a new scope for the interface definition.
+  // members will automatically "inherit" this scope so
+  // that refkeys to them will produce the fully-qualified
+  // name e.g. Foo.Bar.
+  const thisInterfaceScope = new CSharpMemberScope("interface-decl", {
+    owner: thisInterfaceSymbol,
+  });
+
+  const modifiers = computeModifiersPrefix([
+    getAccessModifier(props),
+    getInterfaceModifiers(props),
+  ]);
+  return (
+    <core.Declaration symbol={thisInterfaceSymbol}>
+      <DocWhen doc={props.doc} />
+      {modifiers}interface <Name />
+      {props.typeParameters && (
+        <TypeParameters parameters={props.typeParameters} />
+      )}
+      {props.typeParameters && (
+        <TypeParameterConstraints parameters={props.typeParameters} />
+      )}
+      {props.children ?
+        <core.Block newline>
+          <core.Scope value={thisInterfaceScope}>{props.children}</core.Scope>
+        </core.Block>
+      : ";"}
+    </core.Declaration>
+  );
+}

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

@@ -0,0 +1,250 @@
+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 { SourceFile } from "../SourceFile.jsx";
+import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
+import { InterfaceDeclaration } from "./declaration.jsx";
+import { InterfaceMethod } from "./method.jsx";
+
+const Wrapper = (props: { children: Children }) => (
+  <TestNamespace>
+    <InterfaceDeclaration public name="TestInterface">
+      {props.children}
+    </InterfaceDeclaration>
+  </TestNamespace>
+);
+
+describe("modifiers", () => {
+  describe("access modifiers", () => {
+    it.each(["public", "private", "protected", "internal"] as const)(
+      "%s",
+      (accessModifier) => {
+        expect(
+          <Wrapper>
+            <InterfaceMethod {...{ [accessModifier]: true }} name="MethodOne" />
+          </Wrapper>,
+        ).toRenderTo(`
+        public interface TestInterface
+        {
+          ${accessModifier} void MethodOne();
+        }
+      `);
+      },
+    );
+  });
+
+  describe("method modifiers", () => {
+    it.each(["new"] as const)("%s", (methodModifier) => {
+      expect(
+        <Wrapper>
+          <InterfaceMethod {...{ [methodModifier]: true }} name="MethodOne" />
+        </Wrapper>,
+      ).toRenderTo(`
+        public interface TestInterface
+        {
+          ${methodModifier} void MethodOne();
+        }
+      `);
+    });
+  });
+
+  it("combine modifiers", () => {
+    expect(
+      <Wrapper>
+        <InterfaceMethod returns="Task" public new name="MethodOne" />
+      </Wrapper>,
+    ).toRenderTo(`
+        public interface TestInterface
+        {
+          public new Task MethodOne();
+        }
+      `);
+  });
+});
+
+it("applies PascalCase naming policy", () => {
+  expect(
+    <Wrapper>
+      <InterfaceMethod name="method_one" />
+    </Wrapper>,
+  ).toRenderTo(`
+    public interface TestInterface
+    {
+      void MethodOne();
+    }
+`);
+});
+
+it("defines params and return type", () => {
+  const params = [
+    {
+      name: "intParam",
+      type: "int",
+    },
+    {
+      name: "stringParam",
+      type: "string",
+    },
+  ];
+  const res = (
+    <Wrapper>
+      <InterfaceMethod
+        public
+        name="MethodOne"
+        parameters={params}
+        returns="string"
+      />
+    </Wrapper>
+  );
+
+  expect(res).toRenderTo(`
+    public interface TestInterface
+    {
+      public string MethodOne(int intParam, string stringParam);
+    }
+  `);
+});
+
+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>
+      <InterfaceDeclaration name="Test">
+        <InterfaceMethod name="Method" doc="This is a test" />
+      </InterfaceDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+    interface Test
+    {
+      /// This is a test
+      void Method();
+    }
+  `);
+});
+
+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
+        }
+      }
+    `);
+  });
+});

package/src/components/interface/method.tsx

@@ -0,0 +1,105 @@
+import {
+  Block,
+  Children,
+  MemberDeclaration,
+  refkey,
+  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, useCSharpScope } from "../../symbols/scopes.js";
+import { ParameterProps, Parameters } from "../Parameters.jsx";
+import { DocWhen } from "../doc/comment.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 {
+  readonly new?: boolean;
+}
+
+const getMethodModifier = makeModifiers<InterfaceMethodModifiers>(["new"]);
+
+// properties for creating a method
+export interface InterfaceMethodProps
+  extends AccessModifiers,
+    InterfaceMethodModifiers {
+  name: string;
+  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;
+}
+
+// a C# interface method
+export function InterfaceMethod(props: InterfaceMethodProps) {
+  const name = useCSharpNamePolicy().getName(props.name, "class-method");
+  const scope = useCSharpScope();
+  if (scope.kind !== "member" || scope.name !== "interface-decl") {
+    throw new Error(
+      "can't define an interface method outside of an interface scope",
+    );
+  }
+
+  const methodSymbol = new CSharpOutputSymbol(name, {
+    scope,
+    refkeys: props.refkey ?? refkey(props.name),
+  });
+
+  // scope for method declaration
+  const methodScope = new CSharpMemberScope("method-decl", {
+    owner: methodSymbol,
+  });
+
+  const params =
+    props.parameters ? <Parameters parameters={props.parameters} /> : "";
+
+  const modifiers = computeModifiersPrefix([
+    getAccessModifier(props),
+    getMethodModifier(props),
+  ]);
+  // note that scope wraps the method decl so that the params get the correct scope
+  return (
+    <MemberDeclaration symbol={methodSymbol}>
+      <Scope value={methodScope}>
+        <DocWhen doc={props.doc} />
+        {modifiers}
+        {props.returns ?? "void"} {name}
+        {props.typeParameters && (
+          <TypeParameters parameters={props.typeParameters} />
+        )}
+        ({params})
+        {props.typeParameters && (
+          <TypeParameterConstraints parameters={props.typeParameters} />
+        )}
+        {props.children ?
+          <Block newline>{props.children}</Block>
+        : ";"}
+      </Scope>
+    </MemberDeclaration>
+  );
+}