@typespec/emitter-framework 0.9.0-dev.3 → 0.9.0-dev.7

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

@@ -0,0 +1,97 @@
+import { Tester } from "#test/test-host.js";
+import { type Children } from "@alloy-js/core";
+import { ClassDeclaration, createCSharpNamePolicy, Namespace, 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";
+import { Property } from "./property.jsx";
+
+let tester: TesterInstance;
+
+beforeEach(async () => {
+  tester = await Tester.createInstance();
+});
+
+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>
+    </Output>
+  );
+}
+
+it("maps prop: string | null to nullable property", async () => {
+  const { prop1 } = await tester.compile(t.code`
+    model TestModel {
+      ${t.modelProperty("prop1")}: string | null;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <Property type={prop1} />
+    </Wrapper>,
+  ).toRenderTo(`
+      namespace TestNamespace
+      {
+        class Test
+        {
+          public required string? Prop1 { get; set; }
+        }
+      }
+  `);
+});
+
+describe("jsonAttributes", () => {
+  it("adds [JsonNameAttribute]", async () => {
+    const { prop1 } = await tester.compile(t.code`
+    model TestModel {
+      ${t.modelProperty("prop1")}: string;
+    }
+  `);
+
+    expect(
+      <Wrapper>
+        <Property type={prop1} jsonAttributes />
+      </Wrapper>,
+    ).toRenderTo(`
+      namespace TestNamespace
+      {
+        class Test
+        {
+          [System.Text.Json.JsonPropertyName("prop1")]
+          public required string Prop1 { get; set; }
+        }
+      }
+  `);
+  });
+
+  it("adds [JsonNameAttribute] respecting encodedName", async () => {
+    const { prop1 } = await tester.compile(t.code`
+    model TestModel {
+      @encodedName("application/json", "prop_1")
+      ${t.modelProperty("prop1")}: string;
+    }
+  `);
+
+    expect(
+      <Wrapper>
+        <Property type={prop1} jsonAttributes />
+      </Wrapper>,
+    ).toRenderTo(`
+      namespace TestNamespace
+      {
+        class Test
+        {
+          [System.Text.Json.JsonPropertyName("prop_1")]
+          public required string Prop1 { get; set; }
+        }
+      }
+  `);
+  });
+});

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

@@ -0,0 +1,62 @@
+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 { useTsp } from "../../../core/index.js";
+import { TypeExpression } from "../type-expression.jsx";
+import { getDocComments } from "../utils/doc-comments.jsx";
+
+export interface PropertyProps {
+  type: ModelProperty;
+  /** If set the property will add the json serialization attributes(using System.Text.Json). */
+  jsonAttributes?: boolean;
+}
+
+/**
+ * Create a C# property declaration from a TypeSpec property type.
+ */
+export function Property(props: PropertyProps): Children {
+  const result = preprocessPropertyType(props.type.type);
+  const { $ } = useTsp();
+
+  return (
+    <cs.Property
+      name={props.type.name}
+      type={<TypeExpression type={result.type} />}
+      public
+      required={!props.type.optional}
+      nullable={result.nullable}
+      doc={getDocComments($, props.type)}
+      attributes={props.jsonAttributes ? [<JsonNameAttribute type={props.type} />] : undefined}
+      get
+      set
+    />
+  );
+}
+
+export interface JsonNameAttributeProps {
+  type: ModelProperty;
+}
+
+function JsonNameAttribute(props: JsonNameAttributeProps): Children {
+  const { program } = useTsp();
+  const jsonName = resolveEncodedName(program, props.type, "application/json");
+  return <Attribute name="System.Text.Json.JsonPropertyName" args={[JSON.stringify(jsonName)]} />;
+}
+
+function preprocessPropertyType(type: Type): { type: Type; nullable: boolean } {
+  const { $ } = useTsp();
+
+  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 };
+    } else {
+      return { type, nullable: false };
+    }
+  } else {
+    return { type, nullable: false };
+  }
+}

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

@@ -0,0 +1,133 @@
+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 { Output } from "../../core/index.js";
+import { ClassDeclaration } from "./class/declaration.js";
+import { TypeExpression } from "./type-expression.jsx";
+
+let runner: BasicTestRunner;
+
+beforeEach(async () => {
+  runner = await createEmitterFrameworkTestRunner();
+});
+
+function Wrapper(props: { children: Children }) {
+  return (
+    <Output program={runner.program}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.ts">{props.children}</SourceFile>
+      </Namespace>
+    </Output>
+  );
+}
+
+async function compileType(ref: string) {
+  const { test } = await runner.compile(`
+    model Test {
+      @test test: ${ref};
+    }
+  `);
+
+  return (test as ModelProperty).type;
+}
+
+describe("map scalar to c# built-in types", () => {
+  it.each([
+    ["string", "string"],
+    ["int32", "int"],
+    ["int64", "long"],
+  ])("%s => %s", async (tspType, csType) => {
+    const type = await compileType(tspType);
+    const res = render(
+      <Wrapper>
+        <TypeExpression type={type} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+          namespace TestNamespace
+          {
+              ${csType}
+          }
+        `,
+    );
+  });
+});
+
+it("maps array to c# array", async () => {
+  const type = await compileType("int32[]");
+  const res = render(
+    <Wrapper>
+      <TypeExpression type={type} />
+    </Wrapper>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+          namespace TestNamespace
+          {
+              int[]
+          }
+        `,
+  );
+});
+
+describe("Record map to IDictionary", () => {
+  it("for primitive types", async () => {
+    const type = await compileType("Record<int32>");
+    const res = render(
+      <Wrapper>
+        <TypeExpression type={type} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+          namespace TestNamespace
+          {
+              IDictionary<string, int>
+          }
+        `,
+    );
+  });
+
+  it("for models", async () => {
+    const { test, Pet } = (await runner.compile(`
+      model Test {
+        @test test: Record<Pet>;
+      }
+      @test model Pet {}
+    `)) as { test: ModelProperty; Pet: Model };
+
+    const res = render(
+      <Wrapper>
+        <ClassDeclaration type={Pet} />
+        <hbr />
+        <TypeExpression type={test.type} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+          namespace TestNamespace
+          {
+              class Pet
+              {
+          
+              }
+              IDictionary<string, Pet>
+          }
+        `,
+    );
+  });
+});

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

@@ -1,7 +1,7 @@
-import { Children } from "@alloy-js/core";
+import { type Children, code } from "@alloy-js/core";
 import { Reference } from "@alloy-js/csharp";
-import { IntrinsicType, Scalar, Type } from "@typespec/compiler";
-import { Typekit } from "@typespec/compiler/typekit";
+import { getTypeName, 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 { efRefkey } from "./utils/refkey.js";
@@ -17,8 +17,15 @@ export function TypeExpression(props: TypeExpressionProps): Children {
   }
   if ($.scalar.is(props.type)) {
     return getScalarIntrinsicExpression($, props.type);
+  } else if ($.array.is(props.type)) {
+    return code`${(<TypeExpression type={props.type.indexer.value} />)}[]`;
+  } else if ($.record.is(props.type)) {
+    return code`IDictionary<string, ${(<TypeExpression type={props.type.indexer.value} />)}>`;
   }
-  throw new Error("not implemented");
+
+  throw new Error(
+    `Unsupported type for TypeExpression: ${props.type.kind} (${getTypeName(props.type)})`,
+  );
 }
 
 const intrinsicNameToCSharpType = new Map<string, string | null>([

package/src/csharp/components/utils/doc-comments.tsx

@@ -0,0 +1,58 @@
+import { type Children, List } from "@alloy-js/core";
+import * as cs from "@alloy-js/csharp";
+import { getReturnsDoc, type Type } from "@typespec/compiler";
+import type { Typekit } from "@typespec/compiler/typekit";
+
+/**
+ * Helper to render a doc string for a given TypeSpec type.
+ *
+ * This is not a JSX component as it needs to return undefined if there is no doc.
+ *
+ * @param $ The Typekit instance
+ * @param type The TypeSpec type to generate documentation for
+ * @returns A DocSummary component containing the rendered doc string, or undefined if no doc is available.
+ */
+export function getDocComments($: Typekit, type: Type): Children {
+  const typeDoc = $.type.getDoc(type);
+  if (!typeDoc) {
+    return undefined;
+  }
+
+  const docElements: Children[] = [];
+
+  // Add main type documentation
+  docElements.push(
+    <cs.DocSummary>
+      <cs.DocFromMarkdown markdown={typeDoc} />
+    </cs.DocSummary>,
+  );
+
+  // Add operation-specific documentation if applicable
+  if ($.operation.is(type)) {
+    // Add parameter documentation
+    const paramDocs = [];
+    for (const param of type.parameters.properties.values()) {
+      const paramDoc = $.type.getDoc(param);
+      if (paramDoc) {
+        paramDocs.push(
+          <cs.DocParam name={param.name}>
+            <cs.DocFromMarkdown markdown={paramDoc} />
+          </cs.DocParam>,
+        );
+      }
+    }
+    docElements.push(...paramDocs);
+
+    // Add return documentation
+    const returnDoc = getReturnsDoc($.program, type);
+    if (returnDoc) {
+      docElements.push(
+        <cs.DocReturns>
+          <cs.DocFromMarkdown markdown={returnDoc} />
+        </cs.DocReturns>,
+      );
+    }
+  }
+
+  return <List doubleHardline>{docElements}</List>;
+}

package/src/testing/index.ts

@@ -1,5 +1,5 @@
 import { resolvePath } from "@typespec/compiler";
-import { createTestLibrary, TypeSpecTestLibrary } from "@typespec/compiler/testing";
+import { createTestLibrary, type TypeSpecTestLibrary } from "@typespec/compiler/testing";
 import { fileURLToPath } from "url";
 
 export const EmitterFrameworkTestLibrary: TypeSpecTestLibrary = createTestLibrary({

package/src/testing/scenario-test/harness.ts

@@ -1,11 +1,11 @@
 import { normalizePath } from "@typespec/compiler";
-import { TypeSpecTestLibrary } from "@typespec/compiler/testing";
+import type { TypeSpecTestLibrary } from "@typespec/compiler/testing";
 import { readdirSync, readFileSync, statSync, writeFileSync } from "fs";
 import minimist from "minimist";
 import path from "path";
 import { format } from "prettier";
 import { afterAll, describe, expect, it } from "vitest";
-import { LanguageConfiguration, SnippetExtractor } from "./snippet-extractor.js";
+import type { LanguageConfiguration, SnippetExtractor } from "./snippet-extractor.js";
 import { emitWithDiagnostics } from "./test-host.js";
 
 const rawArgs = process.env.TEST_ARGS ? process.env.TEST_ARGS.split(" ") : [];

package/src/testing/scenario-test/test-host.ts

@@ -1,10 +1,10 @@
-import { CompilerOptions, Diagnostic } from "@typespec/compiler";
+import type { CompilerOptions, Diagnostic } from "@typespec/compiler";
 import {
-  BasicTestRunner,
+  type BasicTestRunner,
   createTestHost,
   createTestWrapper,
-  TestHostConfig,
-  TypeSpecTestLibrary,
+  type TestHostConfig,
+  type TypeSpecTestLibrary,
 } from "@typespec/compiler/testing";
 import { HttpTestLibrary } from "@typespec/http/testing";
 import { RestTestLibrary } from "@typespec/rest/testing";

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

@@ -1,5 +1,5 @@
-import * as ay from "@alloy-js/core";
-import { Type } from "@typespec/compiler";
+import { code } from "@alloy-js/core";
+import type { Type } from "@typespec/compiler";
 import { TypeExpression } from "./type-expression.js";
 
 export interface ArrayExpressionProps {
@@ -7,5 +7,5 @@ export interface ArrayExpressionProps {
 }
 
 export function ArrayExpression({ elementType }: ArrayExpressionProps) {
-  return ay.code`Array<${(<TypeExpression type={elementType} />)}>`;
+  return code`Array<${(<TypeExpression type={elementType} />)}>`;
 }

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

@@ -1,6 +1,6 @@
-import { splitProps } from "@alloy-js/core/jsx-runtime";
+import { splitProps } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
-import { Operation } from "@typespec/compiler";
+import type { Operation } from "@typespec/compiler";
 import { buildParameterDescriptors, getReturnType } from "../utils/operation.js";
 import { TypeExpression } from "./type-expression.jsx";
 

package/src/typescript/components/class-method.tsx

@@ -1,5 +1,5 @@
 import * as ts from "@alloy-js/typescript";
-import { Operation } from "@typespec/compiler";
+import type { Operation } from "@typespec/compiler";
 import { buildParameterDescriptors, getReturnType } from "../utils/operation.js";
 import { TypeExpression } from "./type-expression.jsx";
 

package/src/typescript/components/enum-declaration.tsx

@@ -1,6 +1,6 @@
-import * as ay from "@alloy-js/core";
+import { type Children, For, type Refkey } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
-import { Enum, EnumMember as TspEnumMember, Union } from "@typespec/compiler";
+import type { Enum, EnumMember as TspEnumMember, Union } from "@typespec/compiler";
 import { useTsp } from "../../core/context/tsp-context.js";
 import { reportDiagnostic } from "../../lib.js";
 import { declarationRefkeys, efRefkey } from "../utils/refkey.js";
@@ -38,7 +38,7 @@ export function EnumDeclaration(props: EnumDeclarationProps) {
       default={props.default}
       export={props.export}
     >
-      <ay.For each={members} joiner={",\n"}>
+      <For each={members} joiner={",\n"}>
         {([key, value]) => {
           const memberDoc = $.type.getDoc(value);
           return (
@@ -51,15 +51,15 @@ export function EnumDeclaration(props: EnumDeclarationProps) {
             />
           );
         }}
-      </ay.For>
+      </For>
     </ts.EnumDeclaration>
   );
 }
 
 export interface EnumMemberProps {
   type: TspEnumMember;
-  doc?: ay.Children;
-  refkey?: ay.Refkey;
+  doc?: Children;
+  refkey?: Refkey;
 }
 
 export function EnumMember(props: EnumMemberProps) {

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

@@ -1,5 +1,5 @@
 import * as ts from "@alloy-js/typescript";
-import { Model, Operation } from "@typespec/compiler";
+import type { Model, Operation } from "@typespec/compiler";
 import { useTsp } from "../../core/index.js";
 import { buildParameterDescriptors, getReturnType } from "../utils/operation.js";
 import { declarationRefkeys } from "../utils/refkey.js";

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

@@ -1,6 +1,6 @@
-import { splitProps } from "@alloy-js/core/jsx-runtime";
+import { splitProps } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
-import { Operation } from "@typespec/compiler";
+import type { Operation } from "@typespec/compiler";
 import { buildParameterDescriptors, getReturnType } from "../utils/operation.js";
 import { TypeExpression } from "./type-expression.jsx";
 

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

@@ -1,6 +1,6 @@
-import { splitProps } from "@alloy-js/core/jsx-runtime";
+import { splitProps } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
-import { Operation } from "@typespec/compiler";
+import type { Operation } from "@typespec/compiler";
 import { buildParameterDescriptors, getReturnType } from "../utils/operation.js";
 import { TypeExpression } from "./type-expression.jsx";
 

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

@@ -1,15 +1,14 @@
-import * as ay from "@alloy-js/core";
-import { Children, mapJoin } from "@alloy-js/core";
+import { Block, type Children, For, mapJoin } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
 import {
-  Interface,
+  type Interface,
   isNeverType,
-  Model,
-  ModelProperty,
-  Operation,
-  RekeyableMap,
+  type Model,
+  type ModelProperty,
+  type Operation,
+  type RekeyableMap,
 } from "@typespec/compiler";
-import { Typekit } from "@typespec/compiler/typekit";
+import type { Typekit } from "@typespec/compiler/typekit";
 import { createRekeyableMap } from "@typespec/compiler/utils";
 import { useTsp } from "../../core/context/tsp-context.js";
 import { reportDiagnostic } from "../../lib.js";
@@ -74,9 +73,9 @@ export interface InterfaceExpressionProps extends ts.InterfaceExpressionProps {
 
 export function InterfaceExpression(props: InterfaceExpressionProps) {
   return (
-    <ay.Block>
+    <Block>
       <InterfaceBody {...props} />
-    </ay.Block>
+    </Block>
   );
 }
 
@@ -156,11 +155,11 @@ function InterfaceBody(props: TypedInterfaceDeclarationProps): Children {
 
   return (
     <>
-      <ay.For each={validTypeMembers} semicolon line {...enderProp}>
+      <For each={validTypeMembers} semicolon line {...enderProp}>
         {(typeMember) => {
           return <InterfaceMember type={typeMember} />;
         }}
-      </ay.For>
+      </For>
       {props.children}
     </>
   );

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

@@ -1,6 +1,6 @@
-import { Children } from "@alloy-js/core";
+import { type Children } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
-import { isNeverType, ModelProperty, Operation } from "@typespec/compiler";
+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";

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

@@ -1,6 +1,6 @@
-import { Children, splitProps } from "@alloy-js/core";
+import { type Children, splitProps } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
-import { Operation } from "@typespec/compiler";
+import type { Operation } from "@typespec/compiler";
 import { useTsp } from "../../core/index.js";
 import { buildParameterDescriptors, getReturnType } from "../utils/operation.js";
 import { TypeExpression } from "./type-expression.jsx";

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

@@ -1,5 +1,5 @@
 import { code } from "@alloy-js/core";
-import { Type } from "@typespec/compiler";
+import type { Type } from "@typespec/compiler";
 import { TypeExpression } from "./type-expression.js";
 
 export interface RecordExpressionProps {

package/src/typescript/components/type-alias-declaration.tsx

@@ -1,5 +1,5 @@
 import * as ts from "@alloy-js/typescript";
-import { Type } from "@typespec/compiler";
+import type { Type } from "@typespec/compiler";
 import { useTsp } from "../../core/context/tsp-context.js";
 import { reportDiagnostic } from "../../lib.js";
 import { declarationRefkeys } from "../utils/refkey.js";

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

@@ -1,5 +1,5 @@
 import * as ts from "@alloy-js/typescript";
-import { Type } from "@typespec/compiler";
+import type { Type } from "@typespec/compiler";
 import { useTsp } from "../../core/index.js";
 import { declarationRefkeys } from "../utils/refkey.js";
 import { EnumDeclaration } from "./enum-declaration.js";

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

@@ -1,7 +1,7 @@
 import { For } from "@alloy-js/core";
 import { Reference, ValueExpression } from "@alloy-js/typescript";
-import { IntrinsicType, Model, Scalar, Type } from "@typespec/compiler";
-import { Typekit } from "@typespec/compiler/typekit";
+import type { IntrinsicType, Model, Scalar, Type } from "@typespec/compiler";
+import type { Typekit } from "@typespec/compiler/typekit";
 import "@typespec/http/experimental/typekit";
 import { useTsp } from "../../core/context/tsp-context.js";
 import { reportTypescriptDiagnostic } from "../../typescript/lib.js";

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

@@ -1,6 +1,6 @@
-import { Children, code, For, mapJoin, Refkey } from "@alloy-js/core";
+import { type Children, code, For, mapJoin, type Refkey } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
-import {
+import type {
   Discriminator,
   Model,
   ModelProperty,
@@ -9,7 +9,7 @@ import {
   Type,
   Union,
 } from "@typespec/compiler";
-import { Typekit } from "@typespec/compiler/typekit";
+import type { Typekit } from "@typespec/compiler/typekit";
 import { createRekeyableMap } from "@typespec/compiler/utils";
 import { useTsp } from "../../core/context/tsp-context.js";
 import { reportDiagnostic } from "../../lib.js";

package/src/typescript/components/union-declaration.tsx

@@ -1,6 +1,6 @@
-import { Children } from "@alloy-js/core";
+import { type Children } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
-import { Enum, Union } from "@typespec/compiler";
+import type { Enum, Union } from "@typespec/compiler";
 import { useTsp } from "../../core/context/tsp-context.js";
 import { reportDiagnostic } from "../../lib.js";
 import { declarationRefkeys } from "../utils/refkey.js";