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

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

@@ -0,0 +1,144 @@
+import { Children } from "@alloy-js/core/jsx-runtime";
+import { describe, expect, it } from "vitest";
+import { TestNamespace } from "../../../test/utils.jsx";
+import { InterfaceDeclaration } from "./declaration.jsx";
+import { InterfaceProperty } from "./property.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>
+            <InterfaceProperty
+              {...{ [accessModifier]: true }}
+              name="TestProp"
+              type="string"
+              get
+            />
+          </Wrapper>,
+        ).toRenderTo(`
+        public interface TestInterface
+        {
+          ${accessModifier} string TestProp { get; }
+        }
+      `);
+      },
+    );
+  });
+
+  describe("method modifiers", () => {
+    it.each(["new"] as const)("%s", (methodModifier) => {
+      expect(
+        <Wrapper>
+          <InterfaceProperty
+            {...{ [methodModifier]: true }}
+            name="TestProp"
+            type="string"
+            get
+          />
+        </Wrapper>,
+      ).toRenderTo(`
+        public interface TestInterface
+        {
+          ${methodModifier} string TestProp { get; }
+        }
+      `);
+    });
+  });
+
+  it("combine modifiers", () => {
+    expect(
+      <Wrapper>
+        <InterfaceProperty public new name="TestProp" type="string" get />
+      </Wrapper>,
+    ).toRenderTo(`
+        public interface TestInterface
+        {
+          public new string TestProp { get; }
+        }
+      `);
+  });
+});
+
+it("applies PascalCase naming policy", () => {
+  expect(
+    <Wrapper>
+      <InterfaceProperty name="test_prop" type="string" get />
+    </Wrapper>,
+  ).toRenderTo(`
+    public interface TestInterface
+    {
+      string TestProp { get; }
+    }
+`);
+});
+
+it("has getter only", () => {
+  expect(
+    <Wrapper>
+      <InterfaceProperty name="TestProp" type="string" get />
+    </Wrapper>,
+  ).toRenderTo(`
+    public interface TestInterface
+    {
+      string TestProp { get; }
+    }
+  `);
+});
+
+it("has setter only", () => {
+  expect(
+    <Wrapper>
+      <InterfaceProperty name="TestProp" type="string" set />
+    </Wrapper>,
+  ).toRenderTo(`
+    public interface TestInterface
+    {
+      string TestProp { set; }
+    }
+  `);
+});
+it("has getter and setter", () => {
+  expect(
+    <Wrapper>
+      <InterfaceProperty name="TestProp" type="string" get set />
+    </Wrapper>,
+  ).toRenderTo(`
+    public interface TestInterface
+    {
+      string TestProp { get; set; }
+    }
+  `);
+});
+
+it("specify doc comment", () => {
+  expect(
+    <TestNamespace>
+      <InterfaceDeclaration name="Test">
+        <InterfaceProperty
+          name="Method"
+          type="string"
+          get
+          set
+          doc="This is a test"
+        />
+      </InterfaceDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+    interface Test
+    {
+      /// This is a test
+      string Method { get; set; }
+    }
+  `);
+});

package/src/components/interface/property.tsx

@@ -0,0 +1,107 @@
+import {
+  Block,
+  Children,
+  List,
+  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 { DocWhen } from "../doc/comment.jsx";
+
+/** Method modifiers. Can only be one. */
+export interface InterfacePropertyModifiers {
+  readonly new?: boolean;
+}
+
+const getModifiers = makeModifiers<InterfacePropertyModifiers>(["new"]);
+
+// properties for creating a method
+export interface InterfacePropertyProps
+  extends AccessModifiers,
+    InterfacePropertyModifiers {
+  name: string;
+  refkey?: Refkey;
+
+  /** Property type */
+  type: Children;
+
+  /** If property should have a getter */
+  get?: boolean;
+
+  /** If property should have a setter */
+  set?: boolean;
+
+  /** Doc comment */
+  doc?: Children;
+
+  /**
+   * Property initializer
+   * @example `<ClassProperty name="My" get set nullable />`
+   *
+   * ```cs
+   * int? My { get; set; };
+   * ```
+   */
+  nullable?: boolean;
+}
+
+/**
+ * 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();
+  if (scope.kind !== "member" || scope.name !== "interface-decl") {
+    throw new Error(
+      "can't define an interface method outside of an interface scope",
+    );
+  }
+
+  const propertySymbol = new CSharpOutputSymbol(name, {
+    scope,
+    refkeys: props.refkey ?? refkey(props.name),
+  });
+
+  // scope for property declaration
+  const propertyScope = new CSharpMemberScope("property-decl", {
+    owner: propertySymbol,
+  });
+
+  const modifiers = computeModifiersPrefix([
+    getAccessModifier(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} />
+        {modifiers}
+        {props.type}
+        {props.nullable && "?"} {name}{" "}
+        <Block newline inline>
+          <List joiner=" ">
+            {props.get && "get;"}
+            {props.set && "set;"}
+          </List>
+        </Block>
+      </Scope>
+    </MemberDeclaration>
+  );
+}

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

@@ -0,0 +1,187 @@
+import { Children } from "@alloy-js/core/jsx-runtime";
+import { describe, expect, it } from "vitest";
+import { TestNamespace } from "../../../test/utils.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",
+    ] 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";
+    }
+  `);
+});

