Implemented reserved parameter and alias auto-resolution.

Author: ashishdhingra

generator/AWSPSGeneratorLib/Analysis/OperationAnalyzer.cs

@@ -96,7 +96,13 @@ public HashSet<string> GetAllParameterAliases(SimplePropertyInfo property)
                 var globalAliases = CurrentModel.CustomParameters[property.AnalyzedName].Aliases;
                 foreach (var a in globalAliases)
                 {
-                    aliases.Add(a);
+                    var aliasToUse = ResolveAliasWithReservedParameterName(a);
+
+                    // If new alias is not equivalent to CmdLet parameter name that would be used, then add it to aliases list.
+                    if (aliasToUse != property.CmdletParameterName)
+                    {
+                        aliases.Add(aliasToUse);
+                    }
                 }
             }
 
@@ -109,7 +115,13 @@ public HashSet<string> GetAllParameterAliases(SimplePropertyInfo property)
                 var propAliases = property.Customization.Aliases;
                 foreach (var a in propAliases)
                 {
-                    aliases.Add(a);
+                    var aliasToUse = ResolveAliasWithReservedParameterName(a);
+
+                    // If new alias is not equivalent to CmdLet parameter name that would be used, then add it to aliases list.
+                    if (aliasToUse != property.CmdletParameterName)
+                    {
+                        aliases.Add(aliasToUse);
+                    }
                 }
 
                 if (property.Customization.AutoApplyAlias && property.CmdletParameterName != property.AnalyzedName)
@@ -124,7 +136,15 @@ public HashSet<string> GetAllParameterAliases(SimplePropertyInfo property)
             {
                 var iterAlias = autoIteration.GetIterationParameterAlias(property.AnalyzedName);
                 if (!string.IsNullOrEmpty(iterAlias))
-                    aliases.Add(iterAlias);
+                {
+                    var aliasToUse = ResolveAliasWithReservedParameterName(iterAlias);
+
+                    // If new alias is not equivalent to CmdLet parameter name that would be used, then add it to aliases list.
+                    if (aliasToUse != property.CmdletParameterName)
+                    {
+                        aliases.Add(aliasToUse);
+                    }
+                }
             }
 
             return aliases;
@@ -2407,6 +2427,8 @@ private void FinalizeParameterNames()
                     }
                 }
 
+                // In auto-rename, we attempt to shorten the name. In case there is a new service where there are similar end properties
+                // under different paths (e.g. EmailSettings_EmailMessage for Amplify Backend), then this could generate duplicate parameters.
                 if (attemptAutoRename)
                 {
                     // inspect the name to determine if it can be reduced in length if we flattened a deep
@@ -2434,9 +2456,81 @@ private void FinalizeParameterNames()
                         RecordParameterRename(property, alternateName);
                     }
                 }
+
+                // Attempt to automatically resolve reserved parameter name conflicts.
+                ResolveReservedParameterName(property);
             }
         }
 
