Add support for transitive NoWarn properties from project references

build/Shared/EqualityUtility.cs

@@ -1,4 +1,4 @@
-// Copyright (c) .NET Foundation. All rights reserved.
+// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
@@ -59,6 +59,37 @@ internal static bool SequenceEqualWithNullCheck<T>(
             return self.SequenceEqual(other, comparer);
         }
 
+        /// <summary>
+        /// Compares two sets for equality, allowing either sequence to be null.
+        /// If one is null, both have to be null for equality.
+        /// </summary>
+        internal static bool SetEqualsWithNullCheck<T>(
+            this ISet<T> self,
+            ISet<T> other,
+            IEqualityComparer<T> comparer = null)
+        {
+            bool identityEquals;
+            if (TryIdentityEquals(self, other, out identityEquals))
+            {
+                return identityEquals;
+            }
+
+            // Verify they could be equal by count
+            if (self.Count != other.Count)
+            {
+                return false;
+            }
+
+            if (comparer == null)
+            {
+                comparer = EqualityComparer<T>.Default;
+            }
+
+            var set = new HashSet<T>(self, comparer);
+
+            return set.SetEquals(other);
+        }
+
         internal static bool DictionaryEquals<TKey, TValue>(
             IDictionary<TKey, TValue> self,
             IDictionary<TKey, TValue> other,
@@ -74,6 +105,12 @@ internal static bool DictionaryEquals<TKey, TValue>(
                 return identityEquals;
             }
 
+            // Verify they could be equal by count
+            if (self.Count != other.Count)
+            {
+                return false;
+            }
+
             if (!self.Keys.OrderedEquals(
                 other.Keys,
                 s => s,

build/Shared/SharedExtensions.cs

@@ -25,9 +25,36 @@ public static List<T> AsList<T>(this IEnumerable<T> enumerable)
             return new List<T>(enumerable);
         }
 
+        /// <summary>
+        /// Return the ISet as a HashSet of T, copying if required. Optimized for common case where it is a HashSet of T.
+        /// Avoid mutating the return value.
+        /// </summary>
+        public static HashSet<T> AsHashSet<T>(this ISet<T> enumerable, IEqualityComparer<T> comparer = null)
+        {
+            if (enumerable == null)
+            {
+                return null;
+            }
+
+            var set = enumerable as HashSet<T>;
+            if (set != null)
+            {
+                return set;
+            }
+            else
+            {
+                if (comparer == null)
+                {
+                    comparer = EqualityComparer<T>.Default;
+                }
+
+                return new HashSet<T>(enumerable, comparer);
+            }
+        }
+
         public static void ForEach<T>(this IEnumerable<T> enumeration, Action<T> action)
         {
-            foreach (T item in enumeration)
+            foreach (var item in enumeration)
             {
                 action(item);
             }

build/common.project.props

@@ -243,7 +243,8 @@
   <!-- All projects in the repository -->
   <ItemGroup Condition=" '$(IsXPlat)' != 'true' ">
     <SolutionProjects Include="$(RepositoryRootDirectory)test\*\*\*.csproj"
-                      Exclude="$(RepositoryRootDirectory)test\EndToEnd\*\*.csproj"
+                      Exclude="$(RepositoryRootDirectory)test\EndToEnd\*\*.csproj;
+                               $(RepositoryRootDirectory)test\NuGet.Tests.Apex\*\*.csproj"
                       Condition=" '$(ExcludeTestProjects)' != 'true' " />
 
     <SolutionProjects Include="$(RepositoryRootDirectory)src\*\*\*.csproj" />

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/PackageReferenceCommands/AddPackageReferenceCommandRunner.cs

@@ -138,7 +138,7 @@ public async Task<int> ExecuteCommand(PackageReferenceArgs packageReferenceArgs,
             }
             // Ignore the graphs with RID
             else if (compatibleFrameworks.Count == 
-                restorePreviewResult.Result.CompatibilityCheckResults.Where(r => r.Graph.RuntimeIdentifier == null).Count())
+                restorePreviewResult.Result.CompatibilityCheckResults.Where(r => string.IsNullOrEmpty(r.Graph.RuntimeIdentifier)).Count())
             {
                 // Package is compatible with all the project TFMs
                 // Add an unconditional package reference to the project

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

@@ -1,26 +1,28 @@
-// Copyright (c) .NET Foundation. All rights reserved.
+// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using NuGet.Common;
 using NuGet.Frameworks;
 using NuGet.ProjectModel;
+using NuGet.Shared;
 
 namespace NuGet.Commands
 {
 
     /// <summary>
     /// Contains Package specific properties for Warnings.
     /// </summary>
-    public class PackageSpecificWarningProperties
+    public class PackageSpecificWarningProperties : IEquatable <PackageSpecificWarningProperties>
     {
 
         /// <summary>
         /// Contains Package specific No warn properties.
         /// NuGetLogCode -> LibraryId -> Set of Frameworks.
         /// </summary>
-        private IDictionary<NuGetLogCode, IDictionary<string, ISet<NuGetFramework>>> Properties;
+        public IDictionary<NuGetLogCode, IDictionary<string, ISet<NuGetFramework>>> Properties { get; private set; }
 
         /// <summary>
         /// Extracts PackageSpecific WarningProperties from a PackageSpec
@@ -36,21 +38,48 @@ public static PackageSpecificWarningProperties CreatePackageSpecificWarningPrope
             {
                 foreach (var framework in packageSpec.TargetFrameworks)
                 {
-                    warningProperties.AddRange(dependency.NoWarn, dependency.Name, framework.FrameworkName);
+                    warningProperties.AddRangeOfCodes(dependency.NoWarn, dependency.Name, framework.FrameworkName);
                 }
             }
 
             foreach (var framework in packageSpec.TargetFrameworks)
             {
                 foreach (var dependency in framework.Dependencies)
                 {
-                    warningProperties.AddRange(dependency.NoWarn, dependency.Name, framework.FrameworkName);
+                    warningProperties.AddRangeOfCodes(dependency.NoWarn, dependency.Name, framework.FrameworkName);
                 }
             }
 
             return warningProperties;
         }
 
+        /// <summary>
+        /// Extracts PackageSpecific WarningProperties from a PackageSpec for a specific NuGetFramework
+        /// </summary>
+        /// <param name="packageSpec">PackageSpec containing the Dependencies with WarningProperties</param>
+        /// <param name="framework">NuGetFramework for which the properties should be assessed.</param>
+        /// <returns>PackageSpecific WarningProperties extracted from a PackageSpec for a specific NuGetFramework</returns>
+        public static PackageSpecificWarningProperties CreatePackageSpecificWarningProperties(PackageSpec packageSpec, 
+            NuGetFramework framework)
+        {
+            // NuGetLogCode -> LibraryId -> Set of Frameworks.
+            var warningProperties = new PackageSpecificWarningProperties();
+
+            foreach (var dependency in packageSpec.Dependencies)
+            {
+                warningProperties.AddRangeOfCodes(dependency.NoWarn, dependency.Name, framework);
+            }
+
+            var targetFrameworkInformation = packageSpec.GetTargetFramework(framework);
+
+            foreach (var dependency in targetFrameworkInformation.Dependencies)
+            {
+                warningProperties.AddRangeOfCodes(dependency.NoWarn, dependency.Name, framework);
+            }
+
+            return warningProperties;
+        }
+
         /// <summary>
         /// Adds a NuGetLogCode into the NoWarn Set for the specified library Id and target graph.
         /// </summary>
@@ -85,14 +114,28 @@ public void Add(NuGetLogCode code, string libraryId, NuGetFramework framework)
         /// <param name="codes">IEnumerable of NuGetLogCode for which no warning should be thrown.</param>
         /// <param name="libraryId">Library for which no warning should be thrown.</param>
         /// <param name="framework">Target graph for which no warning should be thrown.</param>
-        public void AddRange(IEnumerable<NuGetLogCode> codes, string libraryId, NuGetFramework framework)
+        public void AddRangeOfCodes(IEnumerable<NuGetLogCode> codes, string libraryId, NuGetFramework framework)
         {
             foreach (var code in codes)
             {
                 Add(code, libraryId, framework);
             }
         }
 
+        /// <summary>
+        /// Adds a list of NuGetLogCode into the NoWarn Set for the specified library Id and target graph.
+        /// </summary>
+        /// <param name="code">NuGetLogCode for which no warning should be thrown.</param>
+        /// <param name="libraryId">Library for which no warning should be thrown.</param>
+        /// <param name="frameworks">IEnumerable of Target graph for which no warning should be thrown.</param>
+        public void AddRangeOfFrameworks(NuGetLogCode code, string libraryId, IEnumerable<NuGetFramework> frameworks)
+        {
+            foreach (var framework in frameworks)
+            {
+                Add(code, libraryId, framework);
+            }
+        }
+
         /// <summary>
         /// Checks if a NugetLogCode is part of the NoWarn list for the specified library Id and target graph.
         /// </summary>
@@ -107,5 +150,34 @@ public bool Contains(NuGetLogCode code, string libraryId, NuGetFramework framewo
                 libraryIdsAndFrameworks.TryGetValue(libraryId, out var frameworkSet) &&
                 frameworkSet.Contains(framework);
         }
+
+        public override int GetHashCode()
+        {
+            // return a constant hash for all objects since the contents of Properties are mutable
+            return 1;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as PackageSpecificWarningProperties);
+        }
+
+        public bool Equals(PackageSpecificWarningProperties other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return EqualityUtility.DictionaryEquals(
+                Properties,
+                other.Properties,
+                (sv1, ov1) => EqualityUtility.DictionaryEquals(sv1, ov1, (sv2, ov2) => EqualityUtility.SetEqualsWithNullCheck(sv2, ov2)));
+        }
     }
 }