@typespec/emitter-framework 0.9.0-dev.1 → 0.9.0-dev.3

package/src/csharp/components/utils/refkey.ts

@@ -0,0 +1,36 @@
+import { refkey as ayRefkey, type Refkey } from "@alloy-js/core";
+
+const refKeyPrefix = Symbol.for("emitter-framework:csharp");
+
+/**
+ * A wrapper around `refkey` that uses a custom symbol to avoid collisions with
+ * other libraries that use `refkey`.
+ *
+ * @remarks
+ *
+ * The underlying refkey function is called with the {@link refKeyPrefix} symbol as the first argument.
+ *
+ * @param args The parameters of the refkey.
+ * @returns A refkey object that can be used to identify the value.
+ */
+export function efRefkey(...args: unknown[]): Refkey {
+  if (args.length === 0) {
+    return ayRefkey(); // Generates a unique refkey
+  }
+  return ayRefkey(refKeyPrefix, ...args);
+}
+
+/**
+ * Creates a refkey for a declaration by combining the provided refkey with an internal
+ * refkey generated from the provided arguments.
+ *
+ * @param refkey The refkey provided by the user to be passed as is.
+ * @param args The parameters of the refkey.
+ * @returns An array of refkeys that can be passed to an Alloy declaration.
+ */
+export function declarationRefkeys(refkey?: Refkey | Refkey[], ...args: unknown[]): Refkey[] {
+  if (refkey) {
+    return [refkey, efRefkey(...args)].flat();
+  }
+  return [efRefkey(...args)];
+}

package/src/csharp/index.ts

@@ -0,0 +1 @@
+export * from "./components/index.js";

package/test/csharp/components/class-declaration.test.tsx

