@typespec/emitter-framework 0.11.0-dev.1 → 0.11.0-dev.10

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

@@ -1,27 +1,23 @@
-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 { Tester } from "#test/test-host.js";
+import { type Children } from "@alloy-js/core";
+import { SourceFile } from "@alloy-js/csharp";
+import type { ModelProperty } from "@typespec/compiler";
+import { t, type TesterInstance } from "@typespec/compiler/testing";
+import { beforeEach, describe, expect, it } from "vitest";
 import { Output } from "../../core/index.js";
 import { ClassDeclaration } from "./class/declaration.js";
 import { TypeExpression } from "./type-expression.jsx";
 
-let runner: BasicTestRunner;
+let runner: TesterInstance;
 
 beforeEach(async () => {
-  runner = await createEmitterFrameworkTestRunner();
+  runner = await Tester.createInstance();
 });
 
 function Wrapper(props: { children: Children }) {
   return (
     <Output program={runner.program}>
-      <Namespace name="TestNamespace">
-        <SourceFile path="test.ts">{props.children}</SourceFile>
-      </Namespace>
+      <SourceFile path="test.ts">{props.children}</SourceFile>
     </Output>
   );
 }
@@ -43,91 +39,110 @@ describe("map scalar to c# built-in types", () => {
     ["int64", "long"],
   ])("%s => %s", async (tspType, csType) => {
     const type = await compileType(tspType);
-    const res = render(
+    expect(
       <Wrapper>
         <TypeExpression type={type} />
       </Wrapper>,
-    );
-
-    assertFileContents(
-      res,
-      d`
-          namespace TestNamespace
-          {
-              ${csType}
-          }
-        `,
-    );
+    ).toRenderTo(`
+        ${csType}
+        `);
   });
 });
 
 it("maps array to c# array", async () => {
   const type = await compileType("int32[]");
-  const res = render(
+  expect(
     <Wrapper>
       <TypeExpression type={type} />
     </Wrapper>,
-  );
-
-  assertFileContents(
-    res,
-    d`
-          namespace TestNamespace
-          {
-              int[]
-          }
-        `,
-  );
+  ).toRenderTo(`
+    int[]
+  `);
 });
 
 describe("Record map to IDictionary", () => {
   it("for primitive types", async () => {
     const type = await compileType("Record<int32>");
-    const res = render(
+    expect(
       <Wrapper>
         <TypeExpression type={type} />
       </Wrapper>,
-    );
-
-    assertFileContents(
-      res,
-      d`
-          namespace TestNamespace
-          {
-              IDictionary<string, int>
-          }
-        `,
-    );
+    ).toRenderTo(`
+      IDictionary<string, int>
+    `);
   });
 
   it("for models", async () => {
-    const { test, Pet } = (await runner.compile(`
+    const { test, Pet } = await runner.compile(t.code`
       model Test {
-        @test test: Record<Pet>;
+         ${t.modelProperty("test")}: Record<Pet>;
       }
-      @test model Pet {}
-    `)) as { test: ModelProperty; Pet: Model };
+      @test model ${t.model("Pet")} {}
+    `);
 
-    const res = render(
+    expect(
       <Wrapper>
         <ClassDeclaration type={Pet} />
         <hbr />
         <TypeExpression type={test.type} />
       </Wrapper>,
-    );
-
-    assertFileContents(
-      res,
-      d`
-          namespace TestNamespace
-          {
-              class Pet
-              {
-          
-              }
-              IDictionary<string, Pet>
-          }
-        `,
-    );
+    ).toRenderTo(`
+      class Pet
+      {
+      
+      }
+      IDictionary<string, Pet>
+    `);
+  });
+});
+
+describe("Nullable union", () => {
+  it("nullable boolean", async () => {
+    const { Pet } = await runner.compile(t.code`
+      @test model ${t.model("Pet")} {
+        @test name: boolean | null;
+      }
+    `);
+
+    expect(
+      <Wrapper>
+        <ClassDeclaration type={Pet} />
+      </Wrapper>,
+    ).toRenderTo(`
+      class Pet
+      {
+          public required bool? name { get; set; }
+      }
+    `);
+  });
+});
+
+describe("Literal types", () => {
+  it("literal types (string, int, double, bool)", async () => {
+    const { Pet } = await runner.compile(t.code`
+      @test model ${t.model("Pet")} {
+        @test boolName: true;
+        @test intName: 42;
+        @test doubleName: 3.14;
+        @test stringName: "Hello";
+      }
+    `);
+
+    expect(
+      <Wrapper>
+        <ClassDeclaration type={Pet} />
+      </Wrapper>,
+    ).toRenderTo(`
+      class Pet
+      {
+          public required bool boolName { get; set; }
+
+          public required int intName { get; set; }
+
+          public required double doubleName { get; set; }
+      
+          public required string stringName { get; set; }
+      }
+    `);
   });
 });

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

@@ -1,10 +1,17 @@
 import { Experimental_OverridableComponent } from "#core/index.js";
-import { type Children, code } from "@alloy-js/core";
+import { code, type Children } from "@alloy-js/core";
 import { Reference } from "@alloy-js/csharp";
-import { getTypeName, type IntrinsicType, type Scalar, type Type } from "@typespec/compiler";
+import {
+  getTypeName,
+  isVoidType,
+  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 { getNullableUnionInnerType } from "./utils/nullable-util.js";
 import { efRefkey } from "./utils/refkey.js";
 
 export interface TypeExpressionProps {
@@ -12,6 +19,12 @@ export interface TypeExpressionProps {
 }
 
 export function TypeExpression(props: TypeExpressionProps): Children {
+  if (props.type.kind === "Union") {
+    const nullabletype = getNullableUnionInnerType(props.type);
+    if (nullabletype) {
+      return code`${(<TypeExpression type={nullabletype} />)}?`;
+    }
+  }
   const { $ } = useTsp();
   if (isDeclaration($, props.type)) {
     return (
@@ -26,6 +39,15 @@ export function TypeExpression(props: TypeExpressionProps): Children {
     return code`${(<TypeExpression type={props.type.indexer.value} />)}[]`;
   } else if ($.record.is(props.type)) {
     return code`IDictionary<string, ${(<TypeExpression type={props.type.indexer.value} />)}>`;
+  } else if ($.literal.isString(props.type)) {
+    // c# doesn't have literal types, so we map them to their corresponding C# types in general
+    return code`string`;
+  } else if ($.literal.isNumeric(props.type)) {
+    return Number.isInteger(props.type.value) ? code`int` : code`double`;
+  } else if ($.literal.isBoolean(props.type)) {
+    return code`bool`;
+  } else if (isVoidType(props.type)) {
+    return code`void`;
   }
 
   throw new Error(
@@ -112,8 +134,7 @@ function isDeclaration($: Typekit, type: Type): boolean {
       if ($.array.is(type) || $.record.is(type)) {
         return false;
       }
-
-      return Boolean(type.name);
+      return true;
     case "Union":
       return Boolean(type.name);
     default:

package/src/csharp/components/utils/nullable-util.ts

@@ -0,0 +1,25 @@
+import { useTsp } from "#core/index.js";
+import type { Type, Union } from "@typespec/compiler";
+
+/** Get the inner type if the union is a nullable, otherwise return undefined */
+export function getNullableUnionInnerType(u: Union): Type | undefined {
+  const { $ } = useTsp();
+  const isNull = (type: Type) => type === $.intrinsic.null || type === $.intrinsic.void;
+
+  if (Array.from(u.variants.values()).some((v) => isNull(v.type))) {
+    const { $ } = useTsp();
+    const left = Array.from(u.variants.values()).filter((v) => !isNull(v.type));
+    if (left.length === 0) {
+      // a union only has null or void?
+      return $.intrinsic.void;
+    } else if (left.length === 1) {
+      return left[0].type;
+    } else {
+      return $.union.create({
+        name: u.name,
+        variants: left,
+      });
+    }
+  }
+  return undefined;
+}

package/test/typescript/components/arrow-function.test.tsx

@@ -1,71 +1,57 @@
-import { render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
+import { Tester } from "#test/test-host.js";
 import { SourceFile } from "@alloy-js/typescript";
-import type { Operation } from "@typespec/compiler";
-import type { BasicTestRunner } from "@typespec/compiler/testing";
-import { beforeEach, describe, it } from "vitest";
+import { type TesterInstance, t } from "@typespec/compiler/testing";
+import { beforeEach, describe, expect, it } from "vitest";
 import { Output } from "../../../src/core/components/output.jsx";
 import { ArrowFunction } from "../../../src/typescript/components/arrow-function.jsx";
-import { assertFileContents } from "../../utils.js";
-import { createEmitterFrameworkTestRunner } from "../test-host.js";
 
 describe("arrow functions with a `type` prop", () => {
-  let runner: BasicTestRunner;
+  let runner: TesterInstance;
 
   beforeEach(async () => {
-    runner = await createEmitterFrameworkTestRunner();
+    runner = await Tester.createInstance();
   });
 
   it("creates a function", async () => {
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
-    `)) as { getName: Operation };
+    const { getName } = await runner.compile(t.code`
+      @test op ${t.op("getName")}(id: string): string;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <ArrowFunction type={getName}>console.log("Hello!");</ArrowFunction>
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         (id: string): string => {
           console.log("Hello!");
         }
-      `,
-    );
+      `);
   });
 
   it("creates an async function", async () => {
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
-    `)) as { getName: Operation };
+    const { getName } = await runner.compile(t.code`
+      @test op ${t.op("getName")}(id: string): string;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <ArrowFunction async type={getName} />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         async (id: string): Promise<string> => {}
-      `,
-    );
+      `);
   });
 
   it("can append extra parameters with raw params provided", async () => {
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
-    `)) as { getName: Operation };
+    const { getName } = await runner.compile(t.code`
+      @test op ${t.op("getName")}(id: string): string;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <ArrowFunction
@@ -74,13 +60,8 @@ describe("arrow functions with a `type` prop", () => {
           />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         (additionalParam: number, id: string): string => {}
-      `,
-    );
+      `);
   });
 });

package/test/typescript/components/component-override.test.tsx

@@ -2,6 +2,7 @@ import {
   Experimental_ComponentOverrides,
   Experimental_ComponentOverridesConfig,
 } from "#core/index.js";
+import { Tester } from "#test/test-host.js";
 import { FunctionDeclaration } from "#typescript/index.js";
 import { For, List, type Children } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";
@@ -10,7 +11,6 @@ import type { Namespace } from "@typespec/compiler";
 import { expect, it } from "vitest";
 import { Output } from "../../../src/core/components/output.jsx";
 import { InterfaceDeclaration } from "../../../src/typescript/components/interface-declaration.jsx";
-import { Tester } from "../../test-host.js";
 
 it("uses overridden component", async () => {
   const { program } = await Tester.compile(`

package/test/typescript/components/function-declaration.test.tsx

@@ -1,3 +1,4 @@
+import { getProgram } from "#test/utils.js";
 import { code } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";
 import { SourceFile } from "@alloy-js/typescript";
@@ -5,7 +6,7 @@ import type { Namespace } from "@typespec/compiler";
 import { describe, expect, it } from "vitest";
 import { Output } from "../../../src/core/components/output.jsx";
 import { FunctionDeclaration } from "../../../src/typescript/components/function-declaration.js";
-import { getProgram } from "../test-host.js";
+
 describe("Typescript Function Declaration", () => {
   describe("Function bound to Typespec Types", () => {
     describe("Bound to Operation", () => {

package/test/typescript/components/function-expression.test.tsx

@@ -1,71 +1,57 @@
-import { render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
+import { Tester } from "#test/test-host.js";
 import { SourceFile } from "@alloy-js/typescript";
-import type { Operation } from "@typespec/compiler";
-import type { BasicTestRunner } from "@typespec/compiler/testing";
-import { beforeEach, describe, it } from "vitest";
+import { t, type TesterInstance } from "@typespec/compiler/testing";
+import { beforeEach, describe, expect, it } from "vitest";
 import { Output } from "../../../src/core/components/output.jsx";
 import { FunctionExpression } from "../../../src/typescript/components/function-expression.jsx";
-import { assertFileContents } from "../../utils.js";
-import { createEmitterFrameworkTestRunner } from "../test-host.js";
 
 describe("function expressions with a `type` prop", () => {
-  let runner: BasicTestRunner;
+  let runner: TesterInstance;
 
   beforeEach(async () => {
-    runner = await createEmitterFrameworkTestRunner();
+    runner = await Tester.createInstance();
   });
 
   it("creates a function", async () => {
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
-    `)) as { getName: Operation };
+    const { getName } = await runner.compile(t.code`
+      @test op ${t.op("getName")}(id: string): string;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <FunctionExpression type={getName}>console.log("Hello!");</FunctionExpression>
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         function (id: string): string {
           console.log("Hello!");
         }
-      `,
-    );
+      `);
   });
 
   it("creates an async function", async () => {
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
-    `)) as { getName: Operation };
+    const { getName } = await runner.compile(t.code`
+      @test op ${t.op("getName")}(id: string): string;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <FunctionExpression async type={getName} />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         async function (id: string): Promise<string> {}
-      `,
-    );
+      `);
   });
 
   it("can append extra parameters with raw params provided", async () => {
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
-    `)) as { getName: Operation };
+    const { getName } = await runner.compile(t.code`
+      @test op ${t.op("getName")}(id: string): string;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <FunctionExpression
@@ -74,13 +60,8 @@ describe("function expressions with a `type` prop", () => {
           />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         function (additionalParam: number, id: string): string {}
-      `,
-    );
+      `);
   });
 });

package/test/typescript/components/function-type.test.tsx

@@ -1,81 +1,63 @@
-import { render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
+import { Tester } from "#test/test-host.js";
 import { SourceFile } from "@alloy-js/typescript";
 import type { Operation } from "@typespec/compiler";
-import type { BasicTestRunner } from "@typespec/compiler/testing";
-import { beforeEach, describe, it } from "vitest";
+import { t, type TesterInstance } from "@typespec/compiler/testing";
+import { beforeEach, describe, expect, it } from "vitest";
 import { Output } from "../../../src/core/components/output.jsx";
 import { FunctionType } from "../../../src/typescript/index.js";
-import { assertFileContents } from "../../utils.js";
-import { createEmitterFrameworkTestRunner } from "../test-host.js";
 
 describe("function types with a `type` prop", () => {
-  let runner: BasicTestRunner;
+  let runner: TesterInstance;
 
   beforeEach(async () => {
-    runner = await createEmitterFrameworkTestRunner();
+    runner = await Tester.createInstance();
   });
 
   it("creates a function type", async () => {
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
-    `)) as { getName: Operation };
+    const { getName } = await runner.compile(t.code`
+      @test op ${t.op("getName")}(id: string): string;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <FunctionType type={getName} />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         (id: string) => string
-      `,
-    );
+      `);
   });
 
   it("creates an async function type", async () => {
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
-    `)) as { getName: Operation };
+    const { getName } = await runner.compile(t.code`
+      @test op ${t.op("getName")}(id: string): string;
+    `);
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <FunctionType async type={getName} />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         (id: string) => Promise<string>
-      `,
-    );
+      `);
   });
 
   it("can append extra parameters with raw params provided", async () => {
-    const { getName } = (await runner.compile(`
-      @test op getName(id: string): string;
+    const { getName } = (await runner.compile(t.code`
+      @test op ${t.op("getName")}(id: string): string;
     `)) as { getName: Operation };
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <FunctionType type={getName} parameters={[{ name: "additionalParam", type: "number" }]} />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         (additionalParam: number, id: string) => string
-      `,
-    );
+      `);
   });
 });

package/test/typescript/components/interface-declaration.test.tsx

@@ -1,10 +1,10 @@
+import { getProgram } from "#test/utils.js";
 import { For, List } from "@alloy-js/core";
 import { SourceFile } from "@alloy-js/typescript";
 import type { Namespace } from "@typespec/compiler";
 import { describe, expect, it } from "vitest";
 import { Output } from "../../../src/core/components/output.jsx";
 import { InterfaceDeclaration } from "../../../src/typescript/components/interface-declaration.js";
-import { getProgram } from "../test-host.js";
 
 describe("Typescript Interface", () => {
   describe("Interface bound to Typespec Types", () => {