@typespec/emitter-framework 0.11.0-dev.6 → 0.11.0-dev.8

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

@@ -1,7 +1,7 @@
 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";
@@ -20,11 +20,44 @@ export function Property(props: PropertyProps): Children {
   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)}

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

@@ -1,11 +1,9 @@
-import { type Children, render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
-import { Namespace, SourceFile } from "@alloy-js/csharp";
+import { type Children } from "@alloy-js/core";
+import { 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 { beforeEach, describe, expect, 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";
@@ -19,9 +17,7 @@ beforeEach(async () => {
 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,61 +39,37 @@ 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 () => {
@@ -108,27 +80,19 @@ describe("Record map to IDictionary", () => {
       @test model Pet {}
     `)) as { test: ModelProperty; Pet: Model };
 
-    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>
+    `);
   });
 });
 
@@ -140,24 +104,16 @@ describe("Nullable union", () => {
       }
     `)) as { Pet: Model };
 
-    const res = render(
+    expect(
       <Wrapper>
         <ClassDeclaration type={Pet} />
       </Wrapper>,
-    );
-
-    assertFileContents(
-      res,
-      d`
-          namespace TestNamespace
-          {
-              class Pet
-              {
-                  public required bool? name { get; set; }
-              }
-          }
-        `,
-    );
+    ).toRenderTo(`
+      class Pet
+      {
+          public required bool? name { get; set; }
+      }
+    `);
   });
 });
 
@@ -172,26 +128,18 @@ describe("Literal types", () => {
       }
     `)) as { Pet: Model };
 
-    const res = render(
+    expect(
       <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; }
-              }
-          }
-        `,
-    );
+    ).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/test/typescript/components/arrow-function.test.tsx

@@ -1,12 +1,9 @@
-import { render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
 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 { 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", () => {
@@ -21,22 +18,17 @@ describe("arrow functions with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    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 () => {
@@ -44,20 +36,15 @@ describe("arrow functions with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    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 () => {
@@ -65,7 +52,7 @@ describe("arrow functions with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <ArrowFunction
@@ -74,13 +61,8 @@ describe("arrow functions with a `type` prop", () => {
           />
         </SourceFile>
       </Output>,
-    );
-
-    assertFileContents(
-      res,
-      d`
+    ).toRenderTo(`
         (additionalParam: number, id: string): string => {}
-      `,
-    );
+      `);
   });
 });

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

@@ -1,12 +1,9 @@
-import { render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
 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 { 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", () => {
@@ -21,22 +18,17 @@ describe("function expressions with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    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 () => {
@@ -44,20 +36,15 @@ describe("function expressions with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    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 () => {
@@ -65,7 +52,7 @@ describe("function expressions with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    const res = render(
+    expect(
       <Output program={runner.program}>
         <SourceFile path="test.ts">
           <FunctionExpression
@@ -74,13 +61,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,12 +1,9 @@
-import { render } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
 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 { 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", () => {
@@ -21,20 +18,15 @@ describe("function types with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    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 () => {
@@ -42,20 +34,15 @@ describe("function types with a `type` prop", () => {
       @test op getName(id: string): string;
     `)) as { getName: Operation };
 
-    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 () => {
@@ -63,19 +50,14 @@ describe("function types with a `type` prop", () => {
       @test 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
-      `,
-    );
+      `);
   });
 });