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

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; }
+    }
+  `);
+});

package/src/components/record/declaration.tsx

@@ -0,0 +1,109 @@
+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";
+
+export interface RecordModifiers {
+  readonly partial?: boolean;
+}
+
+const getRecordModifiers = makeModifiers<RecordModifiers>(["partial"]);
+
+/** Props to use the {@link RecordDeclaration} component */
+export interface RecordDeclarationProps
+  extends Omit<core.DeclarationProps, "nameKind">,
+    AccessModifiers,
+    RecordModifiers {
+  name: string;
+
+  /** Doc comment */
+  doc?: core.Children;
+  refkey?: core.Refkey;
+  typeParameters?: Record<string, core.Refkey>;
+}
+
+/**
+ * CSharp record declaration.
+ * @example
+ * ```tsx
+ * <RecordDeclaration public name="IMyRecord">
+ *   <RecordMember public name="MyProperty" type="int" />
+ *   <RecordMethod public name="MyMethod" returnType="void">
+ *     <Parameter name="value" type="int" />
+ *   </RecordMethod>
+ * </RecordDeclaration>
+ * ```
+ * This will produce:
+ * ```csharp
+ * public record MyIface
+ * {
+ *   public int MyProperty { get; set; }
+ *   public void MyMethod(int value);
+ * }
+ * ```
+ */
+export function RecordDeclaration(props: RecordDeclarationProps) {
+  const name = useCSharpNamePolicy().getName(props.name!, "record");
+
+  const thisRecordSymbol = new CSharpOutputSymbol(name, {
+    refkeys: props.refkey,
+  });
+
+  // this creates a new scope for the record definition.
+  // members will automatically "inherit" this scope so
+  // that refkeys to them will produce the fully-qualified
+  // name e.g. Foo.Bar.
+  const thisRecordScope = new CSharpMemberScope("record-decl", {
+    owner: thisRecordSymbol,
+  });
+
+  let typeParams: core.Children;
+  if (props.typeParameters) {
+    const typeParamNames = new Array<string>();
+    for (const entry of Object.entries(props.typeParameters)) {
+      typeParamNames.push(
+        useCSharpNamePolicy().getName(entry[0], "type-parameter"),
+      );
+      // create a symbol for each type param so its
+      // refkey resolves to the type param's name
+      new CSharpOutputSymbol(entry[0], {
+        scope: thisRecordScope,
+        refkeys: entry[1],
+      });
+    }
+    typeParams = (
+      <group>
+        {"<"}
+        <core.For each={typeParamNames} comma line>
+          {(name) => name}
+        </core.For>
+        {">"}
+      </group>
+    );
+  }
+
+  const modifiers = computeModifiersPrefix([
+    getAccessModifier(props),
+    getRecordModifiers(props),
+  ]);
+  return (
+    <core.Declaration symbol={thisRecordSymbol}>
+      <DocWhen doc={props.doc} />
+      {modifiers}record <Name />
+      {typeParams}
+      {props.children ?
+        <core.Block newline>
+          <core.Scope value={thisRecordScope}>{props.children}</core.Scope>
+        </core.Block>
+      : ";"}
+    </core.Declaration>
+  );
+}

package/src/components/stc/index.ts

@@ -1,11 +1,11 @@
 import * as core from "@alloy-js/core";
 import * as base from "../index.js";
 
-export const Class = core.stc(base.Class);
+export const ClassDeclaration = core.stc(base.ClassDeclaration);
 export const ClassConstructor = core.stc(base.ClassConstructor);
 export const ClassMember = core.stc(base.ClassMember);
 export const ClassMethod = core.stc(base.ClassMethod);
-export const Enum = core.stc(base.Enum);
+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);

package/src/components/type-parameters/type-parameter-constraints.test.tsx

@@ -0,0 +1,93 @@
+import { expect, it } from "vitest";
+import { TypeParameterConstraints } from "./type-parameter-constraints.jsx";
+
+it("renders nothing if there is no constraints", () => {
+  expect(<TypeParameterConstraints parameters={["A", "B"]} />).toRenderTo(``);
+});
+
+it("renders inline if there is only one", () => {
+  expect(
+    <>
+      {"code()"}
+      <TypeParameterConstraints
+        parameters={[{ name: "A", constraints: "string" }]}
+      />
+    </>,
+  ).toRenderTo(`
+    code() where A : string
+  `);
+});
+
+it("renders multiple constraints", () => {
+  expect(
+    <>
+      {"code()"}
+      <TypeParameterConstraints
+        parameters={[{ name: "A", constraints: ["string", "int"] }]}
+      />
+    </>,
+  ).toRenderTo(`
+    code() where A : string, int
+  `);
+});
+
+it("renders newline if constraint is very long", () => {
+  expect(
+    <>
+      {"code()"}
+      <TypeParameterConstraints
+        parameters={[
+          {
+            name: "ThisIsQuiteALongName",
+            constraints: "VeryLongBuilderFactorySingletonThatShouldBeSplit",
+          },
+        ]}
+      />
+    </>,
+  ).toRenderTo(`
+    code()
+      where ThisIsQuiteALongName : VeryLongBuilderFactorySingletonThatShouldBeSplit
+  `);
+});
+
+it("renders multiple constraints on new lines if they are very long", () => {
+  expect(
+    <>
+      {"code()"}
+      <TypeParameterConstraints
+        parameters={[
+          {
+            name: "A",
+            constraints: [
+              "IVeryLongBuilderFactorySingletonThatShouldBeSplitA",
+              "IVeryLongBuilderFactorySingletonThatShouldBeSplitB",
+            ],
+          },
+        ]}
+      />
+    </>,
+  ).toRenderTo(`
+    code()
+      where A :
+        IVeryLongBuilderFactorySingletonThatShouldBeSplitA,
+        IVeryLongBuilderFactorySingletonThatShouldBeSplitB
+  `);
+});
+
+it("declare type parameters using parameters", () => {
+  expect(
+    <>
+      {"code()"}
+      <TypeParameterConstraints
+        parameters={[
+          { name: "A", constraints: "string" },
+          { name: "B", constraints: "string" },
+        ]}
+      />
+    </>,
+  ).toRenderTo(`
+    code()
+      where A : string
+      where B : string
+  `);
+});

package/src/components/type-parameters/type-parameter-constraints.tsx

@@ -0,0 +1,46 @@
+import { Children, code, For, Indent } from "@alloy-js/core";
+import { TypeParameterProps } from "./type-parameter.jsx";
+import { normalizeParameters } from "./type-parameters.jsx";
+
+export interface TypeParameterConstraintsProps {
+  /** Parameters */
+  parameters: (TypeParameterProps | string)[];
+}
+
+export function TypeParameterConstraints(
+  props: TypeParameterConstraintsProps,
+): Children {
+  const parameters = normalizeParameters(props.parameters);
+  if (!parameters.some((x) => x.constraints)) {
+    return null;
+  }
+  return (
+    <group>
+      <Indent line>
+        <For each={parameters} hardline>
+          {(param) => <TypeParameterConstraint {...param} />}
+        </For>
+      </Indent>
+    </group>
+  );
+}
+
+function TypeParameterConstraint(props: TypeParameterProps): Children {
+  const constraints = arrayify(props.constraints);
+  return (
+    <>
+      where {code`${props.name} : `}
+      <group>
+        <Indent softline>
+          <For each={constraints} comma line>
+            {(constraint) => code`${constraint}`}
+          </For>
+        </Indent>
+      </group>
+    </>
+  );
+}
+
+function arrayify<T>(value: T | T[]): T[] {
+  return Array.isArray(value) ? value : [value];
+}

package/src/components/type-parameters/type-parameter.tsx

@@ -0,0 +1,35 @@
+import { Children, MemberDeclaration, refkey, Refkey } from "@alloy-js/core";
+import { useCSharpNamePolicy } from "../../name-policy.js";
+import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
+import { useCSharpScope } from "../../symbols/scopes.js";
+
+/**
+ * Information for a TypeScript generic type parameter.
+ */
+export interface TypeParameterProps {
+  /**
+   * The name of the type parameter.
+   */
+  readonly name: string;
+
+  /**
+   * The parameter constraint
+   */
+  readonly constraints?: Children | Children[];
+
+  /**
+   * A refkey or array of refkeys for this type parameter.
+   */
+  readonly refkey?: Refkey | Refkey[];
+}
+
+export function TypeParameter(props: TypeParameterProps) {
+  const name = useCSharpNamePolicy().getName(props.name, "type-parameter");
+  const scope = useCSharpScope();
+  const symbol = new CSharpOutputSymbol(name, {
+    scope,
+    refkeys: props.refkey ?? refkey(props.name),
+  });
+
+  return <MemberDeclaration symbol={symbol}>{name}</MemberDeclaration>;
+}

package/src/components/type-parameters/type-parameters.test.tsx

@@ -0,0 +1,46 @@
+import { expect, it } from "vitest";
+import { TestNamespace } from "../../../test/utils.jsx";
+import { TypeParameters } from "./type-parameters.jsx";
+
+it("render one", () => {
+  expect(
+    <TestNamespace>
+      <TypeParameters parameters={["A"]} />
+    </TestNamespace>,
+  ).toRenderTo(`<A>`);
+});
+
+it("render very long", () => {
+  expect(
+    <TestNamespace>
+      <TypeParameters
+        parameters={[
+          "SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesA",
+          "SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesB",
+        ]}
+      />
+    </TestNamespace>,
+  ).toRenderTo(
+    `
+    <
+      SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesA,
+      SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesB>
+    `,
+  );
+});
+
+it("declare type parameters using parameters names", () => {
+  expect(
+    <TestNamespace>
+      <TypeParameters parameters={["A", "B"]} />
+    </TestNamespace>,
+  ).toRenderTo(`<A, B>`);
+});
+
+it("declare type parameters using parameters", () => {
+  expect(
+    <TestNamespace>
+      <TypeParameters parameters={[{ name: "A" }, { name: "B" }]} />
+    </TestNamespace>,
+  ).toRenderTo(`<A, B>`);
+});

package/src/components/type-parameters/type-parameters.tsx

@@ -0,0 +1,63 @@
+import { For, Indent, taggedComponent } from "@alloy-js/core";
+import { TypeParameter, TypeParameterProps } from "./type-parameter.jsx";
+
+export const typeParametersTag = Symbol.for("csharp.type-parameters");
+
+export interface TypeParametersProps {
+  /** Parameters */
+  parameters: (TypeParameterProps | string)[];
+}
+
+/**
+ * Represent type parameters
+ *
+ * @example
+ * ```ts
+ * <A, B extends string>
+ * ```
+ */
+export const TypeParameters = taggedComponent(
+  typeParametersTag,
+  function TypeParameters(props: TypeParametersProps) {
+    const typeParameters = normalizeParameters(props.parameters);
+
+    return (
+      <>
+        {"<"}
+        <group>
+          <Indent softline>
+            <For each={typeParameters} comma line>
+              {(param) => <TypeParameter {...param} />}
+            </For>
+          </Indent>
+        </group>
+        {">"}
+      </>
+    );
+  },
+);
+
+export function normalizeParameters(
+  parameters: (TypeParameterProps | string)[],
+): TypeParameterProps[] {
+  return parameters.map((param) => {
+    if (typeof param === "string") {
+      return { name: param };
+    }
+    return param;
+  });
+}
+
+// export function declareParameter(
+//   parameters: TypeParameterProps[],
+// ): TypeParameterProps[] {
+//   return parameters.map((param) => {
+//     return {
+//       ...param,
+//       symbol: new CSharpOutputSymbol(entry[0], {
+//         scope: thisClassScope,
+//         refkeys: entry[1],
+//       }),
+//     };
+//   });
+// }

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

@@ -0,0 +1,59 @@
+import { List, refkey } from "@alloy-js/core";
+import { expect, it } from "vitest";
+import { TestNamespace } from "../../../test/utils.jsx";
+import { SourceFile } from "../SourceFile.jsx";
+import { VarDeclaration } from "./declaration.jsx";
+
+it("declares var without type", () => {
+  expect(
+    <TestNamespace>
+      <VarDeclaration name="testVar">42</VarDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+      var testVar = 42;
+  `);
+});
+
+it("declares var with type", () => {
+  expect(
+    <TestNamespace>
+      <VarDeclaration name="testVar" type="int">
+        42
+      </VarDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+      int testVar = 42;
+  `);
+});
+
+it("name variables camel case", () => {
+  expect(
+    <TestNamespace>
+      <VarDeclaration name="test_var">42</VarDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+      var testVar = 42;
+  `);
+});
+
+it("links refkey", () => {
+  const key = refkey();
+  expect(
+    <TestNamespace>
+      <SourceFile path="test.cs">
+        <List>
+          <VarDeclaration name="testVar" refkey={key}>
+            42
+          </VarDeclaration>
+          <VarDeclaration name="testVar2">{key}</VarDeclaration>
+        </List>
+      </SourceFile>
+    </TestNamespace>,
+  ).toRenderTo(`
+      namespace TestCode
+      {
+        var testVar = 42;
+        var testVar2 = testVar;
+      }
+  `);
+});

