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

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

@@ -0,0 +1,41 @@
+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 { Constructor } from "./constructor.jsx";
+
+it("reference constructor parameters in body", () => {
+  const paramNameRefkey = refkey();
+  const paramSizeRefkey = refkey();
+
+  const ctorParams = [
+    { name: "name", type: "string", refkey: paramNameRefkey },
+    { name: "size", type: "int", refkey: paramSizeRefkey },
+  ];
+
+  expect(
+    <TestNamespace>
+      <SourceFile path="Test.cs">
+        <ClassDeclaration public name="TestClass">
+          <Constructor public parameters={ctorParams}>
+            {paramNameRefkey};<hbr />
+            {paramSizeRefkey};
+          </Constructor>
+        </ClassDeclaration>
+      </SourceFile>
+    </TestNamespace>,
+  ).toRenderTo(`
+    namespace TestCode
+    {
+        public class TestClass
+        {
+            public TestClass(string name, int size)
+            {
+                name;
+                size;
+            }
+        }
+    }
+  `);
+});

package/src/components/constructor/constructor.tsx

@@ -0,0 +1,67 @@
+import {
+  Block,
+  Declaration,
+  Name,
+  Refkey,
+  refkey,
+  Scope,
+} from "@alloy-js/core";
+import { Children } from "@alloy-js/core/jsx-runtime";
+import {
+  AccessModifiers,
+  computeModifiersPrefix,
+  getAccessModifier,
+} 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/parameters.jsx";
+
+/**
+ * Properties for {@link Constructor} component.
+ */
+export interface ConstructorProps extends AccessModifiers {
+  /** Constructor parameters */
+  parameters?: ParameterProps[];
+
+  /** Refkey */
+  refkey?: Refkey;
+
+  /** Constructor body */
+  children?: Children;
+}
+
+export function Constructor(props: ConstructorProps) {
+  const scope = useCSharpScope();
+  if (
+    scope.kind !== "member" ||
+    (scope.name !== "class-decl" && scope.name !== "struct-decl")
+  ) {
+    throw new Error(
+      "can't define a class method outside of a class or struct scope",
+    );
+  }
+
+  const name = useCSharpNamePolicy().getName(scope.owner!.name, "class-method");
+  const ctorSymbol = new CSharpOutputSymbol(name, {
+    scope,
+    refkeys: props.refkey ?? refkey(name),
+  });
+
+  const ctorDeclScope = new CSharpMemberScope("constructor-decl", {
+    owner: ctorSymbol,
+  });
+
+  const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
+
+  return (
+    <Declaration symbol={ctorSymbol}>
+      <Scope value={ctorDeclScope}>
+        {modifiers}
+        <Name />
+        <Parameters parameters={props.parameters} />
+        <Block newline>{props.children}</Block>
+      </Scope>
+    </Declaration>
+  );
+}

package/src/components/index.ts

@@ -1,6 +1,6 @@
 export * from "./attributes/attributes.jsx";
 export * from "./ClassDeclaration.jsx";
-export * from "./ClassMethod.jsx";
+export * from "./constructor/constructor.jsx";
 export * from "./Declaration.js";
 export * from "./doc/comment.jsx";
 export * from "./doc/from-markdown.jsx";
@@ -8,6 +8,7 @@ export * from "./EnumDeclaration.jsx";
 export * from "./interface/declaration.js";
 export * from "./interface/method.js";
 export * from "./interface/property.js";
+export * from "./method/method.jsx";
 export * from "./Name.js";
 export * from "./Namespace.js";
 export * from "./parameters/parameters.jsx";
@@ -16,6 +17,7 @@ export * from "./property/property.jsx";
 export * from "./record/declaration.js";
 export * from "./Reference.js";
 export * from "./SourceFile.js";
+export * from "./struct/declaration.jsx";
 export type { TypeParameterProps } from "./type-parameters/type-parameter.jsx";
 export * from "./UsingDirective.js";
 export * from "./var/declaration.jsx";

package/{test/class-method.test.tsx → src/components/method/method.test.tsx}

@@ -1,7 +1,7 @@
 import { Children } from "@alloy-js/core/jsx-runtime";
 import { describe, expect, it } from "vitest";
