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

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

@@ -1,6 +1,6 @@
 import { Tester } from "#test/test-host.js";
-import { type Children } from "@alloy-js/core";
-import { ClassDeclaration, createCSharpNamePolicy, Namespace, SourceFile } from "@alloy-js/csharp";
+import { List, type Children } from "@alloy-js/core";
+import { ClassDeclaration, createCSharpNamePolicy, 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";
@@ -16,11 +16,9 @@ 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>
+      <SourceFile path="test.cs">
+        <ClassDeclaration name="Test">{props.children}</ClassDeclaration>
+      </SourceFile>
     </Output>
   );
 }
@@ -37,12 +35,47 @@ it("maps prop: string | null to nullable property", async () => {
       <Property type={prop1} />
     </Wrapper>,
   ).toRenderTo(`
-      namespace TestNamespace
+      class Test
       {
-          class Test
-          {
-              public required string? Prop1 { get; set; }
-          }
+          public required string? Prop1 { get; set; }
+      }
+  `);
+});
+
+it("maps optional properties to nullable properties", async () => {
+  const { prop1 } = await tester.compile(t.code`
+    model TestModel {
+      ${t.modelProperty("prop1")}?: string;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <Property type={prop1} />
+    </Wrapper>,
+  ).toRenderTo(`
+      class Test
+      {
+          public string? Prop1 { get; set; }
+      }
+  `);
+});
+
+it("maps optional and nullable properties to nullable properties", async () => {
+  const { prop1 } = await tester.compile(t.code`
+    model TestModel {
+      ${t.modelProperty("prop1")}?: string | null;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <Property type={prop1} />
+    </Wrapper>,
+  ).toRenderTo(`
+      class Test
+      {
+          public string? Prop1 { get; set; }
       }
   `);
 });
@@ -60,13 +93,10 @@ describe("jsonAttributes", () => {
         <Property type={prop1} jsonAttributes />
       </Wrapper>,
     ).toRenderTo(`
-      namespace TestNamespace
+      class Test
       {
-          class Test
-          {
-              [System.Text.Json.JsonPropertyName("prop1")]
-              public required string Prop1 { get; set; }
-          }
+          [System.Text.Json.JsonPropertyName("prop1")]
+          public required string Prop1 { get; set; }
       }
   `);
   });
