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

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/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;