@typespec/emitter-framework 0.9.0-dev.0 → 0.9.0-dev.10

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

@@ -0,0 +1,56 @@
+import { useTsp } from "#core/context/tsp-context.js";
+import { type Children, For } from "@alloy-js/core";
+import * as cs from "@alloy-js/csharp";
+import type { Enum, Union } from "@typespec/compiler";
+import { reportDiagnostic } from "../../../lib.js";
+import { getDocComments } from "../utils/doc-comments.jsx";
+import { declarationRefkeys, efRefkey } from "../utils/refkey.js";
+
+export interface EnumDeclarationProps extends Omit<cs.EnumDeclarationProps, "name"> {
+  name?: string;
+  type: Union | Enum;
+}
+
+export function EnumDeclaration(props: EnumDeclarationProps): 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.EnumDeclaration name={name} refkey={refkeys} {...props}>
+        <For each={members} joiner={",\n"}>
+          {([key, value]) => {
+            return (
+              <>
+                <cs.DocWhen doc={getDocComments($, value)} />
+                <cs.EnumMember
+                  name={cs.useCSharpNamePolicy().getName(key, "enum-member")}
+                  refkey={
+                    $.union.is(props.type)
+                      ? efRefkey(props.type.variants.get(key))
+                      : efRefkey(value)
+                  }
+                />
+              </>
+            );
+          }}
+        </For>
+      </cs.EnumDeclaration>
+    </>
+  );
+}

package/src/csharp/components/index.ts

@@ -0,0 +1,4 @@
+export * from "./class/declaration.js";
+export * from "./enum/declaration.jsx";
+export * from "./property/property.jsx";
+export * from "./type-expression.jsx";

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

