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

package/dist/test/csharp/components/enum-declaration.test.js

@@ -0,0 +1,355 @@
+import { createComponent as _$createComponent, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
+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 { 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;
+beforeEach(async () => {
+  runner = await createEmitterFrameworkTestRunner();
+});
+it("renders a basic enum declaration", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(`
+    @test enum TestEnum {
+      Value1;
+      Value2;
+      Value3;
+    }
+  `);
+  const res = render(_$createComponent(Output, {
+    get program() {
+      return runner.program;
+    },
+    get children() {
+      return _$createComponent(Namespace, {
+        name: "TestNamespace",
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.cs",
+            get children() {
+              return _$createComponent(EnumDeclaration, {
+                type: TestEnum
+              });
+            }
+          });
+        }
+      });
+    }
+  }));
+  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 {}
+  `);
+  const res = render(_$createComponent(Output, {
+    get program() {
+      return runner.program;
+    },
+    get children() {
+      return _$createComponent(Namespace, {
+        name: "TestNamespace",
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.cs",
+            get children() {
+              return _$createComponent(EnumDeclaration, {
+                type: TestEnum
+              });
+            }
+          });
+        }
+      });
+    }
+  }));
+  assertFileContents(res, d`
+      namespace TestNamespace
+      {
+          public enum TestEnum
+          {
+
+          }
+      }
+    `);
+});
+it("can override enum name", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(`
+    @test enum TestEnum {
+      Value1;
+      Value2;
+    }
+  `);
+  const res = render(_$createComponent(Output, {
+    get program() {
+      return runner.program;
+    },
+    get children() {
+      return _$createComponent(Namespace, {
+        name: "TestNamespace",
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.cs",
+            get children() {
+              return _$createComponent(EnumDeclaration, {
+                type: TestEnum,
+                name: "CustomEnumName"
+              });
+            }
+          });
+        }
+      });
+    }
+  }));
+  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;
+    }
+  `);
+  const res = render(_$createComponent(Output, {
+    get program() {
+      return runner.program;
+    },
+    get children() {
+      return _$createComponent(Namespace, {
+        name: "TestNamespace",
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.cs",
+            get children() {
+              return _$createComponent(EnumDeclaration, {
+                type: TestEnum,
+                accessModifier: "internal"
+              });
+            }
+          });
+        }
+      });
+    }
+  }));
+  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;
+    }
+  `);
+  const res = render(_$createComponent(Output, {
+    get program() {
+      return runner.program;
+    },
+    get namePolicy() {
+      return cs.createCSharpNamePolicy();
+    },
+    get children() {
+      return _$createComponent(Namespace, {
+        name: "TestNamespace",
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.cs",
+            get children() {
+              return _$createComponent(EnumDeclaration, {
+                type: TestEnum
+              });
+            }
+          });
+        }
+      });
+    }
+  }));
+  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;
+    }
+  `);
+  const res = render(_$createComponent(Output, {
+    get program() {
+      return runner.program;
+    },
+    get children() {
+      return _$createComponent(Namespace, {
+        name: "TestNamespace",
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.cs",
+            get children() {
+              return _$createComponent(EnumDeclaration, {
+                type: TestEnum
+              });
+            }
+          });
+        }
+      });
+    }
+  }));
+  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;
+    }
+  `);
+  const res = render(_$createComponent(Output, {
+    get program() {
+      return runner.program;
+    },
+    get children() {
+      return _$createComponent(Namespace, {
+        name: "TestNamespace",
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.cs",
+            get children() {
+              return _$createComponent(EnumDeclaration, {
+                type: TestEnum
+              });
+            }
+          });
+        }
+      });
+    }
+  }));
+  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;
+    }
+  `);
+  const res = render(_$createComponent(Output, {
+    get program() {
+      return runner.program;
+    },
+    get children() {
+      return _$createComponent(Namespace, {
+        name: "TestNamespace",
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.cs",
+            get children() {
+              return [_$createComponent(EnumDeclaration, {
+                type: TestEnum1
+              }), _$createIntrinsic("hbr", {}), _$createComponent(EnumDeclaration, {
+                type: TestEnum2
+              })];
+            }
+          });
+        }
+      });
+    }
+  }));
+  assertFileContents(res, d`
+      namespace TestNamespace
+      {
+          public enum TestEnum1
+          {
+              Value1,
+              Value2
+          }
+          public enum TestEnum2
+          {
+              OptionA,
+              OptionB,
+              OptionC
+          }
+      }
+    `);
+});