package/src/components/var/declaration.tsx

@@ -0,0 +1,47 @@
+import { Children, DeclarationProps, Name, Refkey } from "@alloy-js/core";
+import { useCSharpNamePolicy } from "../../name-policy.js";
+import { Declaration } from "../Declaration.jsx";
+
+/** Props for {@link VarDeclaration} component */
+export interface VarDeclarationProps
+  extends Omit<DeclarationProps, "nameKind"> {
+  /** Variable name */
+  name: string;
+  /** Type of the variable declaration. If not specified, defaults to "var" */
+  type?: Children;
+  /** Variable refkey */
+  refkey?: Refkey;
+  /** Variable value */
+  children?: Children;
+}
+
+/**
+ * Render a variable declaration
+ *
+ * @example with var
+ * ```tsx
+ * <VarDeclaration name="myVar">42</VarDeclaration>
+ * ```
+ * This will render:
+ * ```csharp
+ * var myVar = 42;
+ * ```
+ *
+ * @example with type
+ * ```tsx
+ * <VarDeclaration name="myVar" type="int">42</VarDeclaration>
+ * ```
+ * This will render:
+ * ```csharp
+ * int myVar = 42;
+ * ```
+ */
+export function VarDeclaration(props: VarDeclarationProps) {
+  const name = useCSharpNamePolicy().getName(props.name, "variable");
+
+  return (
+    <Declaration name={name} refkey={props.refkey}>
+      {props.type ?? "var"} <Name /> = {props.children};
+    </Declaration>
+  );
+}

