fix-function-parameter-name-issue

packages/autorest.typescript/src/transforms/parameterTransforms.ts

@@ -37,6 +37,7 @@ import { PropertyKind } from "../models/modelDetails";
 import { KnownMediaType } from "@azure-tools/codegen";
 import { getAutorestOptions } from "../autorestSession";
 import { DictionaryMapper } from "@azure/core-client";
+import { ReservedModelNames } from "@azure-tools/rlc-common";
 
 interface OperationParameterDetails {
   parameter: Parameter;
@@ -108,7 +109,7 @@ export function transformParameters(
   const { addCredentials } = getSecurityInfoFromModel(codeModel.security);
 
   const hasXmlMetadata = !!options.mediaTypes?.has(KnownMediaType.Xml);
-  extractOperationParameters(codeModel).forEach(p =>
+  extractOperationParameters(codeModel).forEach((p) =>
     populateOperationParameters(
       p.parameter,
       parameters,
@@ -148,33 +149,35 @@ const extractOperationParameters = (codeModel: CodeModel) =>
           }
           const operationParams: OperationParameterDetails[] = (
             operation.parameters || []
-          ).map(p => { 
+          ).map((p) => {
             if (p.required) {
               p.language.default.isTopLevelParameter = true;
             }
             return {
-              parameter: p, 
-              operationName 
-            }  
+              parameter: p,
+              operationName
+            };
           });
 
           // Operations may have multiple requests, each with their own set of parameters.
           // This is known to be the case when an operation can consume multiple media types.
           // We need to ensure that the parameters from each request (method overload) is accounted for.
           const requestParams: OperationParameterDetails[] = [];
-          requests.map(request => {
-            request.parameters?.map(parameter => {
+          requests.map((request) => {
+            request.parameters?.map((parameter) => {
+              if (parameter.required) {
+                if ((parameter as any)["targetProperty"] !== undefined) {
+                  (parameter as any)[
+                    "targetProperty"
+                  ].language.default.isTopLevelParameter = true;
+                }
+                parameter.language.default.isTopLevelParameter = true;
+              }
               requestParams.push({
                 operationName,
                 parameter,
                 targetMediaType: request.protocol.http?.knownMediaType
               });
-              if (parameter.required) {
-                if ((parameter as any)['targetProperty'] !== undefined) {
-                  (parameter as any)['targetProperty'].language.default.isTopLevelParameter = true;
-                }
-                parameter.language.default.isTopLevelParameter = true;
-              }
               return parameter;
             });
             return request;
@@ -250,11 +253,11 @@ export function populateOperationParameters(
   const name = normalizeName(
     parameterName,
     NameType.Parameter,
-    parameter.language.default.isTopLevelParameter /** shouldGuard */
+    true /** shouldGuard */
   );
 
   const sameNameParams = operationParameters.filter(
-    p => p.name === name || p.nameRef === name
+    (p) => p.name === name || p.nameRef === name
   );
   description += getSchemaTypeDocumentation(parameter.schema);
   const isRequired = getParameterRequired(parameter);
@@ -348,12 +351,13 @@ function getParameterPath(parameter: Parameter) {
   const name = normalizeName(
     metadata.name,
     NameType.Parameter,
-    parameter.language.default.isTopLevelParameter ? true: false /** shouldGuard */
+    true /** shouldGuard */
   );
 
   if (parameter.groupedBy) {
-    const groupedByName = getLanguageMetadata(parameter.groupedBy.language)
-      .name;
+    const groupedByName = getLanguageMetadata(
+      parameter.groupedBy.language
+    ).name;
     return [
       ...(!parameter.required && !parameter.groupedBy.required
         ? ["options"]
@@ -409,7 +413,7 @@ function getCollectionFormat(parameter: Parameter): string | undefined {
 
   const getStyle = (value: QueryCollectionFormat) =>
     Object.keys(QueryCollectionFormat).find(
-      key => (QueryCollectionFormat as any)[key] === value
+      (key) => (QueryCollectionFormat as any)[key] === value
     );
 
   let queryCollectionFormat: QueryCollectionFormat;
@@ -512,7 +516,7 @@ export function disambiguateParameter(
   description: string
 ) {
   const param = getComparableParameter(parameter);
-  const existingParam = sameNameParams.find(p =>
+  const existingParam = sameNameParams.find((p) =>
     isEqual(getComparableParameter(p), param)
   );
 

packages/autorest.typescript/test/integration/generated/azureParameterGrouping/src/models/parameters.ts

@@ -120,11 +120,11 @@ export const query1: OperationQueryParameter = {
   },
 };
 
-export const from: OperationQueryParameter = {
+export const fromParam: OperationQueryParameter = {
   parameterPath: [
     "options",
     "parameterGroupingPostReservedWordsParameters",
-    "from",
+    "fromParam",
   ],
   mapper: {
     serializedName: "from",

packages/autorest.typescript/test/integration/generated/azureParameterGrouping/src/operations/parameterGrouping.ts

@@ -159,7 +159,7 @@ const postReservedWordsOperationSpec: coreClient.OperationSpec = {
       bodyMapper: Mappers.ErrorModel,
     },
   },
-  queryParameters: [Parameters.from, Parameters.accept1],
+  queryParameters: [Parameters.fromParam, Parameters.accept1],
   urlParameters: [Parameters.$host],
   headerParameters: [Parameters.accept],
   serializer,

packages/autorest.typescript/test/unit/transforms/parameterTransforms.spec.ts

@@ -422,7 +422,7 @@ describe("parameterTransforms", () => {
       assert.equal(p1.parameter, param1);
     });
 
-    it("should not guard non-required query parameters name", () => {
+    it("should guard non-required query parameters name", () => {
       const codeModel = new CodeModel("testCodeModel");
       const param1 = new Parameter(
         "type",
@@ -467,11 +467,11 @@ describe("parameterTransforms", () => {
       assert.equal(parameters.length, 2);
       assert.deepEqual(
         parameters.map(p => p.nameRef),
-        ["type", "endpoint"]
+        ["typeParam", "endpoint"]
       );
 
       const p1: ParameterDetails = parameters.find(
-        p => p.nameRef === "type"
+        p => p.nameRef === "typeParam"
       )!;
 
       assert.deepEqual(p1.operationsIn, {