@alloy-js/csharp 0.19.0-dev.1 → 0.19.0-dev.2

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

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

package/src/components/struct/declaration.tsx

@@ -0,0 +1,129 @@
+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 { 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";
+
+export interface StructModifiers {
+  readonly new?: boolean;
+  readonly readonly?: boolean;
+  readonly ref?: boolean;
+  readonly partial?: boolean;
+}
+
+const getStructModifiers = makeModifiers<StructModifiers>([
+  "new",
+  "readonly",
+  "ref",
+  "partial",
+]);
+
+// properties for creating a class
+export interface StructDeclarationProps
+  extends Omit<core.DeclarationProps, "nameKind">,
+    AccessModifiers,
+    StructModifiers {
+  name: string;
+
+  /** Doc comment */
+  doc?: core.Children;
+  refkey?: core.Refkey;
+
+  /**
+   * Type parameters for the struct
+   *
+   * @example
+   * ```tsx
+   * <StructDeclaration name="IList" typeParameters={["T"]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * public struct IList<T>
+   * ```
+   */
+  typeParameters?: (TypeParameterProps | string)[];
+
+  /**
+   * Define attributes to attach
+   * @example
+   * ```tsx
+   * <StructDeclaration name="MyStruct" attributes={[
+   *  <Attribute name="Test" />
+   *  <Attribute name="Test2" args={["arg1", "arg2"]} />
+   * ]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * [Test]
+   * [Test2("arg1", "arg2")]
+   * public struct MyStruct
+   * ```
+   */
+  attributes?: AttributesProp;
+}
+
+/**
+ * CSharp struct declaration.
+ * @example
+ * ```tsx
+ * <StructDeclaration public name="IMyStruct">
+ *   <StructMember public name="MyProperty" type="int" />
+ *   <StructMethod public name="MyMethod" returnType="void">
+ *     <Parameter name="value" type="int" />
+ *   </StructMethod>
+ * </StructDeclaration>
+ * ```
+ * This will produce:
+ * ```csharp
+ * public struct MyIface
+ * {
+ *   public int MyProperty { get; set; }
+ *   public void MyMethod(int value);
+ * }
+ * ```
+ */
+export function StructDeclaration(props: StructDeclarationProps) {
+  const name = useCSharpNamePolicy().getName(props.name!, "struct");
+
+  const thisStructSymbol = new CSharpOutputSymbol(name, {
+    refkeys: props.refkey,
+  });
+
+  const thisStructScope = new CSharpMemberScope("struct-decl", {
+    owner: thisStructSymbol,
+  });
+
+  const modifiers = computeModifiersPrefix([
+    getAccessModifier(props),
+    getStructModifiers(props),
+  ]);
+  return (
+    <core.Declaration symbol={thisStructSymbol}>
+      <DocWhen doc={props.doc} />
+      <AttributeList attributes={props.attributes} endline />
+      {modifiers}struct <Name />
+      {props.typeParameters && (
+        <TypeParameters parameters={props.typeParameters} />
+      )}
+      {props.typeParameters && (
+        <TypeParameterConstraints parameters={props.typeParameters} />
+      )}
+      {props.children ?
+        <core.Block newline>
+          <core.Scope value={thisStructScope}>{props.children}</core.Scope>
+        </core.Block>
+      : ";"}
+    </core.Declaration>
+  );
+}

package/src/name-policy.ts

@@ -6,6 +6,7 @@ export type CSharpElements =
   | "class"
   | "constant"
   | "variable"
+  | "struct"
   | "enum"
   | "enum-member"
   | "function"
@@ -23,6 +24,7 @@ export function createCSharpNamePolicy(): core.NamePolicy<CSharpElements> {
   return core.createNamePolicy((name, element) => {
     switch (element) {
       case "class":
+      case "struct":
       case "enum":
       case "enum-member":
       case "interface":