@azure-tools/typespec-ts 0.57.0-dev.6 → 0.57.0-dev.8

package/src/modular/helpers/example-value-helpers.ts

@@ -15,7 +15,16 @@ import { resolveReference } from "../../framework/reference.js";
 import { getSubscriptionId } from "../../transform/transform-client-options.js";
 import { hasKeyCredential, hasTokenCredential } from "../../utils/credential-utils.js";
 import type { SdkContext } from "../../utils/interfaces.js";
-import { NameType, normalizeName } from "../../utils/name-utils.js";
+import {
+  formatOptionalPropertyAccess,
+  formatPropertyAccess,
+  formatPropertyName,
+  NameType,
+  normalizeName,
+  normalizeSdkName,
+  normalizeSdkPropertyName,
+  type SdkName,
+} from "../../utils/name-utils.js";
 import { getMethodHierarchiesMap, type ServiceOperation } from "../../utils/operation-util.js";
 import { AzureIdentityDependencies, AzureTestDependencies } from "../external-dependencies.js";
 import { getClientParametersDeclaration } from "./client-helpers.js";
@@ -56,13 +65,14 @@ export function buildParameterValueMap(
  * Prepare a common value for tests
  */
 export function prepareCommonValue(
-  name: string,
+  name: string | SdkName,
   value: SdkExampleValue | string,
   isOptional?: boolean,
   onClient?: boolean,
 ): CommonValue {
+  const sdkName = typeof name === "string" ? { name } : name;
   return {
-    name: normalizeName(name, NameType.Parameter),
+    name: normalizeSdkName(sdkName, NameType.Parameter),
     value: typeof value === "string" ? value : serializeExampleValue(value),
     isOptional: Boolean(isOptional),
     onClient: Boolean(onClient),
@@ -187,7 +197,10 @@ export function serializeExampleValue(value: SdkExampleValue): string {
       }) {
         let property;
         if (value.type.kind === "model") {
-          property = value.type.properties.find((p) => p.name === propName);
+          property =
+            value.type.properties.find(
+              (p) => (p.serializationOptions.json?.name ?? p.name) === propName,
+            ) ?? value.type.properties.find((p) => p.name === propName);
         }
         const propValue = value.value[propName];
         if (propValue === undefined || propValue === null) {
@@ -205,19 +218,23 @@ export function serializeExampleValue(value: SdkExampleValue): string {
             if (innerPropValue === undefined || innerPropValue === null) {
               continue;
             }
-            const innerProperty = property.type.properties.find((p) => p.name === innerPropName);
+            const innerProperty =
+              property.type.properties.find(
+                (p) => (p.serializationOptions.json?.name ?? p.name) === innerPropName,
+              ) ?? property.type.properties.find((p) => p.name === innerPropName);
             if (innerProperty && isReadOnly(innerProperty as SdkModelPropertyType)) {
               continue;
             }
             values.push(
-              `"${innerMapper.get(innerPropName) ?? innerPropName}": ` +
+              `${JSON.stringify(innerMapper.get(innerPropName) ?? innerPropName)}: ` +
                 serializeExampleValue(innerPropValue),
             );
           }
           continue;
         }
         const propRetValue =
-          `"${mapper.get(propName) ?? propName}": ` + serializeExampleValue(propValue);
+          `${JSON.stringify(mapper.get(propName) ?? propName)}: ` +
+          serializeExampleValue(propValue);
         values.push(propRetValue);
       }
       const additionalBags = [];
@@ -229,14 +246,15 @@ export function serializeExampleValue(value: SdkExampleValue): string {
           continue;
         }
         const propRetValue =
-          `"${mapper.get(propName) ?? propName}": ` + serializeExampleValue(propValue);
+          `${JSON.stringify(mapper.get(propName) ?? propName)}: ` +
+          serializeExampleValue(propValue);
         additionalBags.push(propRetValue);
       }
       if (additionalBags.length > 0) {
         const name = mapper.get("additionalProperties")
           ? "additionalPropertiesBag"
           : "additionalProperties";
-        values.push(`"${name}": {
+        values.push(`${JSON.stringify(name)}: {
           ${additionalBags.join(", ")}
           }`);
       }
@@ -268,10 +286,7 @@ function buildTestPropertyNameMapper(type: SdkExampleValue["type"]) {
     if (prop.kind !== "property") {
       continue;
     }
-    mapper.set(
-      prop.serializationOptions.json?.name || prop.name,
-      normalizeName(prop.name, NameType.Property),
-    );
+    mapper.set(prop.serializationOptions.json?.name || prop.name, normalizeSdkPropertyName(prop));
   }
   return mapper;
 }
@@ -368,16 +383,14 @@ export function prepareCommonParameters(
     if (!exampleValue || !exampleValue.value) {
       if (!param.optional) {
         // Generate default values for required parameters without examples in tests
-        result.push(
-          prepareCommonValue(param.name, `"{Your ${param.name}}"`, false, param.onClient),
-        );
+        result.push(prepareCommonValue(param, `"{Your ${param.name}}"`, false, param.onClient));
       }
       continue;
     }
 
     result.push(
       prepareCommonValue(
-        exampleValue.parameter.name,
+        exampleValue.parameter,
         exampleValue.value,
         param.optional,
         param.onClient,
@@ -401,7 +414,8 @@ export function prepareCommonParameters(
       bodyExample.value.kind === "model"
     ) {
       for (const prop of bodyParam.type.properties) {
-        const propExample = bodyExample.value.value[prop.name];
+        const wireName = prop.serializationOptions.json?.name ?? prop.name;
+        const propExample = bodyExample.value.value[wireName] ?? bodyExample.value.value[prop.name];
         if (!propExample) {
           continue;
         }
@@ -409,7 +423,7 @@ export function prepareCommonParameters(
         if (isReadOnly(prop as SdkModelPropertyType)) {
           continue;
         }
-        result.push(prepareCommonValue(prop.name, propExample, prop.optional, prop.onClient));
+        result.push(prepareCommonValue(prop, propExample, prop.optional, prop.onClient));
       }
     } else {
       // Check if the body parameter is nested inside a wrapper (e.g., @bodyRoot)
@@ -419,30 +433,19 @@ export function prepareCommonParameters(
       if (isNestedBody) {
         const path = segments[0]!;
         // The first segment is the method-level wrapper param (e.g., "body")
-        const methodParamName = path[0]!.name;
         const methodParamOptional = path[0]!.optional;
         // Wrap the example value with the intermediate property names
         let wrappedValue = serializeExampleValue(bodyExample.value);
         for (let i = path.length - 1; i >= 1; i--) {
-          const propName = normalizeName(path[i]!.name, NameType.Property);
+          const propName = formatPropertyName(normalizeSdkPropertyName(path[i]!));
           wrappedValue = `{ ${propName}: ${wrappedValue} }`;
         }
         result.push(
-          prepareCommonValue(
-            methodParamName,
-            wrappedValue,
-            methodParamOptional,
-            bodyParam.onClient,
-          ),
+          prepareCommonValue(path[0]!, wrappedValue, methodParamOptional, bodyParam.onClient),
         );
       } else {
         result.push(
-          prepareCommonValue(
-            bodyParam.name,
-            bodyExample.value,
-            bodyParam.optional,
-            bodyParam.onClient,
-          ),
+          prepareCommonValue(bodyParam, bodyExample.value, bodyParam.optional, bodyParam.onClient),
         );
       }
     }
@@ -457,7 +460,7 @@ export function prepareCommonParameters(
     .forEach((param) => {
       const exampleValue = parameterMap[param.serializedName];
       if (exampleValue && exampleValue.value) {
-        result.push(prepareCommonValue(param.name, exampleValue.value, true, param.onClient));
+        result.push(prepareCommonValue(param, exampleValue.value, true, param.onClient));
       }
     });
 
@@ -492,10 +495,7 @@ export function iterateClientsAndMethods(
           client,
           generatedFiles,
           classicalMethodPrefix: prefix,
-          subFolder:
-            clients.length > 1
-              ? normalizeName(getClassicalClientName(client), NameType.File)
-              : undefined,
+          subFolder: clients.length > 1 ? normalizeSdkName(client, NameType.File) : undefined,
           hierarchies: hierarchies,
         });
       }
@@ -564,7 +564,9 @@ export function generateMethodCall(
   }
 
   const prefix = options.classicalMethodPrefix ? `${options.classicalMethodPrefix}.` : "";
-  const methodCall = `client.${prefix}${normalizeName(method.oriName ?? method.name, NameType.Property)}(${methodParams.join(", ")})`;
+  const methodCall = `client.${prefix}${normalizeSdkName(method, NameType.Property, {
+    nameOverride: method.oriName ?? method.name,
+  })}(${methodParams.join(", ")})`;
 
   return { methodCall, clientParams, clientParamDefs };
 }
@@ -681,7 +683,11 @@ export function generateAssertionsForValue(
             // Check if this property is flattened in the model type
             let property;
             if (value.kind === "model" && value.type.kind === "model") {
-              property = value.type.properties.find((p) => p.kind === "property" && p.name === key);
+              property =
+                value.type.properties.find(
+                  (p) =>
+                    p.kind === "property" && (p.serializationOptions.json?.name ?? p.name) === key,
+                ) ?? value.type.properties.find((p) => p.kind === "property" && p.name === key);
             }
             if (property?.flatten && (val as SdkExampleValue).kind === "model") {
               // For flattened properties, recurse using the parent path so
@@ -694,7 +700,12 @@ export function generateAssertionsForValue(
               );
               assertions.push(...innerAssertions);
             } else {
-              const propPath = `${path}.${key}`;
+              const propertyName = property ? normalizeSdkPropertyName(property) : key;
+              const optionalBase = path.endsWith("?");
+              const basePath = optionalBase ? path.slice(0, -1) : path;
+              const propPath = optionalBase
+                ? formatOptionalPropertyAccess(basePath, propertyName)
+                : formatPropertyAccess(basePath, propertyName);
               const nestedVal = val as SdkExampleValue;
               // For nested model/dict values, append "?" to the path so child
               // property accesses use optional chaining (e.g. result.systemData?.createdBy)

package/src/modular/helpers/naming-helpers.ts

@@ -5,7 +5,12 @@ import {
 } from "@azure-tools/typespec-client-generator-core";
 import pluralize from "pluralize";
 import type { SdkContext } from "../../utils/interfaces.js";
-import { NameType, normalizeName, ReservedModelNames } from "../../utils/name-utils.js";
+import {
+  NameType,
+  normalizeName,
+  normalizeSdkName,
+  ReservedModelNames,
+} from "../../utils/name-utils.js";
 import type { ServiceOperation } from "../../utils/operation-util.js";
 
 export function getClientName(client: SdkClientType<SdkServiceOperation>): string {
@@ -29,8 +34,8 @@ export function getOperationName(
   dpgContext?: SdkContext,
   prefixes: string[] = [],
 ): GuardedName {
-  const name = normalizeName(operation.name, NameType.Method, true);
-  const propertyName = normalizeName(operation.name, NameType.Property);
+  const name = normalizeSdkName(operation, NameType.Method, { shouldGuard: true });
+  const propertyName = normalizeSdkName(operation, NameType.Property);
   const isDataplane = dpgContext !== undefined && !dpgContext.emitterOptions?.azureArm;
   // An explicit `@clientName` override is an intentional naming choice by the user, so we
   // honor it verbatim and skip the reserved-word disambiguation (and its `@fixme`). The

package/src/modular/helpers/operation-helpers.ts

@@ -35,7 +35,13 @@ 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 {
+  formatOptionalPropertyAccess,
+  formatPropertyAccess,
+  NameType,
+  normalizeSdkName,
+  normalizeSdkPropertyName,
+} from "../../utils/name-utils.js";
 import {
   getCollectionFormatFromArrayEncoding,
   getCollectionFormatHelper,
@@ -1400,7 +1406,7 @@ export function getOperationOptionsName(
     includeGroupName && operation.name.indexOf("_") === -1
       ? getClassicalLayerPrefix(prefixes, NameType.Interface)
       : "";
-  const optionName = `${prefix}${normalizeName(operation.name, NameType.Interface)}OptionalParams`;
+  const optionName = `${prefix}${normalizeSdkName(operation, NameType.Interface)}OptionalParams`;
   return optionName;
 }
 
@@ -1690,17 +1696,19 @@ function isContentType(param: SdkHttpParameter): boolean {
 
 function getContentTypeValue(param: SdkHttpParameter, optionalParamName: string = "options") {
   const defaultValue = param.clientDefaultValue;
+  const optionAccessor = formatPropertyAccess(
+    optionalParamName,
+    normalizeSdkName(param, NameType.Parameter),
+  );
   // allow customers to customize the content type if it's guessed by tcgc.
   if (isConstant(param.type)) {
     return `contentType: ${getConstantValue(param.type)}`;
   }
   if (defaultValue) {
-    return `contentType: ${optionalParamName}.${param.name} as any ?? "${defaultValue}"`;
+    return `contentType: ${optionAccessor} as any ?? "${defaultValue}"`;
   } else {
     return `contentType: ${
-      !param.optional
-        ? normalizeName(param.name, NameType.Property)
-        : `${optionalParamName}.` + param.name + " as any"
+      !param.optional ? normalizeSdkName(param, NameType.Property) : `${optionAccessor} as any`
     }`;
   }
 }
@@ -1919,10 +1927,11 @@ function getParamAccessor(param: SdkHttpParameter, optionalParamName: string = "
   if (param.onClient) {
     return `${clientPrefix}${getClientParameterName(param)}`;
   }
+  const parameterName = normalizeSdkName(param, NameType.Parameter, { shouldGuard: true });
   if (getEffectiveOptional(param)) {
-    return `${optionalParamName}?.${param.name}`;
+    return formatOptionalPropertyAccess(optionalParamName, parameterName);
   }
-  return param.name;
+  return parameterName;
 }
 
 /**
@@ -1948,25 +1957,29 @@ function getMethodParamExpr(
     return undefined;
   }
 
-  const parts: string[] = [];
+  let expression = "";
   for (let i = 0; i < path.length; i++) {
     const segment = path[i]!;
     if (i === 0) {
       // Normalize names for client-level segments to match the context interface property names
       const segmentName = segment.onClient
         ? getClientParameterName(segment as SdkMethodParameter)
-        : segment.name;
+        : normalizeSdkName(segment, NameType.Parameter, { shouldGuard: true });
       if (segment.optional && !segment.onClient) {
         // If the first segment is optional and not on the client, we need to start with the optionalParamName
-        parts.push(`${optionalParamName}?.`);
+        expression = formatOptionalPropertyAccess(optionalParamName, segmentName);
+      } else {
+        expression = segmentName;
       }
-      parts.push(segmentName);
     } else {
       const needsOptionalChain = path[i - 1]!.optional;
-      parts.push(`${needsOptionalChain ? "?." : "."}${segment.name}`);
+      const segmentName = normalizeSdkPropertyName(segment);
+      expression = needsOptionalChain
+        ? formatOptionalPropertyAccess(expression, segmentName)
+        : formatPropertyAccess(expression, segmentName);
     }
   }
-  return parts.join("");
+  return expression;
 }
 
 function getPathParamExpr(
@@ -2692,14 +2705,14 @@ export function getPropertyFullName(
 ) {
   const normalizedPropertyName =
     propertyPath === ""
-      ? normalizeName(property.name, NameType.Parameter, true)
-      : normalizeModelPropertyName(context, property).replace(/^"/g, "").replace(/"$/g, "");
+      ? normalizeSdkName(property, NameType.Parameter, { shouldGuard: true })
+      : normalizeModelPropertyName(context, property);
 
   let fullName = normalizedPropertyName;
   if (propertyPath === "" && property.optional) {
     fullName = `options?.${normalizedPropertyName}`;
   } else if (propertyPath) {
-    fullName = `${propertyPath}["${normalizedPropertyName}"]`;
+    fullName = `${propertyPath}[${normalizedPropertyName}]`;
   }
 
   return fullName;
@@ -2896,7 +2909,7 @@ export function getOperationResponseTypeName(method: [string[], ServiceOperation
   const prefix = !operation.name.includes("_")
     ? getClassicalLayerPrefix(prefixes, NameType.Interface)
     : "";
-  return `${prefix}${normalizeName(operation.name, NameType.Interface)}Response`;
+  return `${prefix}${normalizeSdkName(operation, NameType.Interface)}Response`;
 }
 
 /**

package/src/modular/helpers/type-helpers.ts

@@ -7,7 +7,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 {
   getPropertyWithOverrides,
   type ModelOverrideOptions,
@@ -110,10 +110,7 @@ export function buildPropertyNameMapper(
       continue;
     }
     const prop = getPropertyWithOverrides(p, overrides);
-    mapper.set(
-      prop.serializationOptions.json?.name || prop.name,
-      normalizeName(prop.name, NameType.Property),
-    );
+    mapper.set(prop.serializationOptions.json?.name || prop.name, normalizeSdkPropertyName(prop));
   }
   return mapper;
 }

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

@@ -184,7 +184,6 @@ function buildPolymorphicDeserializer(
     ) {
       return;
     }
-    const union = subType?.discriminatedSubtypes ? "_Union" : "";
     if (!subType || !subType?.name) {
       reportDiagnostic(context.program, {
         code: "anonymous-type-deserialization",
@@ -192,14 +191,12 @@ function buildPolymorphicDeserializer(
       });
       return; // Skip this subtype
     }
-
-    const rawSubTypeName = `${subType.name}${union}`;
-    const subTypeName = `${normalizeName(rawSubTypeName, NameType.Interface, true)}`;
-    const subtypeDeserializerName = normalizeName(
-      `${subTypeName}Deserializer`,
-      NameType.Operation,
-      true,
-    );
+    const union = subType.discriminatedSubtypes ? "Union" : "";
+    const subTypeName = normalizeModelName(context, subType, NameType.Interface, !union);
+    const subtypeDeserializerName = buildModelDeserializer(context, subType, {
+      nameOnly: true,
+      skipDiscriminatedUnionSuffix: false,
+    }) as string;
 
     cases.push(`
         case "${discriminatedValue}":

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(