@azure-tools/typespec-ts 0.56.1-dev.1 → 0.57.0-dev.10

package/src/modular/serialization/build-serializer-function.ts

@@ -16,7 +16,12 @@ import { refkey } from "../../framework/refkey.js";
 import { reportDiagnostic } from "../../lib.js";
 import type { SdkContext } from "../../utils/interfaces.js";
 import { isAzureCoreErrorType } from "../../utils/model-utils.js";
-import { NameType, normalizeName } from "../../utils/name-utils.js";
+import {
+  formatPropertyAccess,
+  NameType,
+  normalizeName,
+  normalizeSdkPropertyName,
+} from "../../utils/name-utils.js";
 import { getAdditionalPropertiesName, normalizeModelName } from "../emit-models.js";
 import {
   getAllAncestors,
@@ -185,7 +190,6 @@ function buildPolymorphicSerializer(
     ) {
       return;
     }
-    const union = subType?.discriminatedSubtypes ? "_Union" : "";
     if (!subType || !subType?.name) {
       reportDiagnostic(context.program, {
         code: "anonymous-type-serialization",
@@ -193,13 +197,12 @@ function buildPolymorphicSerializer(
       });
       return; // Skip this subtype
     }
-    const rawSubTypeName = `${subType.name}${union}`;
-    const subTypeName = `${normalizeName(rawSubTypeName, NameType.Interface, true)}`;
-    const subtypeSerializerName = normalizeName(
-      `${rawSubTypeName}_Serializer`,
-      NameType.Method,
-      true,
-    );
+    const union = subType.discriminatedSubtypes ? "Union" : "";
+    const subTypeName = normalizeModelName(context, subType, NameType.Interface, !union);
+    const subtypeSerializerName = buildModelSerializer(context, subType, {
+      nameOnly: true,
+      skipDiscriminatedUnionSuffix: false,
+    }) as string;
 
     cases.push(`
         case "${discriminatedValue}":
@@ -208,7 +211,7 @@ function buildPolymorphicSerializer(
   });
 
   statements.push(`
-      switch (item.${normalizeName(type.discriminatorProperty.name, NameType.Property)}) {
+      switch (${formatPropertyAccess("item", normalizeSdkPropertyName(type.discriminatorProperty))}) {
        ${cases.join("\n")}
         default:
           return item;
@@ -281,7 +284,7 @@ function buildDiscriminatedUnionSerializer(
     `);
   }
   output.push(`
-    switch (item.${type.discriminatorProperty ? normalizeName(type.discriminatorProperty.name, NameType.Property) : "unknown"}) {
+    switch (${formatPropertyAccess("item", type.discriminatorProperty ? normalizeSdkPropertyName(type.discriminatorProperty) : "unknown")}) {
      ${cases.join("\n")}
       default:
         return ${baseSerializerName}(item);

package/src/modular/serialization/build-xml-serializer-function.ts

@@ -23,7 +23,7 @@ import { getAdditionalPropertiesName, normalizeModelName } from "../emit-models.
 import { getAllAncestors, getAllProperties } from "../helpers/operation-helpers.js";
 import { getAdditionalPropertiesType } from "../helpers/type-helpers.js";
 import { XmlHelpers } from "../static-helpers-metadata.js";
-import { normalizeModelPropertyName } from "../type-expressions/get-type-expression.js";
+import { getModelPropertyName } from "../type-expressions/get-type-expression.js";
 import { isSupportedSerializeType, type ModelSerializeOptions } from "./serialize-utils.js";
 
 /**
@@ -290,8 +290,8 @@ function buildXmlObjectPropertyAssignments(
     }
 
     const xmlOptions = property.serializationOptions?.xml;
-    const propertyName = normalizeModelPropertyName(context, property);
-    const cleanPropertyName = propertyName.replace(/^"|"$/g, "");
+    const propertyName = getModelPropertyName(context, property);
+    const propertyAccessor = `item[${JSON.stringify(propertyName)}]`;
 
     // Use XML name if available, fall back to serializedName, then JSON name, then property name
     const xmlName = xmlOptions?.name ?? property.name;
@@ -302,14 +302,14 @@ function buildXmlObjectPropertyAssignments(
     let valueExpr: string;
     if (nestedSerializer && property.type.kind === "model") {
       // Nested object - use XML object serializer
-      valueExpr = `item["${cleanPropertyName}"] !== undefined ? ${nestedSerializer}(item["${cleanPropertyName}"]) : undefined`;
+      valueExpr = `${propertyAccessor} !== undefined ? ${nestedSerializer}(${propertyAccessor}) : undefined`;
     } else if (
       nestedSerializer &&
       property.type.kind === "array" &&
       property.type.valueType.kind === "model"
     ) {
       // Array of objects - map each item through XML object serializer
-      const mappedExpr = `item["${cleanPropertyName}"]?.map((i: any) => ${nestedSerializer}(i))`;
+      const mappedExpr = `${propertyAccessor}?.map((i: any) => ${nestedSerializer}(i))`;
       if (xmlOptions?.unwrapped) {
         // Unwrapped: items are direct siblings under the item element name
         const itemKey = xmlOptions?.itemsName ?? xmlName;
@@ -326,7 +326,7 @@ function buildXmlObjectPropertyAssignments(
       const primitiveExpr = buildXmlValueSerializationExpr(
         context,
         property.type,
-        `item["${cleanPropertyName}"]`,
+        propertyAccessor,
       );
       if (xmlOptions?.unwrapped) {
         const itemKey = xmlOptions?.itemsName ?? xmlName;
@@ -339,11 +339,7 @@ function buildXmlObjectPropertyAssignments(
       }
     } else {
       // Handle type-specific serialization
-      valueExpr = buildXmlValueSerializationExpr(
-        context,
-        property.type,
-        `item["${cleanPropertyName}"]`,
-      );
+      valueExpr = buildXmlValueSerializationExpr(context, property.type, propertyAccessor);
     }
 
     assignments.push(`"${xmlName}": ${valueExpr}`);
@@ -419,14 +415,13 @@ function buildPropertyMetadataArray(
 
     const xmlOptions = property.serializationOptions?.xml;
     const jsonOptions = property.serializationOptions?.json;
-    const propertyName = normalizeModelPropertyName(context, property);
-    const cleanPropertyName = propertyName.replace(/^"|"$/g, "");
+    const propertyName = getModelPropertyName(context, property);
 
     // Use XML name if available, fall back to JSON name, then property name
     const serializedName = xmlOptions?.name ?? jsonOptions?.name ?? property.name;
 
     const metadataObj: string[] = [
-      `propertyName: "${cleanPropertyName}"`,
+      `propertyName: ${JSON.stringify(propertyName)}`,
       `xmlOptions: { name: "${serializedName}"${buildXmlOptionsString(xmlOptions)} }`,
     ];
 
@@ -737,14 +732,13 @@ function buildDeserializePropertyMetadataArray(
 
     const xmlOptions = property.serializationOptions?.xml;
     const jsonOptions = property.serializationOptions?.json;
-    const propertyName = normalizeModelPropertyName(context, property);
-    const cleanPropertyName = propertyName.replace(/^"|"$/g, "");
+    const propertyName = getModelPropertyName(context, property);
 
     // Use XML name if available, fall back to JSON name, then property name
     const serializedName = xmlOptions?.name ?? jsonOptions?.name ?? property.name;
 
     const metadataObj: string[] = [
-      `propertyName: "${cleanPropertyName}"`,
+      `propertyName: ${JSON.stringify(propertyName)}`,
       `xmlOptions: { name: "${serializedName}"${buildXmlOptionsString(xmlOptions)} }`,
     ];
 

package/src/modular/type-expressions/get-type-expression.ts

@@ -5,7 +5,7 @@ import type {
   SdkType,
 } from "@azure-tools/typespec-client-generator-core";
 import type { SdkContext } from "../../utils/interfaces.js";
-import { NameType, normalizeName } from "../../utils/name-utils.js";
+import { normalizeSdkPropertyName } from "../../utils/name-utils.js";
 import { getCredentialExpression } from "./get-credential-expression.js";
 import { getEnumExpression } from "./get-enum-expression.js";
 import { getModelExpression } from "./get-model-expression.js";
@@ -21,10 +21,16 @@ export function normalizeModelPropertyName(
   context: SdkContext,
   property: SdkModelPropertyType | SdkHttpParameter | SdkServiceResponseHeader,
 ): string {
-  const normalizedPropName = normalizeName(property.name, NameType.Property);
+  return JSON.stringify(getModelPropertyName(context, property));
+}
+
+export function getModelPropertyName(
+  context: SdkContext,
+  property: SdkModelPropertyType | SdkHttpParameter | SdkServiceResponseHeader,
+): string {
   return context.emitterOptions?.ignorePropertyNameNormalize
-    ? `"${property.name}"`
-    : `"${normalizedPropName}"`;
+    ? property.name
+    : normalizeSdkPropertyName(property);
 }
 
 export function getTypeExpression(

package/src/transform/transform-client-options.ts

@@ -57,6 +57,8 @@ function extractClientOptions(
   const ignoreNullableOnOptional = getIgnoreNullableOnOptional(emitterOptions);
   const wrapNonModelReturn = getWrapNonModelReturn(emitterOptions);
   const isMultiService = (dpgContext.allServiceNamespaces?.length ?? 0) > 1;
+  const experimentalSplitModelsByVisibility =
+    emitterOptions["experimental-split-models-by-visibility"] === true;
 
   return {
     ...credentialInfo,
@@ -85,6 +87,7 @@ function extractClientOptions(
     enableStorageCompat,
     treatUnknownAsRecord,
     generateReactNativeTarget,
+    experimentalSplitModelsByVisibility,
   };
 }
 

package/src/utils/client-utils.ts

@@ -12,11 +12,12 @@ import {
   isTemplateDeclaration,
   isTemplateDeclarationOrInstance,
   type Namespace,
+  NoTarget,
   type Operation,
 } from "@typespec/compiler";
 import type { ClientModuleInfo } from "../modular/interfaces.js";
 import type { SdkContext } from "./interfaces.js";
-import { NameType, normalizeName } from "./name-utils.js";
+import { NameType, normalizeSdkName, reportInvalidExactName } from "./name-utils.js";
 
 export function getClients(dpgContext: SdkContext): SdkClient[] {
   const clients = listClients(dpgContext);
@@ -116,8 +117,9 @@ export function isMultiEndpointClient(dpgContext: SdkContext): boolean {
 
 export function getClientModuleInfo(clientMap: [string[], SdkClientType<SdkServiceOperation>]) {
   const [hierarchy, client] = clientMap;
+  const clientName = client.name.replace(/Client$/, "");
   const clientModuleInfo: ClientModuleInfo = {
-    clientName: `${client.name.replace(/Client$/, "")}Context`,
+    clientName: `${clientName}Context`,
   };
   clientModuleInfo.subfolder = hierarchy.join("/");
   return clientModuleInfo;
@@ -133,13 +135,33 @@ export function getClientHierarchyMap(
   const clients = individualClients.map((client) => {
     return [
       context.sdkPackage.clients.length > 1
-        ? [normalizeName(client.name.replace("Client", ""), NameType.File)]
+        ? [
+            normalizeSdkName(client, NameType.File, {
+              nameOverride: client.name.replace(/Client$/, ""),
+            }),
+          ]
         : [],
       client,
     ];
   }) as [string[], SdkClientType<SdkServiceOperation>][];
   for (let i = 0; i < clients.length; i++) {
     const [hierarchy, client] = clients[i]!;
+    reportInvalidExactName(
+      context.program,
+      client,
+      NameType.Class,
+      "client",
+      client.__raw.type ?? NoTarget,
+    );
+    for (const parameter of client.clientInitialization.parameters) {
+      reportInvalidExactName(
+        context.program,
+        parameter,
+        NameType.Parameter,
+        "parameter",
+        parameter.__raw ?? NoTarget,
+      );
+    }
     clientMap.push([hierarchy, client]);
     const childClientsToGenerate = client.children?.filter((child) => {
       return (
@@ -151,7 +173,9 @@ export function getClientHierarchyMap(
       childClientsToGenerate.forEach((child) => {
         const childHierarchy = [
           ...hierarchy,
-          normalizeName(child.name.replace("Client", ""), NameType.File),
+          normalizeSdkName(child, NameType.File, {
+            nameOverride: child.name.replace(/Client$/, ""),
+          }),
         ];
         clients.push([childHierarchy, child]);
       });

package/src/utils/cross-language-def.ts

@@ -48,8 +48,7 @@ export function generateCrossLanguageDefinitionFile(dpgContext: SdkContext): {
         }
       } else {
         // e,g., @azure/ai-client!ConnectionsOperations#getConnectionWithSecrets:member": "Azure.AI.Projects.Connections.getConnectionWithSecrets"
-        const rawGroupName = normalizeName(prefixes[0] ?? "", NameType.Interface);
-        const propertyType = `${normalizeName(rawGroupName, NameType.OperationGroup)}Operations`;
+        const propertyType = `${normalizeName(prefixes[0] ?? "", NameType.OperationGroup)}Operations`;
         for (const operation of operations) {
           const { name } = operation;
           const operationName = `${packageName}!${propertyType}#${name}:member`;

package/src/utils/interfaces.ts

@@ -8,6 +8,7 @@ export interface SdkContext extends TCGCSdkContext {
   generationPathDetail?: GenerationDirDetail;
   hasApiVersionInClient?: boolean;
   allServiceNamespaces?: Namespace[];
+  commonServiceNamespace?: string[];
 }
 
 export interface GenerationDirDetail {

package/src/utils/name-utils.ts

@@ -1,6 +1,9 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+import { NoTarget, type DiagnosticTarget, type Program } from "@typespec/compiler";
+import { reportDiagnostic } from "../lib.js";
+
 export interface NormalizeNameOption {
   shouldGuard?: boolean;
   customReservedNames?: ReservedName[];
@@ -8,6 +11,15 @@ export interface NormalizeNameOption {
   numberPrefixOverride?: string;
 }
 
+export interface NormalizeSdkNameOption extends NormalizeNameOption {
+  nameOverride?: string;
+}
+
+export interface SdkName {
+  name: string;
+  isExactName?: boolean;
+}
+
 export interface ReservedName {
   name: string;
   reservedFor: NameType[];
@@ -208,6 +220,88 @@ export function normalizeName(
   return fixLeadingNumber(result, nameType, numberPrefixOverride);
 }
 
+export function normalizeSdkName(
+  sdkName: SdkName,
+  nameType: NameType,
+  options: NormalizeSdkNameOption = {},
+): string {
+  const { nameOverride, ...normalizeOptions } = options;
+  const name = nameOverride ?? sdkName.name;
+  if (!sdkName.isExactName) {
+    return normalizeName(name, nameType, normalizeOptions);
+  }
+  return normalizeOptions.shouldGuard && nameType === NameType.Method
+    ? guardReservedNames(name, nameType, normalizeOptions.customReservedNames)
+    : name;
+}
+
+export function normalizeSdkPropertyName(sdkName: SdkName): string {
+  return normalizeSdkName(sdkName, NameType.Property);
+}
+
+export function isValidTypeScriptIdentifierName(name: string): boolean {
+  return /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u.test(name);
+}
+
+const reportedInvalidExactNames = new WeakMap<Program, WeakSet<object>>();
+
+export function reportInvalidExactName(
+  program: Program,
+  item: SdkName & object,
+  nameType: NameType,
+  nameKind: string,
+  target: DiagnosticTarget | typeof NoTarget = NoTarget,
+): void {
+  if (
+    !item.isExactName ||
+    nameType === NameType.Property ||
+    nameType === NameType.EnumMemberName ||
+    nameType === NameType.File
+  ) {
+    return;
+  }
+
+  const requiresMethodGuard = guardReservedNames(item.name, NameType.Method) !== item.name;
+  const isValid =
+    isValidTypeScriptIdentifierName(item.name) &&
+    (nameType === NameType.Method || !requiresMethodGuard);
+  if (isValid) {
+    return;
+  }
+
+  let reported = reportedInvalidExactNames.get(program);
+  if (!reported) {
+    reported = new WeakSet<object>();
+    reportedInvalidExactNames.set(program, reported);
+  }
+  if (reported.has(item)) {
+    return;
+  }
+  reported.add(item);
+
+  reportDiagnostic(program, {
+    code: "invalid-exact-name",
+    format: { nameKind, name: item.name },
+    target,
+  });
+}
+
+export function formatPropertyName(name: string): string {
+  return isValidTypeScriptIdentifierName(name) ? name : JSON.stringify(name);
+}
+
+export function formatPropertyAccess(base: string, name: string): string {
+  return isValidTypeScriptIdentifierName(name)
+    ? `${base}.${name}`
+    : `${base}[${JSON.stringify(name)}]`;
+}
+
+export function formatOptionalPropertyAccess(base: string, name: string): string {
+  return isValidTypeScriptIdentifierName(name)
+    ? `${base}?.${name}`
+    : `${base}?.[${JSON.stringify(name)}]`;
+}
+
 export function fixLeadingNumber(name: string, nameType: NameType, prefix: string = "_"): string {
   const casingConvention = getCasingConvention(nameType);
   if (!name || !name.match(/^[-.]?\d/)) {

package/src/utils/operation-util.ts

@@ -53,7 +53,7 @@ import {
 } from "./media-types.js";
 import { isByteOrByteUnion } from "./model-utils.js";
 import { getLroLogicalResponseName, getResponseTypeName } from "./name-constructors.js";
-import { NameType, normalizeName } from "./name-utils.js";
+import { NameType, normalizeName, normalizeSdkName, reportInvalidExactName } from "./name-utils.js";
 import { getOperationNamespaceInterfaceName } from "./namespace-utils.js";
 
 // Sorts the responses by status code
@@ -645,9 +645,10 @@ export function getMethodHierarchiesMap(
     const operationOrGroup = method[1];
 
     if (operationOrGroup.kind === "client") {
-      operationOrGroup.methods.forEach((m) =>
-        methodQueue.push([[...prefixes, operationOrGroup.name], m]),
-      );
+      const hierarchyName = operationOrGroup.isExactName
+        ? `$DO_NOT_NORMALIZE$${operationOrGroup.name}`
+        : operationOrGroup.name;
+      operationOrGroup.methods.forEach((m) => methodQueue.push([[...prefixes, hierarchyName], m]));
       const nonIndependentChildren = operationOrGroup.children?.filter((child) => {
         return (
           !(child.clientInitialization.initializedBy & InitializedByFlags.Individually) &&
@@ -656,10 +657,26 @@ export function getMethodHierarchiesMap(
       });
       if (nonIndependentChildren && nonIndependentChildren.length > 0) {
         nonIndependentChildren.forEach((child) =>
-          methodQueue.push([[...prefixes, operationOrGroup.name], child]),
+          methodQueue.push([[...prefixes, hierarchyName], child]),
         );
       }
     } else {
+      reportInvalidExactName(
+        context.program,
+        operationOrGroup,
+        NameType.Method,
+        "operation",
+        operationOrGroup.__raw ?? NoTarget,
+      );
+      for (const parameter of operationOrGroup.parameters) {
+        reportInvalidExactName(
+          context.program,
+          parameter,
+          NameType.Parameter,
+          "parameter",
+          parameter.__raw ?? NoTarget,
+        );
+      }
       const prefixKey =
         context.emitterOptions?.hierarchyClient || context.emitterOptions?.enableOperationGroup
           ? prefixes.join("/")
@@ -736,18 +753,14 @@ function resolveParameterNameConflict(
   // subsequent calls (e.g. emitNonModelResponseTypes then buildApiOptions both call
   // getMethodHierarchiesMap on the same TCGC object) always normalize from the
   // original, not from the already-mutated value.
-  const paramName = normalizeName(
-    p.name,
-    NameType.Parameter,
-    true,
-    undefined,
-    undefined,
-    p.oriName,
-  );
+  const paramName = normalizeSdkName(p, NameType.Parameter, {
+    shouldGuard: true,
+    nameOverride: p.oriName ?? p.name,
+  });
   if (!p.oriName) {
     p.oriName = p.name;
   }
-  if (paramName === operationOrGroup.name) {
+  if (!p.isExactName && paramName === operationOrGroup.name) {
     p.name = `${paramName}Parameter`;
   } else {
     p.name = paramName;

package/static/static-helpers/storageCompatResponse.ts

@@ -55,14 +55,15 @@ type StorageCompatResult<TBody, THeaders> = TBody extends undefined | void | nul
  * @param rawResponse - The raw FullOperationResponse from the HTTP pipeline.
  * @param parsedBody - The deserialized response body.
  * @param parsedHeaders - The deserialized response headers.
- * @returns The parsedBody augmented with a `_response` property.
+ * @returns A flattened copy of the body and headers augmented with a `_response` property.
  */
 export function addStorageCompatResponse<TBody, THeaders = Record<string, unknown>>(
   rawResponse: FullOperationResponse,
   parsedBody: TBody,
   parsedHeaders: THeaders,
 ): StorageCompatResult<TBody, THeaders> {
-  const base = parsedBody !== undefined && parsedBody !== null ? parsedBody : ({} as TBody);
+  const base =
+    parsedBody !== undefined && parsedBody !== null ? Object.assign({}, parsedBody) : ({} as TBody);
   return Object.assign(base as any, parsedHeaders, {
     _response: {
       rawResponse,

package/static/static-helpers/urlTemplate.ts

@@ -69,7 +69,8 @@ function getExpandedValue(option: ValueOptions): string {
       // prepare the following parts: separator, varName, value
       vals.push(`${getFirstOrSep(op, isFirst)}`);
       if (named && varName) {
-        vals.push(`${encodeURIComponent(varName)}`);
+        // No need to encode varName considering it is already encoded
+        vals.push(`${varName}`);
         if (val === "") {
           vals.push(ifEmpty);
         } else {
@@ -108,7 +109,8 @@ function getNonExpandedValue(option: ValueOptions): string | undefined {
   const first = getFirstOrSep(op, isFirst);
   const [named, ifEmpty] = getNamedAndIfEmpty(op);
   if (named && varName) {
-    vals.push(encodeComponent(varName, reserved, op));
+    // No need to encode varName considering it is already encoded
+    vals.push(varName);
     if (value === "") {
       if (!ifEmpty) {
         vals.push(ifEmpty);