package/src/components/property/property.tsx

@@ -0,0 +1,146 @@
+import {
+  Block,
+  Children,
+  code,
+  List,
+  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 { DocWhen } from "../doc/comment.jsx";
+
+/** Property modifiers. */
+export interface PropertyModifiers {
+  readonly new?: boolean;
+  readonly static?: boolean;
+  readonly virtual?: boolean;
+  readonly sealed?: boolean;
+  readonly override?: boolean;
+  readonly abstract?: boolean;
+  readonly extern?: boolean;
+  readonly readonly?: boolean;
+}
+
+const getModifiers = makeModifiers<PropertyModifiers>([
+  "new",
+  "static",
+  "virtual",
+  "sealed",
+  "override",
+  "abstract",
+  "extern",
+  "readonly",
+]);
+
+/** Properties for {@link Property} component */
+export interface PropertyProps extends AccessModifiers, PropertyModifiers {
+  name: string;
+  refkey?: Refkey;
+
+  /** Property type */
+  type: Children;
+
+  /** If property should have a getter */
+  get?: boolean;
+
+  /** If property should have a setter */
+  set?: boolean;
+
+  /** If property should only be set on the type creation */
+  init?: boolean;
+
+  /** Doc comment */
+  doc?: Children;
+
+  /**
+   * Property initializer
+   * @example `<ClassProperty name="My" get set nullable />`
+   *
+   * ```cs
+   * int? My { get; set; };
+   * ```
+   */
+  nullable?: boolean;
+
+  /**
+   * Property initializer
+   * @example `<ClassProperty name="My" get set init={42} />`
+   *
+   * ```cs
+   * int My { get; set; } = 42;
+   * ```
+   */
+  initializer?: Children;
+}
+
+/**
+ * Render a C# class property.
+ *
+ * @example `<ClassProperty public name="My" get set  />`
+ *
+ * ```cs
+ * public int My { get; set; };
+ * ```
+ */
+export function Property(props: PropertyProps) {
+  const name = useCSharpNamePolicy().getName(props.name, "class-property");
+  const scope = useCSharpScope();
+  if (
+    scope.kind !== "member" ||
+    (scope.name !== "class-decl" && scope.name !== "record-decl")
+  ) {
+    throw new Error(
+      "can't define an interface method outside of an interface scope",
+    );
+  }
+
+  const propertySymbol = new CSharpOutputSymbol(name, {
+    scope,
+    refkeys: props.refkey ?? refkey(props.name),
+  });
+
+  // scope for property declaration
+  const propertyScope = new CSharpMemberScope("property-decl", {
+    owner: propertySymbol,
+  });
+
+  const modifiers = computeModifiersPrefix([
+    getAccessModifier(props),
+    getModifiers(props),
+  ]);
+
+  if (props.init && props.set) {
+    throw new Error(
+      `Cannot use 'init' and 'set' together on property '${name}'`,
+    );
+  }
+  // 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} />
+        {modifiers}
+        {props.type}
+        {props.nullable && "?"} {name}{" "}
+        <Block newline inline>
+          <List joiner=" ">
+            {props.get && "get;"}
+            {props.set && "set;"}
+            {props.init && "init;"}
+          </List>
+        </Block>
+        {props.initializer && code` = ${props.initializer};`}
+      </Scope>
+    </MemberDeclaration>
+  );
+}

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

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+import { TestNamespace } from "../../../test/utils.jsx";
+import { Property } from "../property/property.jsx";
+import { RecordDeclaration } from "./declaration.jsx";
+
+it("declares class with no members", () => {
+  expect(
+    <TestNamespace>
+      <RecordDeclaration name="TestRecord" />
+    </TestNamespace>,
+  ).toRenderTo(`
+      record TestRecord;
+  `);
+});
+
+describe("modifiers", () => {
+  it.each(["public", "private", "internal"])("%s", (mod) => {
+    expect(
+      <TestNamespace>
+        <RecordDeclaration {...{ [mod]: true }} name="TestRecord" />
+      </TestNamespace>,
+    ).toRenderTo(`
+        ${mod} record TestRecord;
+    `);
+  });
+
+  it.each(["partial"])("%s", (mod) => {
+    expect(
+      <TestNamespace>
+        <RecordDeclaration {...{ [mod]: true }} name="TestRecord" />
+      </TestNamespace>,
+    ).toRenderTo(`
+        ${mod} record TestRecord;
+    `);
+  });
+
+  it("combines modifiers", () => {
+    expect(
+      <TestNamespace>
+        <RecordDeclaration public partial name="TestRecord" />
+      </TestNamespace>,
+    ).toRenderTo(`
+        public partial record TestRecord;
+    `);
+  });
+});
+
+it("specify doc comment", () => {
+  expect(
+    <TestNamespace>
+      <RecordDeclaration name="TestRecord" doc="This is a test" />
+    </TestNamespace>,
+  ).toRenderTo(`
+    /// This is a test
+    record TestRecord;
+  `);
+});
+
+it("specify class property inside", () => {
+  expect(
+    <TestNamespace>
+      <RecordDeclaration name="TestRecord" doc="This is a test">
+        <Property name="Prop" get set type="string" />
+      </RecordDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+    /// This is a test
+    record TestRecord
+    {
+      string Prop { get; set; }
+    }
+  `);
+});