-import { ClassDeclaration, ClassMethod } from "../src/index.js";
-import { TestNamespace } from "./utils.jsx";
+import { TestNamespace } from "../../../test/utils.jsx";
+import { ClassDeclaration, Method } from "../../index.js";
 
 const Wrapper = (props: { children: Children }) => (
   <TestNamespace>
@@ -18,7 +18,7 @@ describe("modifiers", () => {
       (accessModifier) => {
         expect(
           <Wrapper>
-            <ClassMethod {...{ [accessModifier]: true }} name="MethodOne" />
+            <Method {...{ [accessModifier]: true }} name="MethodOne" />
           </Wrapper>,
         ).toRenderTo(`
         public class TestClass
@@ -36,7 +36,7 @@ describe("modifiers", () => {
       (methodModifier) => {
         expect(
           <Wrapper>
-            <ClassMethod {...{ [methodModifier]: true }} name="MethodOne" />
+            <Method {...{ [methodModifier]: true }} name="MethodOne" />
           </Wrapper>,
         ).toRenderTo(`
         public class TestClass
@@ -50,7 +50,7 @@ describe("modifiers", () => {
     it("abstract exclude body", () => {
       expect(
         <Wrapper>
-          <ClassMethod abstract name="MethodOne" />
+          <Method abstract name="MethodOne" />
         </Wrapper>,
       ).toRenderTo(`
         public class TestClass
@@ -64,7 +64,7 @@ describe("modifiers", () => {
   it("mark method async", () => {
     expect(
       <Wrapper>
-        <ClassMethod async name="MethodOne" />
+        <Method async name="MethodOne" />
       </Wrapper>,
     ).toRenderTo(`
         public class TestClass
@@ -77,7 +77,7 @@ describe("modifiers", () => {
   it("combine modifiers", () => {
     expect(
       <Wrapper>
-        <ClassMethod async returns="Task" public abstract name="MethodOne" />
+        <Method async returns="Task" public abstract name="MethodOne" />
       </Wrapper>,
     ).toRenderTo(`
         public class TestClass
@@ -91,7 +91,7 @@ describe("modifiers", () => {
 it("applies PascalCase naming policy", () => {
   expect(
     <Wrapper>
-      <ClassMethod name="method_one" />
+      <Method name="method_one" />
     </Wrapper>,
   ).toRenderTo(`
     public class TestClass
@@ -113,12 +113,7 @@ it("defines params and return type", () => {
   ];
   const res = (
     <Wrapper>
-      <ClassMethod
-        public
-        name="MethodOne"
-        parameters={params}
-        returns="string"
-      />
+      <Method public name="MethodOne" parameters={params} returns="string" />
     </Wrapper>
   );
 
@@ -134,7 +129,7 @@ it("specify doc comment", () => {
   expect(
     <TestNamespace>
       <ClassDeclaration name="Test">
-        <ClassMethod name="Method" doc="This is a test" />
+        <Method name="Method" doc="This is a test" />
       </ClassDeclaration>
     </TestNamespace>,
   ).toRenderTo(`
@@ -145,3 +140,21 @@ it("specify doc comment", () => {
     }
   `);
 });
+
+it("use expression body form", () => {
+  expect(
+    <TestNamespace>
+      <ClassDeclaration name="Test">
+        <Method name="Method" doc="This is a test" expression>
+          this.MyProperty.Value;
+        </Method>
+      </ClassDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+    class Test
+    {
+      /// This is a test
+      void Method() => this.MyProperty.Value;
+    }
+  `);
+});

package/src/components/{ClassMethod.tsx → method/method.tsx}

@@ -12,26 +12,26 @@ import {
   getAccessModifier,
   getAsyncModifier,
   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 { 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";
+} 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 { 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 ClassMethodModifiers {
+export interface MethodModifiers {
   readonly abstract?: boolean;
   readonly sealed?: boolean;
   readonly static?: boolean;
   readonly virtual?: boolean;
 }
 
-const getMethodModifier = makeModifiers<ClassMethodModifiers>([
+const getMethodModifier = makeModifiers<MethodModifiers>([
   "abstract",
   "sealed",
   "static",
@@ -39,9 +39,7 @@ const getMethodModifier = makeModifiers<ClassMethodModifiers>([
 ]);
 
 // properties for creating a method
-export interface ClassMethodProps
-  extends AccessModifiers,
-    ClassMethodModifiers {
+export interface MethodProps extends AccessModifiers, MethodModifiers {
   name: string;
   refkey?: Refkey;
   children?: Children;
@@ -87,14 +85,34 @@ export interface ClassMethodProps
    * ```
    */
   attributes?: AttributesProp;
+
+  /**
+   * Use expression syntax for the method.
+   * @example
+   * ```tsx
+   * <ClassMethod name="MyMethod" lambda>
+   *   this.MyProperty.Value;
+   * </ClassMethod>
+   * ```
+   * This will produce:
+   * ```csharp
+   * public void MyMethod() => this.MyProperty.Value;
+   * ```
+   */
+  expression?: boolean;
 }
 
 // a C# class method
-export function ClassMethod(props: ClassMethodProps) {
+export function Method(props: MethodProps) {
   const name = useCSharpNamePolicy().getName(props.name, "class-method");
   const scope = useCSharpScope();
-  if (scope.kind !== "member" || scope.name !== "class-decl") {
-    throw new Error("can't define a class method outside of a class scope");
+  if (
+    scope.kind !== "member" ||
+    (scope.name !== "class-decl" && scope.name !== "struct-decl")
+  ) {
+    throw new Error(
+      "can't define a class method outside of a class or struct scope",
+    );
   }
 
   const methodSymbol = new CSharpOutputSymbol(name, {
@@ -129,7 +147,14 @@ export function ClassMethod(props: ClassMethodProps) {
         {props.typeParameters && (
           <TypeParameterConstraints parameters={props.typeParameters} />
         )}
-        {props.abstract ? ";" : <Block newline>{props.children}</Block>}
+        {props.abstract ?
+          ";"
+        : props.expression ?
+          <>
+            {" => "}
+            {props.children}
+          </>
+        : <Block newline>{props.children}</Block>}
       </Scope>
     </MemberDeclaration>
   );

package/src/components/property/property.tsx

@@ -122,7 +122,9 @@ export function Property(props: PropertyProps) {
   const scope = useCSharpScope();
   if (
     scope.kind !== "member" ||
-    (scope.name !== "class-decl" && scope.name !== "record-decl")
+    (scope.name !== "class-decl" &&
+      scope.name !== "record-decl" &&
+      scope.name !== "struct-decl")
   ) {
     throw new Error(
       "can't define an interface method outside of an interface scope",

package/src/components/stc/index.ts

@@ -2,12 +2,13 @@ import * as core from "@alloy-js/core";
 import * as base from "../index.js";
 
 export const ClassDeclaration = core.stc(base.ClassDeclaration);
-export const ClassConstructor = core.stc(base.ClassConstructor);
+export const Constructor = core.stc(base.Constructor);
 export const ClassMember = core.stc(base.ClassMember);
-export const ClassMethod = core.stc(base.ClassMethod);
+export const ClassMethod = core.stc(base.Method);
 export const EnumDeclaration = core.stc(base.EnumDeclaration);
 export const EnumMember = core.stc(base.EnumMember);
 export const Parameter = core.stc(base.Parameter);
 export const Parameters = core.stc(base.Parameters);
 export const ProjectDirectory = core.stc(base.ProjectDirectory);
 export const UsingDirective = core.stc(base.UsingDirective);
+export const StructDeclaration = core.stc(base.StructDeclaration);

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

@@ -0,0 +1,169 @@
+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 { Constructor } from "../constructor/constructor.jsx";
+import { Method } from "../method/method.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;
+  `);
+});
+
+it("define methods", () => {
+  expect(
+    <TestNamespace>
+      <StructDeclaration name="Test">
+        <Method name="MethodOne" />
+      </StructDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+    struct Test
+    {
+      void MethodOne() {}
+    }
+  `);
+});
+
+it("define constructor", () => {
+  expect(
+    <TestNamespace>
+      <StructDeclaration name="Test">
+        <Constructor public />
+      </StructDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+    struct Test
+    {
+      public 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":