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

package/src/components/field/field.test.tsx

@@ -0,0 +1,122 @@
+import { List } from "@alloy-js/core";
+import { describe, expect, it } from "vitest";
+import { TestNamespace } from "../../../test/utils.jsx";
+import { ClassDeclaration } from "../ClassDeclaration.jsx";
+import { Field } from "./field.jsx";
+
+function Wrapper(props: { children: any }) {
+  return (
+    <TestNamespace>
+      <ClassDeclaration public name="TestClass">
+        {props.children}
+      </ClassDeclaration>
+    </TestNamespace>
+  );
+}
+it("declares multiple fields", () => {
+  expect(
+    <Wrapper>
+      <List>
+        <Field public name="MemberOne" type="string" />
+        <Field public name="MemberTwo" type="int" />
+      </List>
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+      public string MemberOne;
+      public int MemberTwo;
+    }
+  `);
+});
+
+describe("modifiers", () => {
+  describe("access modifiers", () => {
+    it.each(["public", "private", "protected", "internal"] as const)(
+      "%s",
+      (accessModifier) => {
+        expect(
+          <Wrapper>
+            <Field
+              {...{ [accessModifier]: true }}
+              name="TestProp"
+              type="string"
+            />
+          </Wrapper>,
+        ).toRenderTo(`
+        public class TestClass
+        {
+          ${accessModifier} string ${accessModifier === "private" ? "_testProp" : "TestProp"};
+        }
+      `);
+      },
+    );
+  });
+
+  describe("modifiers", () => {
+    it.each(["new", "static", "readonly", "volatile"] as const)(
+      "%s",
+      (methodModifier) => {
+        expect(
+          <Wrapper>
+            <Field
+              {...{ [methodModifier]: true }}
+              name="TestField"
+              type="string"
+            />
+          </Wrapper>,
+        ).toRenderTo(`
+        public class TestClass
+        {
+          ${methodModifier} string _testField;
+        }
+      `);
+      },
+    );
+  });
+
+  it("combine modifiers", () => {
+    expect(
+      <Wrapper>
+        <Field public new name="TestField" type="string" />
+      </Wrapper>,
+    ).toRenderTo(`
+        public class TestClass
+        {
+          public new string TestField;
+        }
+      `);
+  });
+});
+
+describe("naming", () => {
+  it("public field are PascalCase", () => {
+    expect(
+      <Wrapper>
+        <List>
+          <Field public name="member_one" type="string" />
+        </List>
+      </Wrapper>,
+    ).toRenderTo(`
+      public class TestClass
+      {
+        public string MemberOne;
+      }
+    `);
+  });
+
+  it("private field are camelCase with _ prefix", () => {
+    expect(
+      <Wrapper>
+        <List>
+          <Field private name="member_one" type="string" />
+        </List>
+      </Wrapper>,
+    ).toRenderTo(`
+    public class TestClass
+    {
+      private string _memberOne;
+    }
+  `);
+  });
+});

package/src/components/field/field.tsx

@@ -0,0 +1,70 @@
+import { Children, Declaration, Name, refkey, Refkey } from "@alloy-js/core";
+import {
+  AccessModifiers,
+  computeModifiersPrefix,
+  getAccessModifier,
+  makeModifiers,
+} from "../../modifiers.js";
+import { CSharpElements, useCSharpNamePolicy } from "../../name-policy.js";
+import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
+import { useCSharpScope } from "../../symbols/scopes.js";
+import { DocWhen } from "../doc/comment.jsx";
+
+/** Field modifiers. */
+export interface FieldModifiers {
+  readonly new?: boolean;
+  readonly static?: boolean;
+  readonly readonly?: boolean;
+  readonly volatile?: boolean;
+}
+
+const getModifiers = makeModifiers<FieldModifiers>([
+  "new",
+  "static",
+  "readonly",
+  "volatile",
+]);
+
+export interface FieldProps extends AccessModifiers, FieldModifiers {
+  name: string;
+  type: Children;
+  refkey?: Refkey;
+  /** Doc comment */
+  doc?: Children;
+}
+
+/** Render a c# field */
+export function Field(props: FieldProps) {
+  let nameElement: CSharpElements = "class-member-private";
+  if (props.public || props.protected || props.internal) {
+    nameElement = "class-member-public";
+  }
+  const name = useCSharpNamePolicy().getName(props.name, nameElement);
+  const scope = useCSharpScope();
+  if (
+    scope.kind !== "member" ||
+    (scope.name !== "class-decl" && scope.name !== "struct-decl")
+  ) {
+    throw new Error(
+      "can't define a class member outside of a class or struct scope",
+    );
+  }
+
+  const memberSymbol = new CSharpOutputSymbol(name, {
+    scope,
+    refkeys: props.refkey ?? refkey(props.name),
+  });
+
+  const modifiers = computeModifiersPrefix([
+    getAccessModifier(props),
+    getModifiers(props),
+  ]);
+
+  return (
+    <Declaration symbol={memberSymbol}>
+      <DocWhen doc={props.doc} />
+      {modifiers}
+      {props.type} <Name />;
+    </Declaration>
+  );
+}

package/src/components/index.ts

@@ -5,6 +5,7 @@ export * from "./Declaration.js";
 export * from "./doc/comment.jsx";
 export * from "./doc/from-markdown.jsx";
 export * from "./EnumDeclaration.jsx";
+export * from "./field/field.jsx";
 export * from "./interface/declaration.js";
 export * from "./interface/method.js";
 export * from "./interface/property.js";

package/src/components/stc/index.ts

@@ -3,7 +3,7 @@ import * as base from "../index.js";
 
 export const ClassDeclaration = core.stc(base.ClassDeclaration);
 export const Constructor = core.stc(base.Constructor);
-export const ClassMember = core.stc(base.ClassMember);
+export const Field = core.stc(base.Field);
 export const ClassMethod = core.stc(base.Method);
 export const EnumDeclaration = core.stc(base.EnumDeclaration);
 export const EnumMember = core.stc(base.EnumMember);

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

@@ -3,6 +3,7 @@ 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 { Field } from "../field/field.jsx";
 import { Method } from "../method/method.jsx";
 import { Property } from "../property/property.jsx";
 import { SourceFile } from "../SourceFile.jsx";
@@ -167,3 +168,32 @@ it("define constructor", () => {
     }
   `);
 });