package/src/modifiers.ts

@@ -1,51 +1,25 @@
 // the possible C# access modifiers
 // https://learn.microsoft.com/dotnet/csharp/programming-guide/classes-and-structs/access-modifiers
-export type AccessModifier =
-  | "public"
-  | "protected"
-  | "private"
-  | "internal"
-  | "protected-internal"
-  | "private-protected"
-  | "file";
 
-// maps the above access modifier value to its C# syntax.
-// note that the C# keyword includes a trailing space
-const accessModifierLookup: Record<AccessModifier, string> = {
-  public: "public ",
-  protected: "protected ",
-  private: "private ",
-  internal: "internal ",
-  "protected-internal": "protected internal ",
-  "private-protected": "private protected ",
-  file: "file ",
-};
-
-// returns the C# syntax for the specified access modifier.
-// if no access modifier is specified, the empty string is returned.
-export function getAccessModifier(accessModifier?: AccessModifier): string {
-  return accessModifier ? accessModifierLookup[accessModifier] : "";
+/** Access modifiers.  */
+export interface AccessModifiers {
+  readonly public?: boolean;
+  readonly protected?: boolean;
+  readonly private?: boolean;
+  readonly internal?: boolean;
+  readonly file?: boolean;
 }
 
-export type MethodModifier = "abstract" | "sealed" | "static" | "virtual";
-
-// maps the above method modifier value to its C# syntax.
-// note that the C# keyword includes a trailing space
-const methodModifierLookup: Record<MethodModifier, string> = {
-  abstract: "abstract ",
-  sealed: "sealed ",
-  static: "static ",
-  virtual: "virtual ",
-};
-
-// returns the C# syntax for the specified method modifier.
-// if no method modifier is specified, the empty string is returned.
-export function getMethodModifier(methodModifier?: MethodModifier): string {
-  return methodModifier ? methodModifierLookup[methodModifier] : "";
-}
+export const getAccessModifier = makeModifiers<AccessModifiers>([
+  "public",
+  "protected",
+  "private",
+  "internal",
+  "file",
+]);
 
 export function getAsyncModifier(async?: boolean): string {
-  return async ? "async " : "";
+  return async ? "async" : "";
 }
 
 /** Resolve the modifier prefix */
@@ -53,5 +27,14 @@ export function computeModifiersPrefix(
   modifiers: Array<string | undefined>,
 ): string {
   const resolved = modifiers.filter((x) => x);
-  return resolved.length > 0 ? resolved.join("") : "";
+  return resolved.length > 0 ? resolved.join(" ") + " " : "";
+}
+
+export function makeModifiers<T>(obj: Array<keyof T>) {
+  return (data: T) => {
+    return obj
+      .map((key) => (data[key] ? key : undefined))
+      .filter((x) => x)
+      .join(" ");
+  };
 }