package/dist/test/csharp/test-host.d.ts

@@ -0,0 +1,11 @@
+import { Program } from "@typespec/compiler";
+export declare function createTypespecCliTestHost(options?: {
+    libraries: "Http"[];
+}): Promise<import("@typespec/compiler/testing").TestHost>;
+export declare function createEmitterFrameworkTestRunner(options?: {
+    autoUsings?: string[];
+}): Promise<import("@typespec/compiler/testing").BasicTestRunner>;
+export declare function getProgram(code: string, options?: {
+    libraries: "Http"[];
+}): Promise<Program>;
+//# sourceMappingURL=test-host.d.ts.map

package/dist/test/csharp/test-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-host.d.ts","sourceRoot":"","sources":["../../../test/csharp/test-host.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAS7C,wBAAsB,yBAAyB,CAC7C,OAAO,GAAE;IAAE,SAAS,EAAE,MAAM,EAAE,CAAA;CAAsB,0DASrD;AAED,wBAAsB,gCAAgC,CAAC,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CAAO,iEAK7F;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,SAAS,EAAE,MAAM,EAAE,CAAA;CAAsB,GACnD,OAAO,CAAC,OAAO,CAAC,CAUlB"}

package/dist/test/csharp/test-host.js

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

package/dist/test/csharp/utils.d.ts

@@ -0,0 +1,3 @@
+import { OutputDirectory } from "@alloy-js/core";
+export declare function assertFileContents(res: OutputDirectory, contents: string): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/test/csharp/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../test/csharp/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGjD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,QAIxE"}

package/dist/test/csharp/utils.js