@@ -0,0 +1,344 @@
+import { render } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import * as cs from "@alloy-js/csharp";
+import { Namespace, SourceFile } from "@alloy-js/csharp";
+import { Enum, Interface, Model } from "@typespec/compiler";
+import { BasicTestRunner } from "@typespec/compiler/testing";
+import { beforeEach, describe, it } from "vitest";
+import { Output } from "../../../src/core/index.js";
+import { ClassDeclaration, EnumDeclaration } from "../../../src/csharp/index.js";
+import { createEmitterFrameworkTestRunner } from "../test-host.js";
+import { assertFileContents } from "../utils.js";
+
+let runner: BasicTestRunner;
+
+beforeEach(async () => {
+  runner = await createEmitterFrameworkTestRunner();
+});
+
+it("renders an empty class declaration", async () => {
+  const { TestModel } = (await runner.compile(`
+    @test model TestModel {}
+  `)) as { TestModel: Model };
+
+  const res = render(
+    <Output program={runner.program}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <ClassDeclaration type={TestModel} />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          class TestModel
+          {
+
+          }
+      }
+    `,
+  );
+});
+
+it("renders a class declaration with properties", async () => {
+  const { TestModel } = (await runner.compile(`
+    @test model TestModel {
+      @test Prop1: string;
+      @test Prop2: int32;
+    }
+  `)) as { TestModel: Model };
+
+  const res = render(
+    <Output program={runner.program}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <ClassDeclaration type={TestModel} />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          class TestModel
+          {
+              public string Prop1
+              {
+                  get;
+                  set;
+              }
+              public int Prop2
+              {
+                  get;
+                  set;
+              }
+          }
+      }
+    `,
+  );
+});
+
+it("can override class name", async () => {
+  const { TestModel } = (await runner.compile(`
+    @test model TestModel {}
+  `)) as { TestModel: Model };
+
+  const res = render(
+    <Output program={runner.program}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <ClassDeclaration type={TestModel} name="CustomClassName" />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          class CustomClassName
+          {
+
+          }
+      }
+    `,
+  );
+});
+
+it("renders a class with access modifiers", async () => {
+  const { TestModel } = (await runner.compile(`
+    @test model TestModel {
+    }
+  `)) as { TestModel: Model };
+
+  const res = render(
+    <Output program={runner.program}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <ClassDeclaration type={TestModel} accessModifier="protected" />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          protected class TestModel
+          {
+
+          }
+      }
+    `,
+  );
+});
+
+describe("from an interface", () => {
+  it("renders an empty class", async () => {
+    const { TestInterface } = (await runner.compile(`
+    @test interface TestInterface {
+    }
+  `)) as { TestInterface: Interface };
+
+    const res = render(
+      <Output program={runner.program}>
+        <Namespace name="TestNamespace">
+          <SourceFile path="test.cs">
+            <ClassDeclaration type={TestInterface} />
+          </SourceFile>
+        </Namespace>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+      namespace TestNamespace
+      {
+          class TestInterface
+          {
+
+          }
+      }
+    `,
+    );
+  });
+
+  it("renders a class with operations", async () => {
+    const { TestInterface } = (await runner.compile(`
+    @test interface TestInterface {
+      op getName(id: string): string;
+    }
+  `)) as { TestInterface: Interface };
+
+    const res = render(
+      <Output program={runner.program} namePolicy={cs.createCSharpNamePolicy()}>
+        <Namespace name="TestNamespace">
+          <SourceFile path="test.cs">
+            <ClassDeclaration type={TestInterface} />
+          </SourceFile>
+        </Namespace>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+      namespace TestNamespace
+      {
+          class TestInterface
+          {
+              public abstract string GetName(string id) {}
+          }
+      }
+    `,
+    );
+  });
+});
+
+it("renders a class with model members", async () => {
+  const { TestModel, TestReference } = (await runner.compile(`
+    @test model TestReference {
+    }
+    @test model TestModel {
+      @test prop1: TestReference;
+    }
+  `)) as { TestModel: Model; TestReference: Model };
+
+  const res = render(
+    <Output program={runner.program} namePolicy={cs.createCSharpNamePolicy()}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <ClassDeclaration type={TestReference} />
+          <hbr />
+          <ClassDeclaration type={TestModel} />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          class TestReference
+          {
+
+          }
+          class TestModel
+          {
+              public TestReference Prop1
+              {
+                  get;
+                  set;
+              }
+          }
+      }
+    `,
+  );
+});
+
+it("renders a class with enum members", async () => {
+  const { TestModel, TestEnum } = (await runner.compile(`
+    @test enum TestEnum {
+      Value1;
+      Value2;
+    }
+    @test model TestModel {
+      @test prop1: TestEnum;
+    }
+  `)) as { TestModel: Model; TestEnum: Enum };
+
+  const res = render(
+    <Output program={runner.program} namePolicy={cs.createCSharpNamePolicy()}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <EnumDeclaration type={TestEnum} />
+          <hbr />
+          <ClassDeclaration type={TestModel} />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          public enum TestEnum
+          {
+              Value1,
+              Value2
+          }
+          class TestModel
+          {
+              public TestEnum Prop1
+              {
+                  get;
+                  set;
+              }
+          }
+      }
+    `,
+  );
+});
+
+it("renders a class with string enums", async () => {
+  const { TestModel, TestEnum } = (await runner.compile(`
+    @test enum TestEnum {
+      Value1;
+      Value2;
+    }
+    @test model TestModel {
+      @test prop1: TestEnum;
+    }
+  `)) as { TestModel: Model; TestEnum: Enum };
+
+  const res = render(
+    <Output program={runner.program} namePolicy={cs.createCSharpNamePolicy()}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <EnumDeclaration type={TestEnum} />
+          <hbr />
+          <ClassDeclaration type={TestModel} />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          public enum TestEnum
+          {
+              Value1,
+              Value2
+          }
+          class TestModel
+          {
+              public TestEnum Prop1
+              {
+                  get;
+                  set;
+              }
+          }
+      }
+    `,
+  );
+});

package/test/csharp/components/enum-declaration.test.tsx

@@ -0,0 +1,296 @@
+import { render } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import * as cs from "@alloy-js/csharp";
+import { Namespace, SourceFile } from "@alloy-js/csharp";
+import { Enum } from "@typespec/compiler";
+import { BasicTestRunner } from "@typespec/compiler/testing";
+import { beforeEach, it } from "vitest";
+import { Output } from "../../../src/core/index.js";
+import { EnumDeclaration } from "../../../src/csharp/index.js";
+import { createEmitterFrameworkTestRunner } from "../test-host.js";
+import { assertFileContents } from "../utils.js";
+
+let runner: BasicTestRunner;
+
+beforeEach(async () => {
+  runner = await createEmitterFrameworkTestRunner();
+});
+
+it("renders a basic enum declaration", async () => {
+  const { TestEnum } = (await runner.compile(`
+    @test enum TestEnum {
+      Value1;
+      Value2;
+      Value3;
+    }
+  `)) as { TestEnum: Enum };
+
+  const res = render(
+    <Output program={runner.program}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <EnumDeclaration type={TestEnum} />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          public enum TestEnum
+          {
+              Value1,
+              Value2,
+              Value3
+          }
+      }
+    `,
+  );
+});
+
+it("renders an empty enum declaration", async () => {
+  const { TestEnum } = (await runner.compile(`
+    @test enum TestEnum {}
+  `)) as { TestEnum: Enum };
+
+  const res = render(
+    <Output program={runner.program}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <EnumDeclaration type={TestEnum} />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          public enum TestEnum
+          {
+
+          }
+      }
+    `,
+  );
+});
+
+it("can override enum name", async () => {
+  const { TestEnum } = (await runner.compile(`
+    @test enum TestEnum {
+      Value1;
+      Value2;
+    }
+  `)) as { TestEnum: Enum };
+
+  const res = render(
+    <Output program={runner.program}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <EnumDeclaration type={TestEnum} name="CustomEnumName" />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          public enum CustomEnumName
+          {
+              Value1,
+              Value2
+          }
+      }
+    `,
+  );
+});
+
+it("renders an enum with access modifiers", async () => {
+  const { TestEnum } = (await runner.compile(`
+    @test enum TestEnum {
+      Value1;
+      Value2;
+    }
+  `)) as { TestEnum: Enum };
+
+  const res = render(
+    <Output program={runner.program}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <EnumDeclaration type={TestEnum} accessModifier="internal" />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          internal enum TestEnum
+          {
+              Value1,
+              Value2
+          }
+      }
+    `,
+  );
+});
+
+it("renders enum with C# naming conventions", async () => {
+  const { TestEnum } = (await runner.compile(`
+    @test enum TestEnum {
+      value_one;
+      value_two;
+      value_three;
+    }
+  `)) as { TestEnum: Enum };
+
+  const res = render(
+    <Output program={runner.program} namePolicy={cs.createCSharpNamePolicy()}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <EnumDeclaration type={TestEnum} />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          public enum TestEnum
+          {
+              ValueOne,
+              ValueTwo,
+              ValueThree
+          }
+      }
+    `,
+  );
+});
+
+it("renders enum with single value", async () => {
+  const { TestEnum } = (await runner.compile(`
+    @test enum TestEnum {
+      OnlyValue;
+    }
+  `)) as { TestEnum: Enum };
+
+  const res = render(
+    <Output program={runner.program}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <EnumDeclaration type={TestEnum} />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          public enum TestEnum
+          {
+              OnlyValue
+          }
+      }
+    `,
+  );
+});
+
+it("renders enum with numeric-like member names", async () => {
+  const { TestEnum } = (await runner.compile(`
+    @test enum TestEnum {
+      Value0;
+      Value1;
+      Value10;
+      Value100;
+    }
+  `)) as { TestEnum: Enum };
+
+  const res = render(
+    <Output program={runner.program}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <EnumDeclaration type={TestEnum} />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          public enum TestEnum
+          {
+              Value0,
+              Value1,
+              Value10,
+              Value100
+          }
+      }
+    `,
+  );
+});
+
+it("renders multiple enums in the same namespace", async () => {
+  const { TestEnum1, TestEnum2 } = (await runner.compile(`
+    @test enum TestEnum1 {
+      Value1;
+      Value2;
+    }
+    @test enum TestEnum2 {
+      OptionA;
+      OptionB;
+      OptionC;
+    }
+  `)) as { TestEnum1: Enum; TestEnum2: Enum };
+
+  const res = render(
+    <Output program={runner.program}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <EnumDeclaration type={TestEnum1} />
+          <hbr />
+          <EnumDeclaration type={TestEnum2} />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          public enum TestEnum1
+          {
+              Value1,
+              Value2
+          }
+          public enum TestEnum2
+          {
+              OptionA,
+              OptionB,
+              OptionC
+          }
+      }
+    `,
+  );
+});

package/test/csharp/test-host.ts

@@ -0,0 +1,42 @@
+import { Program } from "@typespec/compiler";
+import {
+  createTestHost,
+  createTestWrapper,
+  expectDiagnosticEmpty,
+  TypeSpecTestLibrary,
+} from "@typespec/compiler/testing";
+import { HttpTestLibrary } from "@typespec/http/testing";
+
+export async function createTypespecCliTestHost(
+  options: { libraries: "Http"[] } = { libraries: [] },
+) {
+  const libraries: TypeSpecTestLibrary[] = [];
+  if (options.libraries.includes("Http")) {
+    libraries.push(HttpTestLibrary);
+  }
+  return createTestHost({
+    libraries,
+  });
+}
+
+export async function createEmitterFrameworkTestRunner(options: { autoUsings?: string[] } = {}) {
+  const host = await createTypespecCliTestHost();
+  return createTestWrapper(host, {
+    autoUsings: options.autoUsings,
+  });
+}
+
+export async function getProgram(
+  code: string,
+  options: { libraries: "Http"[] } = { libraries: [] },
+): Promise<Program> {
+  const host = await createTypespecCliTestHost(options);
+  const wrapper = createTestWrapper(host, {
+    compilerOptions: {
+      noEmit: true,
+    },
+  });
+  const [_, diagnostics] = await wrapper.compileAndDiagnose(code);
+  expectDiagnosticEmpty(diagnostics);
+  return wrapper.program;
+}