@@ -0,0 +1,97 @@
+import { Tester } from "#test/test-host.js";
+import { type Children } from "@alloy-js/core";
+import { ClassDeclaration, createCSharpNamePolicy, Namespace, SourceFile } from "@alloy-js/csharp";
+import { t, type TesterInstance } from "@typespec/compiler/testing";
+import { beforeEach, describe, expect, it } from "vitest";
+import { Output } from "../../../core/components/output.jsx";
+import { Property } from "./property.jsx";
+
+let tester: TesterInstance;
+
+beforeEach(async () => {
+  tester = await Tester.createInstance();
+});
+
+function Wrapper(props: { children: Children }) {
+  const policy = createCSharpNamePolicy();
+  return (
+    <Output program={tester.program} namePolicy={policy}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <ClassDeclaration name="Test">{props.children}</ClassDeclaration>
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+}
+
+it("maps prop: string | null to nullable property", async () => {
+  const { prop1 } = await tester.compile(t.code`
+    model TestModel {
+      ${t.modelProperty("prop1")}: string | null;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <Property type={prop1} />
+    </Wrapper>,
+  ).toRenderTo(`
+      namespace TestNamespace
+      {
+          class Test
+          {
+              public required string? Prop1 { get; set; }
+          }
+      }
+  `);
+});
+
+describe("jsonAttributes", () => {
+  it("adds [JsonNameAttribute]", async () => {
+    const { prop1 } = await tester.compile(t.code`
+    model TestModel {
+      ${t.modelProperty("prop1")}: string;
+    }
+  `);
+
+    expect(
+      <Wrapper>
+        <Property type={prop1} jsonAttributes />
+      </Wrapper>,
+    ).toRenderTo(`
+      namespace TestNamespace
+      {
+          class Test
+          {
+              [System.Text.Json.JsonPropertyName("prop1")]
+              public required string Prop1 { get; set; }
+          }
+      }
+  `);
+  });
+
+  it("adds [JsonNameAttribute] respecting encodedName", async () => {
+    const { prop1 } = await tester.compile(t.code`
+    model TestModel {
+      @encodedName("application/json", "prop_1")
+      ${t.modelProperty("prop1")}: string;
+    }
+  `);
+
+    expect(
+      <Wrapper>
+        <Property type={prop1} jsonAttributes />
+      </Wrapper>,
+    ).toRenderTo(`
+      namespace TestNamespace
+      {
+          class Test
+          {
+              [System.Text.Json.JsonPropertyName("prop_1")]
+              public required string Prop1 { get; set; }
+          }
+      }
+  `);
+  });
+});

package/src/csharp/components/property/property.tsx

@@ -0,0 +1,62 @@
+import { type Children } from "@alloy-js/core";
+import * as cs from "@alloy-js/csharp";
+import { Attribute } from "@alloy-js/csharp";
+import { type ModelProperty, resolveEncodedName, type Type } from "@typespec/compiler";
+import { useTsp } from "../../../core/index.js";
+import { TypeExpression } from "../type-expression.jsx";
+import { getDocComments } from "../utils/doc-comments.jsx";
+
+export interface PropertyProps {
+  type: ModelProperty;
+  /** If set the property will add the json serialization attributes(using System.Text.Json). */
+  jsonAttributes?: boolean;
+}
+
+/**
+ * Create a C# property declaration from a TypeSpec property type.
+ */
+export function Property(props: PropertyProps): Children {
+  const result = preprocessPropertyType(props.type.type);
+  const { $ } = useTsp();
+
+  return (
+    <cs.Property
+      name={props.type.name}
+      type={<TypeExpression type={result.type} />}
+      public
+      required={!props.type.optional}
+      nullable={result.nullable}
+      doc={getDocComments($, props.type)}
+      attributes={props.jsonAttributes ? [<JsonNameAttribute type={props.type} />] : undefined}
+      get
+      set
+    />
+  );
+}
+
+export interface JsonNameAttributeProps {
+  type: ModelProperty;
+}
+
+function JsonNameAttribute(props: JsonNameAttributeProps): Children {
+  const { program } = useTsp();
+  const jsonName = resolveEncodedName(program, props.type, "application/json");
+  return <Attribute name="System.Text.Json.JsonPropertyName" args={[JSON.stringify(jsonName)]} />;
+}
+
+function preprocessPropertyType(type: Type): { type: Type; nullable: boolean } {
+  const { $ } = useTsp();
+
+  if (type.kind === "Union") {
+    const variants = type.variants;
+    const nonNullVariant = [...variants.values()].find((v) => v.type !== $.intrinsic.null);
+    const nullVariant = [...variants.values()].find((v) => v.type !== $.intrinsic.null);
+    if (nonNullVariant && nullVariant && variants.size === 2) {
+      return { type: nonNullVariant.type, nullable: true };
+    } else {
+      return { type, nullable: false };
+    }
+  } else {
+    return { type, nullable: false };
+  }
+}

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

@@ -0,0 +1,133 @@
+import { type Children, render } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { Namespace, SourceFile } from "@alloy-js/csharp";
+import type { Model, ModelProperty } from "@typespec/compiler";
+import type { BasicTestRunner } from "@typespec/compiler/testing";
+import { beforeEach, describe, it } from "vitest";
+import { createEmitterFrameworkTestRunner } from "../../../test/typescript/test-host.js";
+import { assertFileContents } from "../../../test/utils.js";
+import { Output } from "../../core/index.js";
+import { ClassDeclaration } from "./class/declaration.js";
+import { TypeExpression } from "./type-expression.jsx";
+
+let runner: BasicTestRunner;
+
+beforeEach(async () => {
+  runner = await createEmitterFrameworkTestRunner();
+});
+
+function Wrapper(props: { children: Children }) {
+  return (
+    <Output program={runner.program}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.ts">{props.children}</SourceFile>
+      </Namespace>
+    </Output>
+  );
+}
+
+async function compileType(ref: string) {
+  const { test } = await runner.compile(`
+    model Test {
+      @test test: ${ref};
+    }
+  `);
+
+  return (test as ModelProperty).type;
+}
+
+describe("map scalar to c# built-in types", () => {
+  it.each([
+    ["string", "string"],
+    ["int32", "int"],
+    ["int64", "long"],
+  ])("%s => %s", async (tspType, csType) => {
+    const type = await compileType(tspType);
+    const res = render(
+      <Wrapper>
+        <TypeExpression type={type} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+          namespace TestNamespace
+          {
+              ${csType}
+          }
+        `,
+    );
+  });
+});
+
+it("maps array to c# array", async () => {
+  const type = await compileType("int32[]");
+  const res = render(
+    <Wrapper>
+      <TypeExpression type={type} />
+    </Wrapper>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+          namespace TestNamespace
+          {
+              int[]
+          }
+        `,
+  );
+});
+
+describe("Record map to IDictionary", () => {
+  it("for primitive types", async () => {
+    const type = await compileType("Record<int32>");
+    const res = render(
+      <Wrapper>
+        <TypeExpression type={type} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+          namespace TestNamespace
+          {
+              IDictionary<string, int>
+          }
+        `,
+    );
+  });
+
+  it("for models", async () => {
+    const { test, Pet } = (await runner.compile(`
+      model Test {
+        @test test: Record<Pet>;
+      }
+      @test model Pet {}
+    `)) as { test: ModelProperty; Pet: Model };
+
+    const res = render(
+      <Wrapper>
+        <ClassDeclaration type={Pet} />
+        <hbr />
+        <TypeExpression type={test.type} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+          namespace TestNamespace
+          {
+              class Pet
+              {
+          
+              }
+              IDictionary<string, Pet>
+          }
+        `,
+    );
+  });
+});

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

@@ -0,0 +1,119 @@
+import { type Children, code } from "@alloy-js/core";
+import { Reference } from "@alloy-js/csharp";
+import { getTypeName, type IntrinsicType, type Scalar, type Type } from "@typespec/compiler";
+import type { 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);
+  } else if ($.array.is(props.type)) {
+    return code`${(<TypeExpression type={props.type.indexer.value} />)}[]`;
+  } else if ($.record.is(props.type)) {
+    return code`IDictionary<string, ${(<TypeExpression type={props.type.indexer.value} />)}>`;
+  }
+
+  throw new Error(
+    `Unsupported type for TypeExpression: ${props.type.kind} (${getTypeName(props.type)})`,
+  );
+}
+
+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 };

package/src/csharp/components/utils/doc-comments.tsx

@@ -0,0 +1,58 @@
+import { type Children, List } from "@alloy-js/core";
+import * as cs from "@alloy-js/csharp";
+import { getReturnsDoc, type Type } from "@typespec/compiler";
+import type { Typekit } from "@typespec/compiler/typekit";
+
+/**
+ * Helper to render a doc string for a given TypeSpec type.
+ *
+ * This is not a JSX component as it needs to return undefined if there is no doc.
+ *
+ * @param $ The Typekit instance
+ * @param type The TypeSpec type to generate documentation for
+ * @returns A DocSummary component containing the rendered doc string, or undefined if no doc is available.
+ */
+export function getDocComments($: Typekit, type: Type): Children {
+  const typeDoc = $.type.getDoc(type);
+  if (!typeDoc) {
+    return undefined;
+  }
+
+  const docElements: Children[] = [];
+
+  // Add main type documentation
+  docElements.push(
+    <cs.DocSummary>
+      <cs.DocFromMarkdown markdown={typeDoc} />
+    </cs.DocSummary>,
+  );
+
+  // Add operation-specific documentation if applicable
+  if ($.operation.is(type)) {
+    // Add parameter documentation
+    const paramDocs = [];
+    for (const param of type.parameters.properties.values()) {
+      const paramDoc = $.type.getDoc(param);
+      if (paramDoc) {
+        paramDocs.push(
+          <cs.DocParam name={param.name}>
+            <cs.DocFromMarkdown markdown={paramDoc} />
+          </cs.DocParam>,
+        );
+      }
+    }
+    docElements.push(...paramDocs);
+
+    // Add return documentation
+    const returnDoc = getReturnsDoc($.program, type);
+    if (returnDoc) {
+      docElements.push(
+        <cs.DocReturns>
+          <cs.DocFromMarkdown markdown={returnDoc} />
+        </cs.DocReturns>,
+      );
+    }
+  }
+
+  return <List doubleHardline>{docElements}</List>;
+}

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/src/testing/index.ts

@@ -1,5 +1,5 @@
 import { resolvePath } from "@typespec/compiler";
-import { createTestLibrary, TypeSpecTestLibrary } from "@typespec/compiler/testing";
+import { createTestLibrary, type TypeSpecTestLibrary } from "@typespec/compiler/testing";
 import { fileURLToPath } from "url";
 
 export const EmitterFrameworkTestLibrary: TypeSpecTestLibrary = createTestLibrary({

package/src/testing/scenario-test/code-block-expectation.test.ts

@@ -0,0 +1,95 @@
+import { d } from "@alloy-js/core/testing";
+import { beforeAll, describe, expect, it } from "vitest";
+import { getExcerptForQuery, parseCodeBlockHeading } from "./code-block-expectation.js";
+import {
+  createSnippetExtractor,
+  createTypeScriptExtractorConfig,
+  type SnippetExtractor,
+} from "./snippet-extractor.js";
+
+describe("parseCodeBlockHeading", () => {
+  it("parse whole file expectation", () => {
+    expect(parseCodeBlockHeading("ts path/to/file.ts")).toEqual({
+      lang: "ts",
+      file: "path/to/file.ts",
+    });
+  });
+
+  it("throws error when no file is provided", () => {
+    expect(() => parseCodeBlockHeading("ts")).toThrow(
+      'Invalid code block heading: "ts". Missing file path. Expected format: "<lang> <path>"',
+    );
+  });
+
+  it("parse parse with type and name", () => {
+    expect(parseCodeBlockHeading("ts path/to/file.ts interface foo")).toEqual({
+      lang: "ts",
+      file: "path/to/file.ts",
+      query: {
+        type: "interface",
+        name: "foo",
+      },
+    });
+  });
+
+  it("throws error when using type but no name is provided", () => {
+    expect(() => parseCodeBlockHeading("ts path/to/file.ts interface")).toThrow(
+      'Invalid code block heading: "ts path/to/file.ts interface". Missing name when using type. Expected format: "<lang> <path> [type] [name]"',
+    );
+  });
+});
+
+describe("getExcerptForQuery", () => {
+  let snippetExtractor: SnippetExtractor;
+  beforeAll(async () => {
+    const tsExtractorConfig = await createTypeScriptExtractorConfig();
+    snippetExtractor = createSnippetExtractor(tsExtractorConfig);
+  });
+
+  it("gets a whole file", async () => {
+    const expectation = {
+      lang: "ts",
+      file: "file.ts",
+    };
+    const outputs = {
+      "file.ts": d`
+        interface bar {
+        
+        }
+        interface foo {
+          bar: string;
+        }      
+      `,
+    };
+    const excerpt = getExcerptForQuery(snippetExtractor, expectation, outputs);
+    expect(excerpt).toBe(outputs["file.ts"]);
+  });
+
+  it("gets an interface for typescript", async () => {
+    const expectation = {
+      lang: "ts",
+      file: "file.ts",
+      query: {
+        type: "interface",
+        name: "foo",
+      },
+    };
+    const outputs = {
+      "file.ts": d`
+        interface bar {
+        
+        }
+
+        interface foo {
+          bar: string;
+        }
+      `,
+    };
+    const excerpt = getExcerptForQuery(snippetExtractor, expectation, outputs);
+    expect(excerpt).toBe(d`
+      interface foo {
+        bar: string;
+      }
+    `);
+  });
+});