@@ -0,0 +1,6 @@
+import { assert } from "vitest";
+export function assertFileContents(res, contents) {
+  const testFile = res.contents.find(file => file.path === "test.cs");
+  assert(testFile, "test.cs file not rendered");
+  assert.equal(testFile.contents, contents);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/emitter-framework",
-  "version": "0.9.0-dev.1",
+  "version": "0.9.0-dev.2",
   "type": "module",
   "main": "dist/index.js",
   "repository": {
@@ -25,6 +25,7 @@
   "peerDependencies": {
     "@alloy-js/core": "^0.17.0",
     "@alloy-js/typescript": "^0.17.0",
+    "@alloy-js/csharp": "^0.17.0",
     "@typespec/compiler": "^1.1.0",
     "@typespec/http": "^1.1.0",
     "@typespec/rest": "^0.71.0 || >=0.72.0-dev <0.72.0"

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

@@ -0,0 +1,87 @@
+import * as ay from "@alloy-js/core";
+import * as cs from "@alloy-js/csharp";
+import { Interface, Model } from "@typespec/compiler";
+import { useTsp } from "../../core/index.js";
+import { TypeExpression } from "./type-expression.jsx";
+import { declarationRefkeys } from "./utils/refkey.js";
+
+export interface ClassDeclarationProps extends Omit<cs.ClassProps, "name"> {
+  name?: string;
+  type: Model | Interface;
+}
+
+interface ClassPropertiesProps {
+  type: Model;
+}
+
+interface ClassMethodsProps {
+  type: Interface;
+}
+
+export function ClassDeclaration(props: ClassDeclarationProps): ay.Children {
+  const { $ } = useTsp();
+
+  const namePolicy = cs.useCSharpNamePolicy();
+  const className = props.name ?? namePolicy.getName(props.type.name, "class");
+
+  const refkeys = declarationRefkeys(props.refkey, props.type)[0]; // TODO: support multiple refkeys for declarations in alloy
+
+  return (
+    <>
+      <cs.Class name={className} accessModifier={props.accessModifier} refkey={refkeys}>
+        {$.model.is(props.type) && <ClassProperties type={props.type} />}
+        {props.type.kind === "Interface" && <ClassMethods type={props.type} />}
+      </cs.Class>
+    </>
+  );
+}
+
+function ClassProperties(props: ClassPropertiesProps): ay.Children {
+  const namePolicy = cs.useCSharpNamePolicy();
+
+  const classProperties: ay.Children = [];
+  for (const [name, prop] of props.type.properties) {
+    classProperties.push(
+      <>
+        <cs.ClassMember
+          name={namePolicy.getName(name, "class-member-public")}
+          type={<TypeExpression type={prop.type} />}
+          accessModifier="public"
+        />{" "}
+        <ay.Block newline>
+          <ay.StatementList children={["get", "set"]} />
+        </ay.Block>
+      </>,
+    );
+  }
+
+  return (
+    <ay.For each={classProperties} hardline>
+      {(c) => c}
+    </ay.For>
+  );
+}
+
+function ClassMethods(props: ClassMethodsProps): ay.Children {
+  const namePolicy = cs.useCSharpNamePolicy();
+
+  const abstractMethods: ay.Children = [];
+  for (const [name, prop] of props.type.operations) {
+    abstractMethods.push(
+      <cs.ClassMethod
+        name={namePolicy.getName(name, "class-method")}
+        methodModifier="abstract"
+        parameters={[...prop.parameters.properties.entries()].map(([name, prop]) => {
+          return {
+            name: namePolicy.getName(name, "type-parameter"),
+            type: <TypeExpression type={prop.type} />,
+          };
+        })}
+        accessModifier="public"
+        returns={<TypeExpression type={prop.returnType} />}
+      />,
+    );
+  }
+
+  return <>{abstractMethods}</>;
+}

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

@@ -0,0 +1,48 @@
+import * as ay from "@alloy-js/core";
+import * as cs from "@alloy-js/csharp";
+import { Enum, Union } from "@typespec/compiler";
+import { useTsp } from "../../core/index.js";
+import { reportDiagnostic } from "../../lib.js";
+import { declarationRefkeys, efRefkey } from "./utils/refkey.js";
+
+export interface EnumDeclarationProps extends Omit<cs.EnumProps, "name"> {
+  name?: string;
+  type: Union | Enum;
+}
+
+export function EnumDeclaration(props: EnumDeclarationProps): ay.Children {
+  const { $ } = useTsp();
+  let type: Enum;
+  if ($.union.is(props.type)) {
+    if (!$.union.isValidEnum(props.type)) {
+      throw new Error("The provided union type cannot be represented as an enum");
+    }
+    type = $.enum.createFromUnion(props.type);
+  } else {
+    type = props.type;
+  }
+
+  if (!props.type.name) {
+    reportDiagnostic($.program, { code: "type-declaration-missing-name", target: props.type });
+  }
+  const refkeys = declarationRefkeys(props.refkey, props.type)[0]; // TODO: support multiple refkeys for declarations in alloy
+  const name = props.name ?? cs.useCSharpNamePolicy().getName(props.type.name!, "enum");
+  const members = Array.from(type.members.entries());
+
+  return (
+    <cs.Enum name={name} refkey={refkeys} accessModifier={props.accessModifier ?? "public"}>
+      <ay.For each={members} joiner={",\n"}>
+        {([key, value]) => {
+          return (
+            <cs.EnumMember
+              name={cs.useCSharpNamePolicy().getName(key, "enum-member")}
+              refkey={
+                $.union.is(props.type) ? efRefkey(props.type.variants.get(key)) : efRefkey(value)
+              }
+            />
+          );
+        }}
+      </ay.For>
+    </cs.Enum>
+  );
+}

package/src/csharp/components/index.ts

@@ -0,0 +1,2 @@
+export * from "./class-declaration.jsx";
+export * from "./enum-declaration.jsx";

package/src/csharp/components/type-expression.tsx

@@ -0,0 +1,112 @@
+import { Children } from "@alloy-js/core";
+import { Reference } from "@alloy-js/csharp";
+import { IntrinsicType, Scalar, Type } from "@typespec/compiler";
+import { Typekit } from "@typespec/compiler/typekit";
+import { useTsp } from "../../core/index.js";
+import { reportTypescriptDiagnostic } from "../../typescript/lib.js";
+import { efRefkey } from "./utils/refkey.js";
+
+export interface TypeExpressionProps {
+  type: Type;
+}
+
+export function TypeExpression(props: TypeExpressionProps): Children {
+  const { $ } = useTsp();
+  if (isDeclaration($, props.type)) {
+    return <Reference refkey={efRefkey(props.type)} />;
+  }
+  if ($.scalar.is(props.type)) {
+    return getScalarIntrinsicExpression($, props.type);
+  }
+  throw new Error("not implemented");
+}
+
+const intrinsicNameToCSharpType = new Map<string, string | null>([
+  // Core types
+  ["unknown", "object"], // Matches C#'s `object`
+  ["string", "string"], // Matches C#'s `string`
+  ["boolean", "bool"], // Matches C#'s `bool`
+  ["null", "null"], // Matches C#'s `null`
+  ["void", "void"], // Matches C#'s `void`
+  ["never", null], // No direct equivalent in C#
+  ["bytes", "byte[]"], // Matches C#'s `byte[]`
+
+  // Numeric types
+  ["numeric", "decimal"], // Parent type for all numeric types, use most precise
+  ["integer", "int"], // Broad integer category, maps to `int`
+  ["float", "float"], // Broad float category, maps to `float`
+  ["decimal", "decimal"], // Broad decimal category, maps to `decimal`
+  ["decimal128", "decimal"], // C#'s decimal is 128-bit
+  ["int64", "long"], // 64-bit signed integer
+  ["int32", "int"], // 32-bit signed integer
+  ["int16", "short"], // 16-bit signed integer
+  ["int8", "sbyte"], // 8-bit signed integer
+  ["safeint", "int"], // Safe integer, use int as default
+  ["uint64", "ulong"], // 64-bit unsigned integer
+  ["uint32", "uint"], // 32-bit unsigned integer
+  ["uint16", "ushort"], // 16-bit unsigned integer
+  ["uint8", "byte"], // 8-bit unsigned integer
+  ["float32", "float"], // 32-bit floating point
+  ["float64", "double"], // 64-bit floating point
+
+  // Date and time types
+  ["plainDate", "DateOnly"], // Use .NET 6+ DateOnly for plain calendar dates
+  ["plainTime", "TimeOnly"], // Use .NET 6+ TimeOnly for plain clock times
+  ["utcDateTime", "DateTimeOffset"], // Use DateTimeOffset for UTC date-times
+  ["offsetDateTime", "DateTimeOffset"], // Use DateTimeOffset for timezone-specific date-times
+  ["duration", "TimeSpan"], // Duration as TimeSpan
+
+  // String types
+  ["url", "Uri"], // Matches C#'s `Uri`
+]);
+
+export function getScalarIntrinsicExpression(
+  $: Typekit,
+  type: Scalar | IntrinsicType,
+): string | null {
+  let intrinsicName: string;
+
+  if ($.scalar.isUtcDateTime(type) || $.scalar.extendsUtcDateTime(type)) {
+    return "DateTimeOffset";
+  }
+  if ($.scalar.is(type)) {
+    intrinsicName = $.scalar.getStdBase(type)?.name ?? "";
+  } else {
+    intrinsicName = type.name;
+  }
+
+  const csType = intrinsicNameToCSharpType.get(intrinsicName);
+
+  if (!csType) {
+    reportTypescriptDiagnostic($.program, { code: "typescript-unsupported-scalar", target: type });
+    return "object"; // Fallback to object if unsupported
+  }
+
+  return csType;
+}
+
+function isDeclaration($: Typekit, type: Type): boolean {
+  switch (type.kind) {
+    case "Namespace":
+    case "Interface":
+    case "Enum":
+    case "Operation":
+    case "EnumMember":
+      return true;
+    case "UnionVariant":
+      return false;
+
+    case "Model":
+      if ($.array.is(type) || $.record.is(type)) {
+        return false;
+      }
+
+      return Boolean(type.name);
+    case "Union":
+      return Boolean(type.name);
+    default:
+      return false;
+  }
+}
+
+export { intrinsicNameToCSharpType };