Add External property to InputType to align with TCGC

Co-authored-by: JoshLove-msft <[email protected]>

Author: Copilot

packages/http-client-csharp/emitter/src/lib/type-converter.ts

@@ -38,6 +38,7 @@ import {
   InputPrimitiveType,
   InputType,
   InputUnionType,
+  ExternalTypeInfo,
 } from "../type/input-type.js";
 import { isReadOnly } from "./utils.js";
 
@@ -81,36 +82,39 @@ export function fromSdkType<T extends SdkType>(
     return retVar as any;
   }
 
-  // Check if this type references an external type
-  if ((sdkType as any).external) {
-    retVar = fromSdkExternalType(sdkContext, sdkType);
-    sdkContext.__typeCache.updateSdkTypeReferences(sdkType, retVar);
-    return retVar as any;
-  }
+  // Extract external type information if present
+  const externalInfo = (sdkType as any).external
+    ? {
+        identity: (sdkType as any).external.identity,
+        package: (sdkType as any).external.package,
+        minVersion: (sdkType as any).external.minVersion,
+      }
+    : undefined;
 
   switch (sdkType.kind) {
     case "nullable":
       const nullableType: InputNullableType = {
         kind: "nullable",
         type: fromSdkType(sdkContext, sdkType.type, sdkProperty, namespace),
         namespace: sdkType.namespace,
+        external: externalInfo,
       };
       retVar = nullableType;
       break;
     case "model":
-      retVar = fromSdkModelType(sdkContext, sdkType);
+      retVar = fromSdkModelType(sdkContext, sdkType, externalInfo);
       break;
     case "enum":
-      retVar = fromSdkEnumType(sdkContext, sdkType);
+      retVar = fromSdkEnumType(sdkContext, sdkType, externalInfo);
       break;
     case "enumvalue":
       retVar = fromSdkEnumValueType(sdkContext, sdkType);
       break;
     case "dict":
-      retVar = fromSdkDictionaryType(sdkContext, sdkType);
+      retVar = fromSdkDictionaryType(sdkContext, sdkType, externalInfo);
       break;
     case "array":
-      retVar = fromSdkArrayType(sdkContext, sdkType);
+      retVar = fromSdkArrayType(sdkContext, sdkType, externalInfo);
       break;
     case "constant":
       if (
@@ -120,20 +124,20 @@ export function fromSdkType<T extends SdkType>(
         sdkType.valueType.kind !== "boolean"
       ) {
         // turn the constant into an extensible enum
-        retVar = createEnumType(sdkContext, sdkType, namespace!);
+        retVar = createEnumType(sdkContext, sdkType, namespace!, externalInfo);
       } else {
         retVar = fromSdkConstantType(sdkContext, sdkType);
       }
       break;
     case "union":
-      retVar = fromUnionType(sdkContext, sdkType);
+      retVar = fromUnionType(sdkContext, sdkType, externalInfo);
       break;
     case "utcDateTime":
     case "offsetDateTime":
-      retVar = fromSdkDateTimeType(sdkContext, sdkType);
+      retVar = fromSdkDateTimeType(sdkContext, sdkType, externalInfo);
       break;
     case "duration":
-      retVar = fromSdkDurationType(sdkContext, sdkType);
+      retVar = fromSdkDurationType(sdkContext, sdkType, externalInfo);
       break;
     case "tuple":
       sdkContext.logger.reportDiagnostic({
@@ -146,6 +150,7 @@ export function fromSdkType<T extends SdkType>(
         name: "tuple",
         crossLanguageDefinitionId: "",
         decorators: sdkType.decorators,
+        external: externalInfo,
       };
       retVar = tupleType;
       break;
@@ -165,11 +170,12 @@ export function fromSdkType<T extends SdkType>(
         name: "credential",
         crossLanguageDefinitionId: "",
         decorators: sdkType.decorators,
+        external: externalInfo,
       };
       retVar = credentialType;
       break;
     default:
-      retVar = fromSdkBuiltInType(sdkContext, sdkType);
+      retVar = fromSdkBuiltInType(sdkContext, sdkType, externalInfo);
       break;
   }
 
@@ -181,6 +187,7 @@ export function fromSdkType<T extends SdkType>(
 function fromSdkModelType(
   sdkContext: CSharpEmitterContext,
   modelType: SdkModelType,
+  externalInfo?: ExternalTypeInfo,
 ): InputModelType {
   // get all unique decorators for the model type from the namespace level and the model level
   let decorators: DecoratorInfo[] = modelType.decorators;
@@ -200,6 +207,7 @@ function fromSdkModelType(
     summary: modelType.summary,
     discriminatorValue: modelType.discriminatorValue,
     decorators: decorators,
+    external: externalInfo,
   } as InputModelType;
 
   sdkContext.__typeCache.updateSdkTypeReferences(modelType, inputModelType);
@@ -281,14 +289,15 @@ function fromSdkModelProperty(
   return property;
 }
 
-function fromSdkEnumType(sdkContext: CSharpEmitterContext, enumType: SdkEnumType): InputEnumType {
-  return createEnumType(sdkContext, enumType, enumType.namespace);
+function fromSdkEnumType(sdkContext: CSharpEmitterContext, enumType: SdkEnumType, externalInfo?: ExternalTypeInfo): InputEnumType {
+  return createEnumType(sdkContext, enumType, enumType.namespace, externalInfo);
 }
 
 function createEnumType(
   sdkContext: CSharpEmitterContext,
   sdkType: SdkConstantType | SdkEnumType,
   namespace: string,
+  externalInfo?: ExternalTypeInfo,
 ): InputEnumType {
   const values: InputEnumValueType[] = [];
 
@@ -313,6 +322,7 @@ function createEnumType(
     // constantType.usage, TODO - constant type now does not have usage. TCGC will add it later
     usage: sdkType.kind === "enum" ? sdkType.usage : UsageFlags.None,
     decorators: sdkType.decorators,
+    external: externalInfo,
   };
 
   sdkContext.__typeCache.updateSdkTypeReferences(sdkType, inputEnumType);
@@ -331,6 +341,7 @@ function createEnumType(
 function fromSdkDateTimeType(
   sdkContext: CSharpEmitterContext,
   dateTimeType: SdkDateTimeType,
+  externalInfo?: ExternalTypeInfo,
 ): InputDateTimeType {
   return {
     kind: dateTimeType.kind,
@@ -340,12 +351,14 @@ function fromSdkDateTimeType(
     crossLanguageDefinitionId: dateTimeType.crossLanguageDefinitionId,
     baseType: dateTimeType.baseType ? fromSdkType(sdkContext, dateTimeType.baseType) : undefined,
     decorators: dateTimeType.decorators,
+    external: externalInfo,
   };
 }
 
 function fromSdkDurationType(
   sdkContext: CSharpEmitterContext,
   durationType: SdkDurationType,
+  externalInfo?: ExternalTypeInfo,
 ): InputDurationType {
   return {
     kind: durationType.kind,
@@ -355,12 +368,14 @@ function fromSdkDurationType(
     crossLanguageDefinitionId: durationType.crossLanguageDefinitionId,
     baseType: durationType.baseType ? fromSdkType(sdkContext, durationType.baseType) : undefined,
     decorators: durationType.decorators,
+    external: externalInfo,
   };
 }
 
 function fromSdkBuiltInType(
   sdkContext: CSharpEmitterContext,
   builtInType: SdkBuiltInType,
+  externalInfo?: ExternalTypeInfo,
 ): InputPrimitiveType {
   return {
     kind: builtInType.kind,
@@ -369,10 +384,11 @@ function fromSdkBuiltInType(
     crossLanguageDefinitionId: builtInType.crossLanguageDefinitionId,
     baseType: builtInType.baseType ? fromSdkType(sdkContext, builtInType.baseType) : undefined,
     decorators: builtInType.decorators,
+    external: externalInfo,
   };
 }
 
-function fromUnionType(sdkContext: CSharpEmitterContext, union: SdkUnionType): InputUnionType {
+function fromUnionType(sdkContext: CSharpEmitterContext, union: SdkUnionType, externalInfo?: ExternalTypeInfo): InputUnionType {
   const variantTypes: InputType[] = [];
   for (const value of union.variantTypes) {
     const variantType = fromSdkType(sdkContext, value);
@@ -385,6 +401,7 @@ function fromUnionType(sdkContext: CSharpEmitterContext, union: SdkUnionType): I
     variantTypes: variantTypes,
     namespace: union.namespace,
     decorators: union.decorators,
+    external: externalInfo,
   };
 }
 
@@ -441,25 +458,29 @@ function createEnumValueType(
 function fromSdkDictionaryType(
   sdkContext: CSharpEmitterContext,
   dictionaryType: SdkDictionaryType,
+  externalInfo?: ExternalTypeInfo,
 ): InputDictionaryType {
   return {
     kind: "dict",
     keyType: fromSdkType(sdkContext, dictionaryType.keyType),
     valueType: fromSdkType(sdkContext, dictionaryType.valueType),
     decorators: dictionaryType.decorators,
+    external: externalInfo,
   };
 }
 
 function fromSdkArrayType(
   sdkContext: CSharpEmitterContext,
   arrayType: SdkArrayType,
+  externalInfo?: ExternalTypeInfo,
 ): InputArrayType {
   return {
     kind: "array",
     name: arrayType.name,
     valueType: fromSdkType(sdkContext, arrayType.valueType),
     crossLanguageDefinitionId: arrayType.crossLanguageDefinitionId,
     decorators: arrayType.decorators,
+    external: externalInfo,
   };
 }
 
@@ -471,20 +492,6 @@ function fromSdkEndpointType(): InputPrimitiveType {
   };
 }
 
-function fromSdkExternalType(
-  sdkContext: CSharpEmitterContext,
-  sdkType: SdkType,
-): InputExternalType {
-  const external = (sdkType as any).external;
-  return {
-    kind: "external",
-    identity: external.identity,
-    package: external.package,
-    minVersion: external.minVersion,
-    decorators: sdkType.decorators,
-  };
-}
-
 /**
  * @beta
  */

packages/http-client-csharp/emitter/src/type/input-type.ts

@@ -16,6 +16,16 @@ import { InputParameterScope } from "./input-parameter-scope.js";
 import { InputServiceMethod } from "./input-service-method.js";
 import { RequestLocation } from "./request-location.js";
 
+/**
+ * External type information for types that map to external library types.
+ * @beta
+ */
+export interface ExternalTypeInfo {
+  identity: string;
+  package?: string;
+  minVersion?: string;
+}
+
 /**
  * The input client type for the CSharp emitter.
  * @beta
@@ -54,6 +64,7 @@ interface InputTypeBase extends DecoratedType {
   summary?: string;
   doc?: string;
   deprecation?: string;
+  external?: ExternalTypeInfo;
 }
 
 export type InputType =

packages/http-client-csharp/emitter/test/Unit/type-converter.test.ts

@@ -127,11 +127,15 @@ describe("External types", () => {
     const prop = testModel.properties.find((p) => p.name === "prop");
     ok(prop, "prop should exist");
 
-    // The type should be an external type
-    strictEqual(prop.type.kind, "external");
-    strictEqual((prop.type as any).identity, "Azure.Core.Expressions.DataFactoryExpression");
-    strictEqual((prop.type as any).package, "Azure.Core.Expressions");
-    strictEqual((prop.type as any).minVersion, "1.0.0");
+    // The type should remain a union but with external info
+    strictEqual(prop.type.kind, "union");
+    ok((prop.type as any).external, "Type should have external info");
+    strictEqual((prop.type as any).external.identity, "Azure.Core.Expressions.DataFactoryExpression");
+    strictEqual((prop.type as any).external.package, "Azure.Core.Expressions");
+    strictEqual((prop.type as any).external.minVersion, "1.0.0");
+    // Verify union variants are preserved
+    ok((prop.type as any).variantTypes, "Union should have variant types");
+    strictEqual((prop.type as any).variantTypes.length, 2, "Union should have 2 variant types");
   });
 
   it("should convert external type on model", async () => {
@@ -165,10 +169,11 @@ describe("External types", () => {
     const jsonElementProp = testModel.properties.find((p) => p.name === "jsonElement");
     ok(jsonElementProp, "jsonElement property should exist");
 
-    // The type should be an external type
-    strictEqual(jsonElementProp.type.kind, "external");
-    strictEqual((jsonElementProp.type as any).identity, "System.Text.Json.JsonElement");
-    strictEqual((jsonElementProp.type as any).package, "System.Text.Json");
-    strictEqual((jsonElementProp.type as any).minVersion, "8.0.0");
+    // The type should remain a model but with external info
+    strictEqual(jsonElementProp.type.kind, "model");
+    ok((jsonElementProp.type as any).external, "Type should have external info");
+    strictEqual((jsonElementProp.type as any).external.identity, "System.Text.Json.JsonElement");
+    strictEqual((jsonElementProp.type as any).external.package, "System.Text.Json");
+    strictEqual((jsonElementProp.type as any).external.minVersion, "8.0.0");
   });
 });

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/ExternalTypeInfo.cs

@@ -0,0 +1,39 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+namespace Microsoft.TypeSpec.Generator.Input
+{
+    /// <summary>
+    /// External type information for types that map to external library types.
+    /// </summary>
+    public sealed class ExternalTypeInfo
+    {
+        /// <summary>
+        /// Construct a new <see cref="ExternalTypeInfo"/> instance
+        /// </summary>
+        /// <param name="identity">The fully qualified name of the external type.</param>
+        /// <param name="package">The package that exports the external type.</param>
+        /// <param name="minVersion">The minimum version of the package.</param>
+        public ExternalTypeInfo(string identity, string? package, string? minVersion)
+        {
+            Identity = identity;
+            Package = package;
+            MinVersion = minVersion;
+        }
+
+        /// <summary>
+        /// The fully qualified name of the external type. For example, "Azure.Core.Expressions.DataFactoryExpression"
+        /// </summary>
+        public string Identity { get; }
+
+        /// <summary>
+        /// The package that exports the external type. For example, "Azure.Core.Expressions"
+        /// </summary>
+        public string? Package { get; }
+
+        /// <summary>
+        /// The minimum version of the package to use for the external type. For example, "1.0.0"
+        /// </summary>
+        public string? MinVersion { get; }
+    }
+}

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/InputType.cs

@@ -21,6 +21,7 @@ protected InputType(string name)
 
         public string Name { get; internal set; }
         public IReadOnlyList<InputDecoratorInfo> Decorators { get; internal set; } = new List<InputDecoratorInfo>();
+        public ExternalTypeInfo? External { get; internal set; }
 
         internal InputType GetCollectionEquivalent(InputType inputType)
         {