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

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

@@ -1,6 +1,15 @@
-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,
+  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";
@@ -11,9 +20,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 +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(
@@ -28,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`
@@ -107,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:

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}

package/test/typescript/components/component-override.test.tsx

@@ -0,0 +1,71 @@
+import {
+  Experimental_ComponentOverrides,
+  Experimental_ComponentOverridesConfig,
+} from "#core/index.js";
+import { FunctionDeclaration } from "#typescript/index.js";
+import { For, List, type Children } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { SourceFile } from "@alloy-js/typescript";
+import type { Namespace } from "@typespec/compiler";
+import { expect, it } from "vitest";
+import { Output } from "../../../src/core/components/output.jsx";
+import { InterfaceDeclaration } from "../../../src/typescript/components/interface-declaration.jsx";
+import { Tester } from "../../test-host.js";
+
+it("uses overridden component", async () => {
+  const { program } = await Tester.compile(`
+          namespace DemoService;
+          model Foo {
+            knownProp: string;
+          }
+
+          op foo(): Foo;
+
+          `);
+
+  const [namespace] = program.resolveTypeReference("DemoService");
+  const models = Array.from((namespace as Namespace).models.values());
+  const operations = Array.from((namespace as Namespace).operations.values());
+
+  expect(
+    <Output program={program}>
+      <TestClientOverrides>
+        <SourceFile path="test.ts">
+          <List hardline>
+            {models.map((model) => (
+              <InterfaceDeclaration export type={model} />
+            ))}
+          </List>
+          <hbr />
+          <For each={operations}>
+            {(operation) => <FunctionDeclaration export type={operation} />}
+          </For>
+        </SourceFile>
+      </TestClientOverrides>
+    </Output>,
+  ).toRenderTo(
+    d`
+      export interface Foo {
+        knownProp: string;
+      }
+      export function foo(): unknown {}
+            `,
+  );
+});
+
+function TestClientOverrides(props: { children?: Children }) {
+  const overrides = Experimental_ComponentOverridesConfig().forTypeKind("Model", {
+    reference: (props) => {
+      if (props.type.name === "Foo") {
+        return "unknown";
+      } else {
+        return props.default;
+      }
+    },
+  });
+  return (
+    <Experimental_ComponentOverrides overrides={overrides}>
+      {props.children}
+    </Experimental_ComponentOverrides>
+  );
+}

package/test/typescript/test-host.ts

@@ -4,18 +4,9 @@ import {
   createTestWrapper,
   expectDiagnosticEmpty,
 } from "@typespec/compiler/testing";
-import { HttpTestLibrary } from "@typespec/http/testing";
 
-export async function createTypespecCliTestHost(
-  options: { libraries: "Http"[] } = { libraries: [] },
-) {
-  const libraries = [];
-  if (options.libraries.includes("Http")) {
-    libraries.push(HttpTestLibrary);
-  }
-  return createTestHost({
-    libraries,
-  });
+export async function createTypespecCliTestHost() {
+  return createTestHost({});
 }
 
 export async function createEmitterFrameworkTestRunner(options: { autoUsings?: string[] } = {}) {
@@ -25,11 +16,8 @@ export async function createEmitterFrameworkTestRunner(options: { autoUsings?: s
   });
 }
 
-export async function getProgram(
-  code: string,
-  options: { libraries: "Http"[] } = { libraries: [] },
-): Promise<Program> {
-  const host = await createTypespecCliTestHost(options);
+export async function getProgram(code: string): Promise<Program> {
+  const host = await createTypespecCliTestHost();
   const wrapper = createTestWrapper(host, {
     compilerOptions: {
       noEmit: true,