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

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";
@@ -41,6 +41,12 @@ export function ClassDeclaration(props: ClassDeclarationProps): Children {
         {...props}
         name={className}
         refkey={refkeys}
+        baseType={
+          props.baseType ??
+          (props.type.kind === "Model" && props.type.baseModel ? (
+            <TypeExpression type={props.type.baseModel} />
+          ) : undefined)
+        }
         doc={getDocComments($, props.type)}
       >
         {props.type.kind === "Model" && (
@@ -53,8 +59,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} doubleHardline>
       {([name, property]) => <Property type={property} jsonAttributes={props.jsonAttributes} />}
     </For>
   );

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

@@ -1,6 +1,6 @@
 import { Tester } from "#test/test-host.js";
 import { type Children } from "@alloy-js/core";
-import { createCSharpNamePolicy, Namespace, SourceFile } from "@alloy-js/csharp";
+import { createCSharpNamePolicy, SourceFile } from "@alloy-js/csharp";
 import { t, type TesterInstance } from "@typespec/compiler/testing";
 import { beforeEach, expect, it } from "vitest";
 import { Output } from "../../../core/index.js";
@@ -16,9 +16,7 @@ function Wrapper(props: { children: Children }) {
   const policy = createCSharpNamePolicy();
   return (
     <Output program={runner.program} namePolicy={policy}>
-      <Namespace name="TestNamespace">
-        <SourceFile path="test.cs">{props.children}</SourceFile>
-      </Namespace>
+      <SourceFile path="test.cs">{props.children}</SourceFile>
     </Output>
   );
 }
@@ -37,14 +35,11 @@ it("renders a basic enum declaration", async () => {
       <EnumDeclaration type={TestEnum} />
     </Wrapper>,
   ).toRenderTo(`
-    namespace TestNamespace
+    enum TestEnum
     {
-        enum TestEnum
-        {
-            Value1,
-            Value2,
-            Value3
-        }
+        Value1,
+        Value2,
+        Value3
     }
   `);
 });
@@ -59,12 +54,9 @@ it("renders an empty enum declaration", async () => {
       <EnumDeclaration type={TestEnum} />
     </Wrapper>,
   ).toRenderTo(`
-    namespace TestNamespace
+    enum TestEnum
     {
-        enum TestEnum
-        {
 
-        }
     }
   `);
 });
@@ -82,13 +74,10 @@ it("can override enum name", async () => {
       <EnumDeclaration type={TestEnum} name="CustomEnumName" />
     </Wrapper>,
   ).toRenderTo(`
-    namespace TestNamespace
+    enum CustomEnumName
     {
-        enum CustomEnumName
-        {
-            Value1,
-            Value2
-        }
+        Value1,
+        Value2
     }
   `);
 });
@@ -106,13 +95,10 @@ it("renders an enum with access modifiers", async () => {
       <EnumDeclaration type={TestEnum} internal />
     </Wrapper>,
   ).toRenderTo(`
-    namespace TestNamespace
+    internal enum TestEnum
     {
-        internal enum TestEnum
-        {
-            Value1,
-            Value2
-        }
+        Value1,
+        Value2
     }
   `);
 });
@@ -128,21 +114,16 @@ it("renders enum with C# naming conventions", async () => {
 
   expect(
     <Output program={runner.program} namePolicy={createCSharpNamePolicy()}>
-      <Namespace name="TestNamespace">
-        <SourceFile path="test.cs">
-          <EnumDeclaration type={TestEnum} />
-        </SourceFile>
-      </Namespace>
+      <SourceFile path="test.cs">
+        <EnumDeclaration type={TestEnum} />
+      </SourceFile>
     </Output>,
   ).toRenderTo(`
-    namespace TestNamespace
+    enum TestEnum
     {
-        enum TestEnum
-        {
-            ValueOne,
-            ValueTwo,
-            ValueThree
-        }
+        ValueOne,
+        ValueTwo,
+        ValueThree
     }
   `);
 });
@@ -159,13 +140,10 @@ it("renders enum with single value", async () => {
       <EnumDeclaration type={TestEnum} />
     </Wrapper>,
   ).toRenderTo(`
-    namespace TestNamespace
-    {
-        enum TestEnum
-        {
-            OnlyValue
-        }
-    }
+      enum TestEnum
+      {
+          OnlyValue
+      }
   `);
 });
 
@@ -184,15 +162,12 @@ it("renders enum with numeric-like member names", async () => {
       <EnumDeclaration type={TestEnum} />
     </Wrapper>,
   ).toRenderTo(`
-    namespace TestNamespace
+    enum TestEnum
     {
-        enum TestEnum
-        {
-            Value0,
-            Value1,
-            Value10,
-            Value100
-        }
+        Value0,
+        Value1,
+        Value10,
+        Value100
     }
   `);
 });
@@ -217,19 +192,16 @@ it("renders multiple enums in the same namespace", async () => {
       <EnumDeclaration type={TestEnum2} />
     </Wrapper>,
   ).toRenderTo(`
-    namespace TestNamespace
+    enum TestEnum1
+    {
+        Value1,
+        Value2
+    }
+    enum TestEnum2
     {
-        enum TestEnum1
-        {
-            Value1,
-            Value2
-        }
-        enum TestEnum2
-        {
-            OptionA,
-            OptionB,
-            OptionC
-        }
+        OptionA,
+        OptionB,
+        OptionC
     }
   `);
 });
@@ -249,19 +221,16 @@ it("renders an enum with doc comments", async () => {
       <EnumDeclaration type={TestEnum} />
     </Wrapper>,
   ).toRenderTo(`
-    namespace TestNamespace
+    enum TestEnum
     {
-        enum TestEnum
-        {
-            /// <summary>
-            /// This is value one
-            /// </summary>
-            Value1,
-            /// <summary>
-            /// This is value two
-            /// </summary>
-            Value2
-        }
+        /// <summary>
+        /// This is value one
+        /// </summary>
+        Value1,
+        /// <summary>
+        /// This is value two
+        /// </summary>
+        Value2
     }
   `);
 });

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 };
   }
 }