@@ -84,14 +114,67 @@ describe("jsonAttributes", () => {
         <Property type={prop1} jsonAttributes />
       </Wrapper>,
     ).toRenderTo(`
-      namespace TestNamespace
+        class Test
+        {
+            [System.Text.Json.JsonPropertyName("prop_1")]
+            public required string Prop1 { get; set; }
+        }
+  `);
+  });
+
+  it("inherit prop: override, new", async () => {
+    const r = await tester.compile(t.code`
+      model TestModel extends BaseModel {
+        ${t.modelProperty("prop1")}: string;
+        ${t.modelProperty("prop2")}: string | null;
+      }
+      model BaseModel {
+        prop1: string | null;
+        prop2: string | null;
+      }
+    `);
+
+    expect(
+      <Wrapper>
+        <List>
+          <Property type={r.prop1} />
+          <Property type={r.prop2} />
+        </List>
+      </Wrapper>,
+    ).toRenderTo(`
+      class Test
       {
-          class Test
-          {
-              [System.Text.Json.JsonPropertyName("prop_1")]
-              public required string Prop1 { get; set; }
-          }
+          public new required string Prop1 { get; set; }
+          public override required string? Prop2 { get; set; }
       }
-  `);
+    `);
+  });
+
+  it("inherit prop: virtual", async () => {
+    const r = await tester.compile(t.code`
+      model TestModel extends BaseModel {
+        prop1: string;
+        prop2: string | null;
+      }
+      model BaseModel {
+        ${t.modelProperty("prop1")}: string | null;
+        ${t.modelProperty("prop2")}: string | null;
+      }
+    `);
+
+    expect(
+      <Wrapper>
+        <List>
+          <Property type={r.prop1} />
+          <Property type={r.prop2} />
+        </List>
+      </Wrapper>,
+    ).toRenderTo(`
+      class Test
+      {
+          public required string? Prop1 { get; set; }
+          public virtual required string? Prop2 { get; set; }
+      }
+    `);
   });
 });

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

@@ -1,10 +1,11 @@
 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 { getProperty, 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";
+import { getNullableUnionInnerType } from "../utils/nullable-util.js";
 
 export interface PropertyProps {
   type: ModelProperty;
@@ -16,14 +17,47 @@ export interface PropertyProps {
  * Create a C# property declaration from a TypeSpec property type.
  */
 export function Property(props: PropertyProps): Children {
-  const result = preprocessPropertyType(props.type.type);
+  const result = preprocessPropertyType(props.type);
   const { $ } = useTsp();
 
+  let overrideType: "" | "override" | "new" = "";
+  let isVirtual = false;
+  if (props.type.model) {
+    if (props.type.model.baseModel) {
+      const base = props.type.model.baseModel;
+      const baseProperty = getProperty(base, props.type.name);
+      if (baseProperty) {
+        const baseResult = preprocessPropertyType(baseProperty);
+        if (baseResult.nullable === result.nullable && baseResult.type === result.type) {
+          overrideType = "override";
+        } else {
+          overrideType = "new";
+        }
+      }
+    }
+    if (
+      overrideType === "" &&
+      props.type.model.derivedModels &&
+      props.type.model.derivedModels.length > 0
+    ) {
+      isVirtual = props.type.model.derivedModels.some((derived) => {
+        const derivedProperty = derived.properties.get(props.type.name);
+        if (derivedProperty) {
+          const derivedResult = preprocessPropertyType(derivedProperty);
+          return derivedResult.nullable === result.nullable && derivedResult.type === result.type;
+        }
+      });
+    }
+  }
+
   return (
     <cs.Property
       name={props.type.name}
       type={<TypeExpression type={result.type} />}
+      override={overrideType === "override"}
+      new={overrideType === "new"}
       public
+      virtual={isVirtual}
       required={!props.type.optional}
       nullable={result.nullable}
       doc={getDocComments($, props.type)}
@@ -44,19 +78,17 @@ function JsonNameAttribute(props: JsonNameAttributeProps): Children {
   return <Attribute name="System.Text.Json.JsonPropertyName" args={[JSON.stringify(jsonName)]} />;
 }
 
-function preprocessPropertyType(type: Type): { type: Type; nullable: boolean } {
-  const { $ } = useTsp();
+function preprocessPropertyType(prop: ModelProperty): { type: Type; nullable: boolean } {
+  const type = prop.type;
 
   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 };
+    const innerType = getNullableUnionInnerType(type);
+    if (innerType) {
+      return { type: innerType, nullable: true };
     } else {
-      return { type, nullable: false };
+      return { type, nullable: prop.optional };
     }
   } else {
-    return { type, nullable: false };
+    return { type, nullable: prop.optional };
   }
 }

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,9 +1,17 @@
-import { type Children, code } from "@alloy-js/core";
+import { Experimental_OverridableComponent } from "#core/index.js";
+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 {
@@ -11,9 +19,19 @@ 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 <Reference refkey={efRefkey(props.type)} />;
+    return (
+      <Experimental_OverridableComponent reference type={props.type}>
+        <Reference refkey={efRefkey(props.type)} />
+      </Experimental_OverridableComponent>
+    );
   }
   if ($.scalar.is(props.type)) {
     return getScalarIntrinsicExpression($, props.type);
@@ -21,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(
@@ -107,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/src/testing/scenario-test/harness.ts

@@ -198,7 +198,12 @@ function describeScenarios(
               );
 
               if (SCENARIOS_UPDATE) {
-                testBlock.content = await languageConfiguration.format(result);
+                try {
+                  testBlock.content = await languageConfiguration.format(result);
+                } catch {
+                  // If formatting fails, we still want to update the content
+                  testBlock.content = result;
+                }
               } else {
                 const expected = await languageConfiguration.format(testBlock.content);
                 const actual = await languageConfiguration.format(result);

package/src/typescript/components/interface-member.tsx

@@ -1,7 +1,6 @@
 import { type Children } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
 import { isNeverType, type ModelProperty, type Operation } from "@typespec/compiler";
-import { getHttpPart } from "@typespec/http";
 import { useTsp } from "../../core/context/tsp-context.js";
 import { InterfaceMethod } from "./interface-method.jsx";
 import { TypeExpression } from "./type-expression.js";
@@ -23,20 +22,15 @@ export function InterfaceMember(props: InterfaceMemberProps) {
       return null;
     }
 
-    let unpackedType = props.type.type;
-    const part = getHttpPart($.program, props.type.type);
-    if (part) {
-      unpackedType = part.type;
-    }
+    const unpackedType = props.type.type;
 
-    return (
-      <ts.InterfaceMember
-        doc={doc}
-        name={name}
-        optional={props.optional ?? props.type.optional}
-        type={<TypeExpression type={unpackedType} />}
-      />
-    );
+    const interfaceMemberProps = {
+      doc,
+      name,
+      optional: props.optional ?? props.type.optional,
+      type: <TypeExpression type={unpackedType} />,
+    };
+    return <ts.InterfaceMember {...interfaceMemberProps} />;
   }
 
   if ($.operation.is(props.type)) {

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

@@ -2,7 +2,7 @@ import { For } from "@alloy-js/core";
 import { Reference, ValueExpression } from "@alloy-js/typescript";
 import type { IntrinsicType, Model, Scalar, Type } from "@typespec/compiler";
 import type { Typekit } from "@typespec/compiler/typekit";
-import "@typespec/http/experimental/typekit";
+import { Experimental_OverridableComponent } from "../../core/components/overrides/component-overrides.jsx";
 import { useTsp } from "../../core/context/tsp-context.js";
 import { reportTypescriptDiagnostic } from "../../typescript/lib.js";
 import { efRefkey } from "../utils/refkey.js";
@@ -25,11 +25,15 @@ export interface TypeExpressionProps {
 
 export function TypeExpression(props: TypeExpressionProps) {
   const { $ } = useTsp();
-  const type = $.httpPart.unpack(props.type);
+  const type = props.type;
   if (!props.noReference && isDeclaration($, type)) {
     // todo: probably need abstraction around deciding what's a declaration in the output
     // (it may not correspond to things which are declarations in TypeSpec?)
-    return <Reference refkey={efRefkey(type)} />;
+    return (
+      <Experimental_OverridableComponent reference type={type}>
+        <Reference refkey={efRefkey(type)} />
+      </Experimental_OverridableComponent>
+    );
     //throw new Error("Reference not implemented");
   }
 
@@ -69,11 +73,6 @@ export function TypeExpression(props: TypeExpressionProps) {
         return <RecordExpression elementType={elementType} />;
       }
 
-      if ($.httpPart.is(type)) {
-        const partType = $.httpPart.unpack(type);
-        return <TypeExpression type={partType} />;
-      }
-
       return <InterfaceExpression type={type} />;
     case "Operation":
       return <FunctionType type={type} />;

package/src/typescript/components/type-transform.tsx

@@ -227,7 +227,7 @@ export function ModelTransformExpression(props: ModelTransformExpressionProps) {
       {mapJoin(
         () => modelProperties,
         (_, property) => {
-          const unpackedType = $.httpPart.unpack(property.type) ?? property.type;
+          const unpackedType = property.type;
           let targetPropertyName = property.name;
           let sourcePropertyName = namePolicy.getName(property.name, "interface-member");
 
@@ -368,9 +368,7 @@ export function TypeTransformCall(props: TypeTransformCallProps): Children {
   }
   const transformType = collapsedProperty?.type ?? props.type;
   if ($.model.is(transformType) && $.array.is(transformType)) {
-    const unpackedElement =
-      $.httpPart.unpack($.array.getElementType(transformType)) ??
-      $.array.getElementType(transformType);
+    const unpackedElement = $.array.getElementType(transformType);
     return (
       <ts.FunctionCallExpression
         target={ArraySerializerRefkey}
@@ -380,9 +378,7 @@ export function TypeTransformCall(props: TypeTransformCallProps): Children {
   }
 
   if ($.model.is(transformType) && $.record.is(transformType)) {
-    const unpackedElement =
-      $.httpPart.unpack($.record.getElementType(transformType)) ??
-      $.record.getElementType(transformType);
+    const unpackedElement = $.record.getElementType(transformType);
     return (
       <ts.FunctionCallExpression
         target={RecordSerializerRefkey}