+        /// <summary>
+        /// Automatically resolves reserved parameter name conflict.
+        /// </summary>
+        /// <param name="property">Property representing parameter.</param>
+        /// <returns>Flag indicating if resolution was done.</returns>
+        private bool ResolveReservedParameterName(SimplePropertyInfo property)
+        {
+            string parameterNameToResolve = property.Customization?.NewName ?? property.AnalyzedName;
+
+            // Parameter Name conflicts with one of the reserved parameter names. We want to use reserved parameter name from existing list for proper casing.
+            string reservedParameterName = ReservedParameterNames.FirstOrDefault(r => r.Equals(parameterNameToResolve, StringComparison.OrdinalIgnoreCase));
+            if (reservedParameterName != null)
+            {
+                // We want to use reserved parameter name from existing list for proper casing.
+                if (AllModels.ReservedParameterNameMappings.TryGetValue(reservedParameterName, out var newResolvedName))
+                {
+                    newResolvedName = newResolvedName.Replace("{Noun}", CurrentOperation.SelectedNoun).Replace("{Verb}", CurrentOperation.SelectedVerb);
+
+                    var customization = property.Customization;
+                    if (customization == null)
+                    {
+                        customization = new Param
+                        {
+                            Origin = Param.CustomizationOrigin.DuringGeneration,
+                            Name = property.AnalyzedName
+                        };
+                        property.Customization = customization;
+                    }
+
+                    property.Customization.NewName = newResolvedName;
+
+                    // We should not auto apply alias since it would apply an alias of the original name which we have already transformed.
+                    property.Customization.AutoApplyAlias = false;
+
+                    // We should override this even if there was NewName specified in customization.
+                    property.Customization.Origin = Param.CustomizationOrigin.DuringGeneration;
+
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Automatically resolves alias reserved parameter name conflict.
+        /// </summary>
+        /// <param name="alias">Parameter alias.</param>
+        /// <returns>Resolved alias.</returns>
+        private string ResolveAliasWithReservedParameterName(string alias)
+        {
+            string newAlias = alias;
+
+            if (!string.IsNullOrEmpty(alias))
+            {
+                // Alias conflicts with one of the reserved parameter names. We want to use reserved parameter name from existing list for proper casing.
+                string reservedParameterName = ReservedParameterNames.FirstOrDefault(r => r.Equals(alias, StringComparison.OrdinalIgnoreCase));
+                if (reservedParameterName != null)
+                {
+                    // We want to use reserved parameter name from existing list for proper casing.
+                    if (AllModels.ReservedParameterNameMappings.TryGetValue(reservedParameterName, out var newResolvedName))
+                    {
+                        newAlias = newResolvedName.Replace("{Noun}", CurrentOperation.SelectedNoun).Replace("{Verb}", CurrentOperation.SelectedVerb);
+                    }
+                }
+            }
+
+            return newAlias;
+        }
 
         /// <summary>
         /// Register fields derived from the SDK's ConstantClass 'enum' type

generator/AWSPSGeneratorLib/Config/Configs.xml

@@ -13,6 +13,20 @@
     <Map From="ListTagsForResource" To="GetResourceTag" />
     <Map From="GetAccessPolicies" To="GetAccessPolicyCollection" />
   </OperationNameMappings>
+  
+  <ReservedParameterNameMappings>
+    <Map From="Credential" To="{Noun}Credential" />
+    <Map From="AccessKey" To="{Noun}AccessKey" />
+    <Map From="SecretKey" To="{Noun}SecretKey" />
+    <Map From="SecretAccessKey" To="{Noun}SecretAccessKey" />
+    <Map From="SessionToken" To="{Noun}SessionToken" />
+    <Map From="Region" To="{Noun}Region" />
+    <Map From="Select" To="{Noun}Select" />
+    <Map From="Force" To="Force{Verb}" />
+    <Map From="Verbose" To="VerboseOutput" />
+    <Map From="ProfileName" To="Profile" />
+  </ReservedParameterNameMappings>
+  
   <!-- Verb transformation patterns for special operation naming patterns -->
   <VerbNounTransformationPatterns>
     <Pattern Verb="Advertise" TargetVerb="Start" NounTransformation="{Noun}Advertisement" />

generator/AWSPSGeneratorLib/ConfigModel/ConfigModel.cs

@@ -156,6 +156,26 @@ public Dictionary<string, string> OperationNameMappings
             }
         }
 
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        [XmlArray("ReservedParameterNameMappings")]
+        public List<Map> ReservedParameterNameMappingsList = new List<Map>();
+
+        Dictionary<string, string> _reservedParameterNameMappings;
+        /// <summary>
+        /// Reserved parameter name remaps
+        /// </summary>
+        [XmlIgnore]
+        public Dictionary<string, string> ReservedParameterNameMappings
+        {
+            get
+            {
+                if (_reservedParameterNameMappings == null)
+                    _reservedParameterNameMappings = ReservedParameterNameMappingsList.ToDictionary(m => m.From, m => m.To);
+
+                return _reservedParameterNameMappings;
+            }
+        }
+
         [DebuggerBrowsable(DebuggerBrowsableState.Never)]
         [XmlArray("NounMappings")]
         public List<Map> NounMappingsList = new List<Map>();