[v6] Naming fixes (#625)

* Add reserved words and make operationFullName consistent

* Address pr comments

* Update naming utils and remove unecessary serializedNames

src/generators/clientFileGenerator.ts

@@ -175,7 +175,11 @@ function getOperationGroupsDeclarationDetails(
   return operationGroups.map(og => {
     return {
       name: normalizeName(og.name, NameType.Property),
-      typeName: `operations.${normalizeName(og.name, NameType.Class)}`
+      typeName: `operations.${normalizeName(
+        og.name,
+        NameType.OperationGroup,
+        true /* shouldGuard */
+      )}`
     };
   });
 }

src/generators/operationGenerator.ts

@@ -326,7 +326,11 @@ function addClass(
   clientDetails: ClientDetails
 ) {
   let importedModels = new Set<string>();
-  const className = normalizeName(operationGroupDetails.name, NameType.Class);
+  const className = normalizeName(
+    operationGroupDetails.name,
+    NameType.OperationGroup,
+    true /** shouldGuard */
+  );
   const operationGroupClass = operationGroupFile.addClass({
     name: className,
     docs: [`Class representing a ${className}.`],

src/transforms/mapperTransforms.ts

@@ -125,7 +125,8 @@ export function transformMapper({ schema, options }: MapperInput) {
 export function getMapperClassName(schema: Schema): string {
   return normalizeName(
     getLanguageMetadata(schema.language).name,
-    NameType.Class
+    NameType.Class,
+    true /** shouldGuard */
   );
 }
 
@@ -153,7 +154,8 @@ function buildMapper(
   const serializedName =
     getDiscriminatorValue(schema) ||
     options.serializedName ||
-    getLanguageMetadata(schema.language).name;
+    // Fallback to name only for XML schemas since they need a name, otherwise don't
+    (options.hasXmlMetadata && getLanguageMetadata(schema.language).name);
 
   const arraySchema = schema as ArraySchema;
   arraySchema.elementType;
@@ -528,8 +530,7 @@ function transformConstantMapper(pipelineValue: PipelineValue): PipelineValue {
   }
   const serializedName =
     (options && options.serializedName) ||
-    getLanguageMetadata(schema.language).serializedName ||
-    getLanguageMetadata(schema.language).name;
+    getLanguageMetadata(schema.language).serializedName;
 
   const constantSchema = schema as ConstantSchema;
 
@@ -607,7 +608,11 @@ function processProperties(
   properties.forEach(prop => {
     const serializedName = getPropertySerializedName(prop);
     const propName = getLanguageMetadata(prop.language).name;
-    const name = normalizeName(propName, NameType.Property);
+    const name = normalizeName(
+      propName,
+      NameType.Property,
+      true /** shouldGuard */
+    );
     modelProperties[name] = getMapperOrRef(prop.schema, prop.serializedName, {
       ...options,
       required: prop.required,

src/transforms/objectTransforms.ts

@@ -40,7 +40,11 @@ export function transformObject(
   uberParents: ObjectDetails[]
 ): ObjectDetails {
   const metadata = getLanguageMetadata(schema.language);
-  let name = normalizeName(metadata.name, NameType.Class);
+  let name = normalizeName(
+    metadata.name,
+    NameType.Class,
+    true /** shouldGuard */
+  );
   const kind = getObjectKind(schema);
 
   let objectDetails: ObjectDetails = {
@@ -72,7 +76,11 @@ export function transformProperty({
   const { typeName, isConstant, defaultValue } = typeDetails;
 
   return {
-    name: normalizeName(metadata.name, NameType.Property),
+    name: normalizeName(
+      metadata.name,
+      NameType.Property,
+      true /** shouldGuard */
+    ),
     description: !metadata.description.startsWith("MISSING")
       ? metadata.description
       : undefined,
@@ -144,7 +152,8 @@ function extractHierarchy(
     .map(r => {
       const relativeName = normalizeName(
         getLanguageMetadata(r.language).name,
-        NameType.Interface
+        NameType.Interface,
+        true /** shouldGuard */
       );
       const relative = objectsDetails.find(o => o.name === relativeName);
 
@@ -188,7 +197,11 @@ function transformComposedObject(
 
   const parentNames = schema.parents.immediate.map(parent => {
     const name = getLanguageMetadata(parent.language).name;
-    return `${normalizeName(name, NameType.Interface)}`;
+    return `${normalizeName(
+      name,
+      NameType.Interface,
+      true /** shouldGuard */
+    )}`;
   });
 
   return {
@@ -209,7 +222,8 @@ function transformPolymorphicObject(
       // TODO: Reconsider names to reduce issues with normalization, can we switch to serialized?
       const name = normalizeName(
         getLanguageMetadata(p.language).name,
-        NameType.Interface
+        NameType.Interface,
+        true /** shouldGuard */
       );
       return uberParents.some(up => up.name === name);
     });

src/transforms/operationTransforms.ts

@@ -15,7 +15,11 @@ import {
   ConstantSchema,
   CodeModel
 } from "@azure-tools/codemodel";
-import { normalizeName, NameType } from "../utils/nameUtils";
+import {
+  normalizeName,
+  NameType,
+  getOperationFullName
+} from "../utils/nameUtils";
 import {
   OperationGroupDetails,
   OperationDetails,
@@ -86,7 +90,11 @@ export function transformOperationSpec(
   operationDetails: OperationDetails,
   parameters: ParameterDetails[]
 ): OperationSpecDetails[] {
-  const operationName = normalizeName(operationDetails.name, NameType.Property);
+  const operationName = normalizeName(
+    operationDetails.name,
+    NameType.Operation,
+    true /** shouldGuard */
+  );
   // Extract protocol information
   const operationFullName = operationDetails.fullName;
 
@@ -190,7 +198,11 @@ export function getSpecType(responseSchema: Schema, expand = false): SpecType {
       break;
     case SchemaType.Object:
       const name = getLanguageMetadata(responseSchema.language).name;
-      reference = `Mappers.${normalizeName(name, NameType.Class)}`;
+      reference = `Mappers.${normalizeName(
+        name,
+        NameType.Class,
+        true /** shouldGuard */
+      )}`;
       break;
     default:
       typeName = getMapperTypeFromSchema(responseSchema.type);
@@ -290,20 +302,33 @@ export function transformOperationResponse(
 
 export async function transformOperation(
   operation: Operation,
-  operationGroupName: string
+  operationGroup: OperationGroup,
+  clientName: string
 ): Promise<OperationDetails> {
   const metadata = getLanguageMetadata(operation.language);
   const pagination = extractPaginationDetails(operation);
-  const name = normalizeName(metadata.name, NameType.Property);
-  const operationFullName = `${operationGroupName}_${name}`;
+  const name = normalizeName(
+    metadata.name,
+    NameType.Operation,
+    true /** shouldGuard */
+  );
+  const operationFullName = getOperationFullName(
+    operationGroup,
+    operation,
+    clientName
+  );
   const responsesAndErrors = [
     ...(operation.responses || []),
     ...(operation.exceptions || [])
   ];
   const typeName = `${normalizeName(
-    operationGroupName,
+    getOperationGroupName(operationGroup, clientName),
     NameType.Interface
-  )}${normalizeName(metadata.name, NameType.Interface)}`;
+  )}${normalizeName(
+    metadata.name,
+    NameType.Interface,
+    true /** shouldGuard */
+  )}`;
 
   const typeDetails: TypeDetails = {
     typeName,
@@ -347,7 +372,7 @@ export async function transformOperation(
   return {
     name,
     typeDetails,
-    fullName: operationFullName.toLowerCase(),
+    fullName: operationFullName,
     apiVersions: operation.apiVersions
       ? operation.apiVersions.map(v => v.version)
       : [],
@@ -372,23 +397,35 @@ export function transformOperationGroups(
   );
 }
 
+function getOperationGroupName(
+  operationGroup: OperationGroup,
+  clientName: string = ""
+) {
+  const { name } = getLanguageMetadata(operationGroup.language);
+
+  return normalizeName(name || clientName, NameType.OperationGroup);
+}
+
 export async function transformOperationGroup(
   operationGroup: OperationGroup,
   clientName: string
 ): Promise<OperationGroupDetails> {
   const metadata = getLanguageMetadata(operationGroup.language);
   const isTopLevel = !metadata.name;
-  const name = normalizeName(metadata.name || clientName, NameType.Property);
+  const operationGroupClassName = getOperationGroupName(
+    operationGroup,
+    clientName
+  );
 
   const operations = await Promise.all(
     operationGroup.operations.map(operation =>
-      transformOperation(operation, name)
+      transformOperation(operation, operationGroup, clientName)
     )
   );
   const mediaTypes = getOperationGroupMediaTypes(operations);
 
   return {
-    name,
+    name: operationGroupClassName,
     key: operationGroup.$key,
     operations,
     isTopLevel,

src/transforms/parameterTransforms.ts

@@ -13,7 +13,11 @@ import {
 } from "@azure-tools/codemodel";
 import { QueryCollectionFormat } from "@azure/core-http";
 import { getLanguageMetadata } from "../utils/languageHelpers";
-import { normalizeName, NameType } from "../utils/nameUtils";
+import {
+  normalizeName,
+  NameType,
+  getOperationFullName
+} from "../utils/nameUtils";
 import { ParameterDetails } from "../models/parameterDetails";
 import {
   isSchemaType,
@@ -111,13 +115,11 @@ export function transformParameters(
 const extractOperationParameters = (codeModel: CodeModel) =>
   codeModel.operationGroups.reduce<OperationParameterDetails[]>((acc, og) => {
     const clientName = getLanguageMetadata(codeModel.language).name;
-    const groupName = getLanguageMetadata(og.language).name || clientName;
     return [
       ...acc,
       ...og.operations.reduce<OperationParameterDetails[]>(
         (operations, operation) => {
-          const opName = getLanguageMetadata(operation.language).name;
-          const operationName = `${groupName}_${opName}`.toLowerCase();
+          const operationName = getOperationFullName(og, operation, clientName);
 
           // Look for request in old 'request' property if new 'requests' doesn't exist
           const requests = operation.requests;
@@ -200,7 +202,11 @@ export function populateOperationParameters(
     return;
   }
 
-  const name = normalizeName(parameterName, NameType.Property);
+  const name = normalizeName(
+    parameterName,
+    NameType.Parameter,
+    true /** shouldGuard */
+  );
   const serializedName =
     getLanguageMetadata(parameter.language).serializedName || name;
   const sameNameParams = operationParameters.filter(p => p.name === name);
@@ -275,12 +281,19 @@ function getIsGlobal(parameter: Parameter) {
 function getParameterPath(parameter: Parameter) {
   const metadata = getLanguageMetadata(parameter.language);
   // ParameterPath has to include the name we used for the parameter, not the serializedName
-  const name = normalizeName(metadata.name, NameType.Property);
+  const name = normalizeName(
+    metadata.name,
+    NameType.Parameter,
+    true /** shouldGuard */
+  );
 
   if (parameter.groupedBy) {
     const groupedByName = getLanguageMetadata(parameter.groupedBy.language)
       .name;
-    return [normalizeName(groupedByName, NameType.Property), name];
+    return [
+      normalizeName(groupedByName, NameType.Parameter, true /** shouldGuard */),
+      name
+    ];
   }
 
   return isClientImplementation(parameter) || parameter.required
@@ -383,7 +396,11 @@ export function disambiguateParameter(
     return;
   } else {
     // Since there is already a parameter with the same name, we need to ad a sufix
-    const name = normalizeName(serializedName, NameType.Property);
+    const name = normalizeName(
+      serializedName,
+      NameType.Parameter,
+      true /** shouldGuard */
+    );
     const nameRef = `${name}${sameNameParams.length}`;
     const collectionFormat = getCollectionFormat(parameter);
     let description =

src/transforms/transforms.ts

@@ -41,7 +41,7 @@ export function transformChoice(
   choice: ChoiceSchema | SealedChoiceSchema
 ): UnionDetails {
   const metadata = getLanguageMetadata(choice.language);
-  let name = guardReservedNames(metadata.name);
+  let name = normalizeName(metadata.name, NameType.Interface);
 
   return {
     name,
@@ -57,7 +57,11 @@ export async function transformCodeModel(
   codeModel: CodeModel,
   host: Host
 ): Promise<ClientDetails> {
-  const className = normalizeName(codeModel.info.title, NameType.Class);
+  const className = normalizeName(
+    codeModel.info.title,
+    NameType.Class,
+    true /** shouldGuard */
+  );
   normalizeModelWithExtensions(codeModel);
 
   const [uberParents, operationGroups] = await Promise.all([