+
+it("defines fields", () => {
+  expect(
+    <TestNamespace>
+      <StructDeclaration public name="TestClass">
+        <List>
+          <Field public name="MemberOne" type="string" />
+          <Field public name="MemberTwo" type="int" />
+        </List>
+      </StructDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+    public struct TestClass
+    {
+      public string MemberOne;
+      public int MemberTwo;
+    }
+  `);
+});
+
+it("define multiple interface types", () => {
+  expect(
+    <TestNamespace>
+      <StructDeclaration name="Test" interfaceTypes={["Foo", "Bar"]} />
+    </TestNamespace>,
+  ).toRenderTo(`
+      struct Test : Foo, Bar;
+  `);
+});

package/src/components/struct/declaration.tsx

@@ -1,4 +1,5 @@
 import * as core from "@alloy-js/core";
+import { join } from "@alloy-js/core";
 import {
   AccessModifiers,
   computeModifiersPrefix,
@@ -71,6 +72,9 @@ export interface StructDeclarationProps
    * ```
    */
   attributes?: AttributesProp;
+
+  /** Interfaces this struct implements */
+  interfaceTypes?: core.Children[];
 }
 
 /**
@@ -108,6 +112,12 @@ export function StructDeclaration(props: StructDeclarationProps) {
     getAccessModifier(props),
     getStructModifiers(props),
   ]);
+
+  const base =
+    props.interfaceTypes && props.interfaceTypes.length > 0 ?
+      <> : {join(props.interfaceTypes, { joiner: ", " })}</>
+    : null;
+
   return (
     <core.Declaration symbol={thisStructSymbol}>
       <DocWhen doc={props.doc} />
@@ -116,6 +126,7 @@ export function StructDeclaration(props: StructDeclarationProps) {
       {props.typeParameters && (
         <TypeParameters parameters={props.typeParameters} />
       )}
+      {base}
       {props.typeParameters && (
         <TypeParameterConstraints parameters={props.typeParameters} />
       )}

package/src/name-policy.ts

@@ -36,6 +36,8 @@ export function createCSharpNamePolicy(): core.NamePolicy<CSharpElements> {
         return changecase.pascalCase(name);
       case "constant":
         return changecase.constantCase(name);
+      case "class-member-private":
+        return `_${changecase.camelCase(name)}`;
       default:
         return changecase.camelCase(name);
     }