Include service operation in report.xml while auto-resolving reserved parameter names.

Author: ashishdhingra

buildtools/Build.ps1

@@ -201,8 +201,9 @@ try {
     # if the report.xml is generated, rename it to overrides.xml so that auto-configured operations are included during cmdlet generation.
     try {
       Write-Host "Generating report.xml"
-      # build-report-only generates report.xml only when there is a new operation and
-      # there are no errors during auto-generation of the buildconfig
+      # build-report-only generates report.xml only when there is a new operation 
+	    # or existing operation introduced a parameter which conflicted with reserved parameter name that was auto-resolved
+      # and there are no errors during auto-generation of the buildconfig
       dotnet msbuild ./buildtools/build.proj /t:build-report-only `
         /p:CleanSdkReferences=false `
         /p:BreakOnNewOperations=false `

generator/AWSPSGeneratorLib/Analysis/AnalysisError.cs

@@ -462,5 +462,10 @@ public static void NounAssignmentMethodPrefixTransformationApplied(ConfigModel s
         {
             new InfoMessage(service, operation, $"noun assignment: Method prefix transformation applied - '{originalNoun}' transformed to '{transformedNoun}' using '{methodPrefix}' prefix pattern.");
         }
+
+        public static void ReservedParameterNameConflictResolved(ConfigModel service, ServiceOperation operation, SimplePropertyInfo candidateParameter)
+        {
+            new InfoMessage(service, operation, $"Reserved paramater name conflict {candidateParameter.AnalyzedName} found. Automatically resolved as {candidateParameter.CmdletParameterName}.");
+        }
     }
 }

generator/AWSPSGeneratorLib/Analysis/OperationAnalyzer.cs

@@ -2457,8 +2457,14 @@ private void FinalizeParameterNames()
                     }
                 }
 
-                // Attempt to automatically resolve reserved parameter name conflicts.
-                ResolveReservedParameterName(property);
+                // Attempt to automatically resolve reserved parameter name conflicts. We should attempt auto rename if resolution was not done.
+                if (ResolveReservedParameterName(property))
+                {
+                    CurrentOperation.IsReservedParameterNameHandled = true;
+                    InfoMessage.ReservedParameterNameConflictResolved(CurrentModel, CurrentOperation, property);
+
+                    // For new operations, the CurrentOperation.CustomParameters would not contain the resolved reserved parameter name. During report serialization, we should emit new parameter customization.
+                }
             }
         }
 

generator/AWSPSGeneratorLib/ConfigModel/ConfigModel.cs

@@ -1233,6 +1233,13 @@ public enum LegacyPaginationType
         [XmlIgnore]
         public bool IsAutoConfiguring;
 
+        /// <summary>
+        /// Set when the generator detects a parameter which conflicts with reserved parameter name.
+        /// The generator will take a try to handle the reserved parameter name based on configured mappings.
+        /// </summary>
+        [XmlIgnore]
+        public bool IsReservedParameterNameHandled;
+
         /// <summary>
         /// Stores the VerbNounTransformationPattern that was applied during verb processing.
         /// Used to defer noun transformation to the AssignNoun method.

generator/AWSPSGeneratorLib/ConfigModel/XmlReportWriter.cs

@@ -37,7 +37,7 @@ public static void SerializeReport(string folderPath, IEnumerable<ConfigModel> m
                 var configModelsToOutput = models.Where(configModel =>
                         configModel.AnalysisErrors.Any() ||
                         overrides.ContainsKey(configModel.C2jFilename) ||
-                        configModel.ServiceOperationsList.Where(op => op.IsAutoConfiguring || op.AnalysisErrors.Any()).Any())
+                        configModel.ServiceOperationsList.Where(op => op.IsAutoConfiguring || op.AnalysisErrors.Any() || op.IsReservedParameterNameHandled).Any())
                     .ToArray();
 
                 bool hasErrors = models.Any(configModel =>
@@ -52,6 +52,7 @@ public static void SerializeReport(string folderPath, IEnumerable<ConfigModel> m
                 }
 
                 bool hasNewOperations = models.Any(model => model.ServiceOperationsList.Any(op => op.IsAutoConfiguring));
+                bool isReservedParameterNameHandled = models.Any(model => model.ServiceOperationsList.Any(op => op.IsReservedParameterNameHandled));
 
                 var doc = new XDocument();
 
@@ -141,11 +142,12 @@ public static void SerializeReport(string folderPath, IEnumerable<ConfigModel> m
                     {
                         var isConfigurationOverridden = modelOverrides?.MethodNames.Contains(operation.operation.MethodName) ?? false;
 
-                        //We only include in the report new operations (IsAutoConfiguring=true) and operations requiring configuration updated. We also retain in the report
-                        //any operation that was manually configured.
+                        // We only include in the report new operations (IsAutoConfiguring=true) and operations requiring configuration updated (e.g. reserved parameter name handling).
+                        // We also retain in the report any operation that was manually configured.
                         if (operation.operation.IsAutoConfiguring ||
                             operation.operation.AnalysisErrors.Any() ||
-                            isConfigurationOverridden)
+                            isConfigurationOverridden ||
+                            operation.operation.IsReservedParameterNameHandled)
                         {
                             var firstOperationChildElement = operation.element.Elements().FirstOrDefault();
 
@@ -173,6 +175,35 @@ public static void SerializeReport(string folderPath, IEnumerable<ConfigModel> m
                                 {
                                     if (operation.operation.Analyzer.AnalyzedParameters.Any())
                                     {
+                                        // If reserved parameter name was handled, then we need to update or add Param element for the parameter customization in the report XML.
+                                        var analyzedParametersWithCustomization = operation.operation.Analyzer.AnalyzedParameters.Where(p => p.Customization != null);
+                                        if (operation.operation.IsReservedParameterNameHandled && analyzedParametersWithCustomization.Any())
+                                        {
+                                            var paramsElement = operation.element.Element("Params");
+                                            if (paramsElement == null)
+                                            {
+                                                paramsElement = new XElement("Params");
+                                                operation.element.Add(paramsElement);
+                                            }
+
+                                            foreach (var analyzedParameter in analyzedParametersWithCustomization)
+                                            {
+                                                var parameterElement = paramsElement.Elements("Param").FirstOrDefault(child => (string)child.Attribute("Name") == analyzedParameter.Customization.Name);
+                                                if (parameterElement == null)
+                                                {
+                                                    parameterElement = new XElement("Param", new XAttribute("Name", analyzedParameter.Customization.Name));
+                                                    paramsElement.Add(parameterElement);
+                                                }
+
+                                                parameterElement.SetAttributeValue("NewName", analyzedParameter.Customization.NewName);
+                                                parameterElement.SetAttributeValue("AutoApplyAlias", analyzedParameter.Customization.AutoApplyAlias);
+
+                                                // We can add a XML comment before Param element if customization is due to reserved parameter handling. But we cannot rely on analyzedParameter.Customization.Origin
+                                                // as DuringGeneration since it could happen for other shortning scenarios. We are already adding info message if reserved parameter handling was done, which is good enough.
+                                            }
+                                        }
+
+                                        // Add XML comment about parameters information.
                                         var parametersComments = operation.operation.Analyzer.AnalyzedParameters.Select(PropertyChangedEventArgs => GetParameterCommentForReport(PropertyChangedEventArgs, operation.operation.Analyzer));
                                         operation.element.Add(new XComment($"INFO - Parameters:\n            {string.Join(";\n            ", parametersComments)}."));
                                     }
@@ -205,9 +236,14 @@ public static void SerializeReport(string folderPath, IEnumerable<ConfigModel> m
                     Console.WriteLine("New operations were auto-configured without errors and saved in report.xml");
                     doc.Save(filename);
                 }
+                else if (isReservedParameterNameHandled && !hasErrors)
+                {
+                    Console.WriteLine("Operations had parameters which conflicted with reserved parameter name that were automatically resolved without errors and saved in report.xml");
+                    doc.Save(filename);
+                }
                 else
                 {
-                    Console.WriteLine($"Skipping saving report: hasNewOperations:{hasNewOperations}, hasErrors: {hasErrors} ");
+                    Console.WriteLine($"Skipping saving report: hasNewOperations:{hasNewOperations}, isReservedParameterNameHandled: {isReservedParameterNameHandled}, hasErrors: {hasErrors} ");
                 }
             }
             catch (Exception e)