Add support for transitive NoWarn properties from project references

src/NuGet.Core/NuGet.Commands/RestoreCommand/Logging/RestoreCollectorLogger.cs

@@ -130,6 +130,8 @@ public void Log(IRestoreLogMessage message)
             // This will be true if the message is not or warning or it is not suppressed.
             if (!IsWarningSuppressed(message))
             {
+                UpgradeWarningIfNeeded(message);
+
                 if (string.IsNullOrEmpty(message.FilePath))
                 {
                     message.FilePath = message.ProjectPath ?? ProjectPath;
@@ -152,6 +154,8 @@ public Task LogAsync(IRestoreLogMessage message)
             // This will be true if the message is not or warning or it is not suppressed.
             if (!IsWarningSuppressed(message))
             {
+                UpgradeWarningIfNeeded(message);
+
                 if (string.IsNullOrEmpty(message.FilePath))
                 {
                     message.FilePath = message.ProjectPath ?? ProjectPath;
@@ -205,20 +209,39 @@ protected bool DisplayMessage(IRestoreLogMessage message)
         /// <returns>bool indicating if the message should be suppressed.</returns>
         private bool IsWarningSuppressed(IRestoreLogMessage message)
         {
-
-            if (ProjectWarningPropertiesCollection != null && ProjectWarningPropertiesCollection.ApplyWarningProperties(message))
-            {
-                return true;
-            }
-            else if (message.Level == LogLevel.Warning)
+            if (message.Level == LogLevel.Warning)
             {
-                // Use transitive warning properties only if the project does not suppress the warning or upgrade it to an error
-                return TransitiveWarningPropertiesCollection != null && TransitiveWarningPropertiesCollection.ApplyWarningProperties(message);
+                // If the ProjectWarningPropertiesCollection is present then test if the warning is suppressed in
+                // project wide no warn or package specific no warn
+                if (ProjectWarningPropertiesCollection != null && ProjectWarningPropertiesCollection.ApplyNoWarnProperties(message))
+                {
+                    return true;
+                }
+                else
+                {
+                    // Use transitive warning properties only if the project does not suppress the warning
+                    // In transitive warning properties look at only the package specific ones as all properties are per package reference.
+                    return TransitiveWarningPropertiesCollection != null && TransitiveWarningPropertiesCollection.ApplyNoWarnProperties(message);
+                }
             }
 
             return false;
         }
 
+        /// <summary>
+        /// This method upgrades the warning to an error if the project wide warning properties have set the code in WarningsAsErrors or
+        /// set TreatWarningsAsErrors to true
+        /// </summary>
+        /// <param name="message">IRestoreLogMessage to be logged as an error or warning.</param>
+        /// <returns>bool indicating if the message should be suppressed.</returns>
+        private void UpgradeWarningIfNeeded(IRestoreLogMessage message)
+        {
+            if (ProjectWarningPropertiesCollection != null)
+            {
+                ProjectWarningPropertiesCollection.ApplyWarningAsErrorProperties(message);
+            }
+        }
+
         private static IRestoreLogMessage ToRestoreLogMessage(ILogMessage message)
         {
             var restoreLogMessage = message as IRestoreLogMessage;

src/NuGet.Core/NuGet.Commands/RestoreCommand/Logging/WarningPropertiesCollection.cs

@@ -55,75 +55,116 @@ public WarningPropertiesCollection(WarningProperties projectWideWarningPropertie
         /// If not then the param message sould have been mutated to an error</returns>
         public bool ApplyWarningProperties(IRestoreLogMessage message)
         {
-            if (message.Level != LogLevel.Warning)
+            if (ApplyProjectWideNoWarnProperties(message) || ApplyPackageSpecificNoWarnProperties(message))
             {
-                return false;
+                return true;
             }
             else
             {
-                // First look at PackageSpecificWarningProperties and then at ProjectWideWarningProperties.
-                if (!string.IsNullOrEmpty(message.LibraryId) && PackageSpecificWarningProperties != null)
-                {
-                    var messageTargetFrameworks = message.TargetGraphs.Select(GetNuGetFramework).ToList();
+                ApplyWarningAsErrorProperties(message);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Attempts to suppress a warning log message.
+        /// The decision is made based on the Package Specific or Project wide no warn properties.
+        /// </summary>
+        /// <param name="message">Message that should be suppressed.</param>
+        /// <returns>Bool indicating is the warning should be suppressed or not.</returns>
+        public bool ApplyNoWarnProperties(IRestoreLogMessage message)
+        {
+            return ApplyProjectWideNoWarnProperties(message) || ApplyPackageSpecificNoWarnProperties(message);
+        }
+
+        /// <summary>
+        /// Method is used to upgrade a warning to an error if needed.
+        /// </summary>
+        /// <param name="message">Message which should be upgraded to error if needed.</param>
+        public void ApplyWarningAsErrorProperties(IRestoreLogMessage message)
+        {
+            ApplyProjectWideWarningsAsErrorProperties(message);
+        }
+
+        /// <summary>
+        /// Method is used to check is a warning should be suppressed due to package specific no warn properties.
+        /// </summary>
+        /// <param name="message">Message to be checked for no warn.</param>
+        /// <returns>bool indicating if the IRestoreLogMessage should be suppressed or not.</returns>
+        private bool ApplyPackageSpecificNoWarnProperties(IRestoreLogMessage message)
+        {            
+            if (message.Level == LogLevel.Warning &&
+                PackageSpecificWarningProperties != null &&
+                !string.IsNullOrEmpty(message.LibraryId))
+            {
+                var messageTargetFrameworks = message.TargetGraphs.Select(GetNuGetFramework).ToList();
 
-                    // If the message does not contain a target graph, assume that it is applicable for all project frameworks.
-                    if (messageTargetFrameworks.Count == 0)
+                // If the message does not contain a target graph, assume that it is applicable for all project frameworks.
+                if (messageTargetFrameworks.Count == 0)
+                {
+                    // Suppress the warning if the code + libraryId combination is suppressed for all project frameworks.
+                    if (ProjectFrameworks.Count > 0 &&
+                        ProjectFrameworks.All(e => PackageSpecificWarningProperties.Contains(message.Code, message.LibraryId, e)))
                     {
-                        // Suppress the warning if the code + libraryId combination is suppressed for all project frameworks.
-                        if (ProjectFrameworks.Count > 0 &&
-                            ProjectFrameworks.All(e => PackageSpecificWarningProperties.Contains(message.Code, message.LibraryId, e)))
-                        {
-                            return true;
-                        }
+                        return true;
                     }
-                    else
+                }
+                else
+                {
+                    // Get all the target graphs for which code + libraryId combination is not suppressed.
+                    message.TargetGraphs = message
+                        .TargetGraphs
+                        .Where(e => !PackageSpecificWarningProperties.Contains(message.Code, message.LibraryId, GetNuGetFramework(e)))
+                        .ToList();
+
+                    // If the message is left with no target graphs then suppress it.
+                    if (message.TargetGraphs.Count == 0)
                     {
-                        // Get all the target graphs for which code + libraryId combination is not suppressed.
-                        message.TargetGraphs = message
-                            .TargetGraphs
-                            .Where(e => !PackageSpecificWarningProperties.Contains(message.Code, message.LibraryId, GetNuGetFramework(e)))
-                            .ToList();
-
-                        // If the message is left with no target graphs then suppress it.
-                        if (message.TargetGraphs.Count == 0)
-                        {
-                            return true;
-                        }
+                        return true;
                     }
                 }
-
-                // The message does not contain a LibraryId or it is not suppressed in package specific settings.
-                // Apply ProjectWideWarningProperties.
-                return ProjectWideWarningProperties != null && ApplyProjectWideWarningProperties(message);
             }
+
+            // The message is not a warning or it does not contain a LibraryId or it is not suppressed in package specific settings.
+            return false;
         }
 
         /// <summary>
-        /// Method is used to check is a warning should be suppressed and if not then if it should be treated as an error.
+        /// Method is used to check is a warning should be suppressed due to project wide no warn properties.
         /// </summary>
-        /// <param name="logMessage">Message which should be mutated if needed.</param>
+        /// <param name="message">Message to be checked for no warn.</param>
         /// <returns>bool indicating if the ILogMessage should be suppressed or not.</returns>
-        private bool ApplyProjectWideWarningProperties(ILogMessage logMessage)
+        private bool ApplyProjectWideNoWarnProperties(ILogMessage message)
         {
-            if (logMessage.Level == LogLevel.Warning)
+            if (message.Level == LogLevel.Warning && ProjectWideWarningProperties != null)
             {
-                if (ProjectWideWarningProperties.NoWarn.Contains(logMessage.Code))
+                if (ProjectWideWarningProperties.NoWarn.Contains(message.Code))
                 {
                     // If the project wide NoWarn contains the message code then suppress it.
                     return true;
-                }
-                else if ((ProjectWideWarningProperties.AllWarningsAsErrors && logMessage.Code > NuGetLogCode.Undefined) || 
-                    ProjectWideWarningProperties.WarningsAsErrors.Contains(logMessage.Code))
+                }              
+            }
+
+            // the project wide NoWarn does contain the message code. do not suppress the warning.
+            return false;
+        }
+
+        /// <summary>
+        /// Method is used to check is a warning should be treated as an error.
+        /// </summary>
+        /// <param name="message">Message which should be upgraded to error if needed.</param>
+        private void ApplyProjectWideWarningsAsErrorProperties(ILogMessage message)
+        {
+            if (message.Level == LogLevel.Warning && ProjectWideWarningProperties != null)
+            {
+                if ((ProjectWideWarningProperties.AllWarningsAsErrors && message.Code > NuGetLogCode.Undefined) || 
+                    ProjectWideWarningProperties.WarningsAsErrors.Contains(message.Code))
                 {
                     // If the project wide AllWarningsAsErrors is true and the message has a valid code or
-                    // project wide WarningsAsErrors contains the message code then pgrade to error and do not suppress it.
-                    logMessage.Level = LogLevel.Error;
-                    return false;
+                    // Project wide WarningsAsErrors contains the message code then upgrade to error.
+                    message.Level = LogLevel.Error;
                 }
             }
-
-            // Finally do not suppress or modify the message.
-            return false;
         }
 
         private NuGetFramework GetNuGetFramework(string targetGraph)