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

package/dist/src/csharp/components/class/declaration.d.ts

@@ -1,6 +1,6 @@
 import { type Children } from "@alloy-js/core";
 import * as cs from "@alloy-js/csharp";
-import type { Interface, Model } from "@typespec/compiler";
+import { type Interface, type Model } from "@typespec/compiler";
 export interface ClassDeclarationProps extends Omit<cs.ClassDeclarationProps, "name"> {
     /** Set an alternative name for the class. Otherwise default to the type name. */
     name?: string;

package/dist/src/csharp/components/class/declaration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"declaration.d.ts","sourceRoot":"","sources":["../../../../../src/csharp/components/class/declaration.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAO,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEvC,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAO3D,MAAM,WAAW,qBAAsB,SAAQ,IAAI,CAAC,EAAE,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACnF,iFAAiF;IACjF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,IAAI,EAAE,KAAK,GAAG,SAAS,CAAC;IACxB,8FAA8F;IAC9F,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAYD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,GAAG,QAAQ,CAuBvE"}
+{"version":3,"file":"declaration.d.ts","sourceRoot":"","sources":["../../../../../src/csharp/components/class/declaration.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAO,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEvC,OAAO,EAAc,KAAK,SAAS,EAAE,KAAK,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAO5E,MAAM,WAAW,qBAAsB,SAAQ,IAAI,CAAC,EAAE,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACnF,iFAAiF;IACjF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,IAAI,EAAE,KAAK,GAAG,SAAS,CAAC;IACxB,8FAA8F;IAC9F,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAYD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,GAAG,QAAQ,CAuBvE"}

package/dist/src/csharp/components/class/declaration.js

@@ -2,6 +2,7 @@ import { memo as _$memo, mergeProps as _$mergeProps, createComponent as _$create
 import { For } from "@alloy-js/core";
 import * as cs from "@alloy-js/csharp";
 import { Method } from "@alloy-js/csharp";
+import { isVoidType } from "@typespec/compiler";
 import { useTsp } from "../../../core/index.js";
 import { Property } from "../property/property.js";
 import { TypeExpression } from "../type-expression.js";
@@ -38,10 +39,10 @@ export function ClassDeclaration(props) {
   }))];
 }
 function ClassProperties(props) {
+  // Ignore 'void' type properties which is not valid in csharp
+  const properties = Array.from(props.type.properties.entries()).filter(([_, p]) => !isVoidType(p.type));
   return _$createComponent(For, {
-    get each() {
-      return props.type.properties.entries();
-    },
+    each: properties,
     hardline: true,
     children: ([name, property]) => _$createComponent(Property, {
       type: property,

package/dist/src/csharp/components/type-expression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"type-expression.d.ts","sourceRoot":"","sources":["../../../../src/csharp/components/type-expression.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,QAAQ,EAAQ,MAAM,gBAAgB,CAAC;AAErD,OAAO,EAAe,KAAK,aAAa,EAAE,KAAK,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC7F,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAK1D,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,IAAI,CAAC;CACZ;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,GAAG,QAAQ,CAoBnE;AAED,QAAA,MAAM,yBAAyB,4BAqC7B,CAAC;AAEH,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,OAAO,EACV,IAAI,EAAE,MAAM,GAAG,aAAa,GAC3B,MAAM,GAAG,IAAI,CAoBf;AA0BD,OAAO,EAAE,yBAAyB,EAAE,CAAC"}
+{"version":3,"file":"type-expression.d.ts","sourceRoot":"","sources":["../../../../src/csharp/components/type-expression.tsx"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAErD,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,MAAM,EACX,KAAK,IAAI,EAEV,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAK1D,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,IAAI,CAAC;CACZ;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,GAAG,QAAQ,CAmCnE;AAwBD,QAAA,MAAM,yBAAyB,4BAqC7B,CAAC;AAEH,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,OAAO,EACV,IAAI,EAAE,MAAM,GAAG,aAAa,GAC3B,MAAM,GAAG,IAAI,CAoBf;AAyBD,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/src/csharp/components/type-expression.js

@@ -2,11 +2,19 @@ import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime
 import { Experimental_OverridableComponent } from "#core/index.js";
 import { code } from "@alloy-js/core";
 import { Reference } from "@alloy-js/csharp";
-import { getTypeName } from "@typespec/compiler";
+import { getTypeName, isNullType, isVoidType } from "@typespec/compiler";
 import { useTsp } from "../../core/index.js";
 import { reportTypescriptDiagnostic } from "../../typescript/lib.js";
 import { efRefkey } from "./utils/refkey.js";
 export function TypeExpression(props) {
+  if (props.type.kind === "Union") {
+    const nullabletype = getNullableUnionInnerType(props.type);
+    if (nullabletype) {
+      return code`${_$createComponent(TypeExpression, {
+        type: nullabletype
+      })}?`;
+    }
+  }
   const {
     $
   } = useTsp();
@@ -39,9 +47,41 @@ export function TypeExpression(props) {
         return 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(`Unsupported type for TypeExpression: ${props.type.kind} (${getTypeName(props.type)})`);
 }
+
+/** Get the inner type if the union is a nullable, otherwise return undefined */
+function getNullableUnionInnerType(u) {
+  const isNull = type => isNullType(type) || isVoidType(type);
+  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;
+}
 const intrinsicNameToCSharpType = new Map([
 // Core types
 ["unknown", "object"],
@@ -142,7 +182,7 @@ function isDeclaration($, type) {
       if ($.array.is(type) || $.record.is(type)) {
         return false;
       }
-      return Boolean(type.name);
+      return true;
     case "Union":
       return Boolean(type.name);
     default:

package/dist/src/csharp/components/type-expression.test.js

@@ -125,4 +125,64 @@ describe("Record map to IDictionary", () => {
           }
         `);
   });
+});
+describe("Nullable union", () => {
+  it("nullable boolean", async () => {
+    const {
+      Pet
+    } = await runner.compile(`
+      @test model Pet {
+        @test name: boolean | null;
+      }
+    `);
+    const res = render(_$createComponent(Wrapper, {
+      get children() {
+        return _$createComponent(ClassDeclaration, {
+          type: Pet
+        });
+      }
+    }));
+    assertFileContents(res, d`
+          namespace TestNamespace
+          {
+              class Pet
+              {
+                  public required bool? name { get; set; }
+              }
+          }
+        `);
+  });
+});
+describe("Literal types", () => {
+  it("literal types (string, int, double, bool)", async () => {
+    const {
+      Pet
+    } = await runner.compile(`
+      @test model Pet {
+        @test boolName: true;
+        @test intName: 42;
+        @test doubleName: 3.14;
+        @test stringName: "Hello";
+      }
+    `);
+    const res = render(_$createComponent(Wrapper, {
+      get children() {
+        return _$createComponent(ClassDeclaration, {
+          type: Pet
+        });
+      }
+    }));
+    assertFileContents(res, d`
+          namespace TestNamespace
+          {
+              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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/emitter-framework",
-  "version": "0.11.0-dev.1",
+  "version": "0.11.0-dev.2",
   "type": "module",
   "main": "dist/index.js",
   "repository": {

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

@@ -1,7 +1,7 @@
-import { type Children, For } from "@alloy-js/core";
+import { For, type Children } from "@alloy-js/core";
 import * as cs from "@alloy-js/csharp";
 import { Method } from "@alloy-js/csharp";
-import type { Interface, Model } from "@typespec/compiler";
+import { isVoidType, type Interface, type Model } from "@typespec/compiler";
 import { useTsp } from "../../../core/index.js";
 import { Property } from "../property/property.jsx";
 import { TypeExpression } from "../type-expression.jsx";
@@ -53,8 +53,12 @@ export function ClassDeclaration(props: ClassDeclarationProps): Children {
 }
 
 function ClassProperties(props: ClassPropertiesProps): Children {
+  // Ignore 'void' type properties which is not valid in csharp
+  const properties = Array.from(props.type.properties.entries()).filter(
+    ([_, p]) => !isVoidType(p.type),
+  );
   return (
-    <For each={props.type.properties.entries()} hardline>
+    <For each={properties} hardline>
       {([name, property]) => <Property type={property} jsonAttributes={props.jsonAttributes} />}
     </For>
   );

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

@@ -131,3 +131,67 @@ describe("Record map to IDictionary", () => {
     );
   });
 });
+
+describe("Nullable union", () => {
+  it("nullable boolean", async () => {
+    const { Pet } = (await runner.compile(`
+      @test model Pet {
+        @test name: boolean | null;
+      }
+    `)) as { Pet: Model };
+
+    const res = render(
+      <Wrapper>
+        <ClassDeclaration type={Pet} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+          namespace TestNamespace
+          {
+              class Pet
+              {
+                  public required bool? name { get; set; }
+              }
+          }
+        `,
+    );
+  });
+});
+
+describe("Literal types", () => {
+  it("literal types (string, int, double, bool)", async () => {
+    const { Pet } = (await runner.compile(`
+      @test model Pet {
+        @test boolName: true;
+        @test intName: 42;
+        @test doubleName: 3.14;
+        @test stringName: "Hello";
+      }
+    `)) as { Pet: Model };
+
+    const res = render(
+      <Wrapper>
+        <ClassDeclaration type={Pet} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+          namespace TestNamespace
+          {
+              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,7 +1,15 @@
 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,
+  isNullType,
+  isVoidType,
+  type IntrinsicType,
+  type Scalar,
+  type Type,
+  type Union,
+} from "@typespec/compiler";
 import type { Typekit } from "@typespec/compiler/typekit";
 import { useTsp } from "../../core/index.js";
 import { reportTypescriptDiagnostic } from "../../typescript/lib.js";
@@ -12,6 +20,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 +40,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(
@@ -33,6 +56,28 @@ export function TypeExpression(props: TypeExpressionProps): Children {
   );
 }
 
+/** Get the inner type if the union is a nullable, otherwise return undefined */
+function getNullableUnionInnerType(u: Union): Type | undefined {
+  const isNull = (type: Type) => isNullType(type) || isVoidType(type);
+
+  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;
+}
+
 const intrinsicNameToCSharpType = new Map<string, string | null>([
   // Core types
   ["unknown", "object"], // Matches C#'s `object`
@@ -112,8 +157,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: