Use already calculated NuGet matching

Author: ViktorHofer

src/ApiCompat/Microsoft.DotNet.ApiCompat.Shared/ValidatePackage.cs

@@ -69,8 +69,7 @@ public static void Run(Func<ISuppressionEngine, ISuppressableLog> logFactory,
                     enableStrictMode: enableStrictModeForBaselineValidation,
                     enqueueApiCompatWorkItems: runApiCompat,
                     executeApiCompatWorkItems: false,
-                    // Use the current package assembly references if baseline package assembly references aren't provided.
-                    baselinePackage: Package.Create(baselinePackagePath, baselinePackageAssemblyReferences ?? packageAssemblyReferences)));
+                    baselinePackage: Package.Create(baselinePackagePath, baselinePackageAssemblyReferences)));
             }
 
             if (runApiCompat)

src/ApiCompat/Microsoft.DotNet.ApiCompatibility/Runner/ApiCompatRunner.cs

@@ -46,13 +46,13 @@ public void ExecuteWorkItems()
 
             foreach (ApiCompatRunnerWorkItem workItem in _workItems)
             {
-                IReadOnlyList<ElementContainer<IAssemblySymbol>> leftContainerList = CreateAssemblySymbols(workItem.Left, out bool resolvedExternallyProvidedAssemblyReferences);
+                IReadOnlyList<ElementContainer<IAssemblySymbol>> leftContainerList = CreateAssemblySymbols(workItem.Left, workItem.Options, out bool resolvedExternallyProvidedAssemblyReferences);
                 bool runWithReferences = resolvedExternallyProvidedAssemblyReferences;
 
                 List<IEnumerable<ElementContainer<IAssemblySymbol>>> rightContainersList = new(workItem.Right.Count);
                 foreach (IReadOnlyList<MetadataInformation> right in workItem.Right)
                 {
-                    IReadOnlyList<ElementContainer<IAssemblySymbol>> rightContainers = CreateAssemblySymbols(right.ToImmutableArray(), out resolvedExternallyProvidedAssemblyReferences);
+                    IReadOnlyList<ElementContainer<IAssemblySymbol>> rightContainers = CreateAssemblySymbols(right.ToImmutableArray(), workItem.Options, out resolvedExternallyProvidedAssemblyReferences);
                     rightContainersList.Add(rightContainers);
                     runWithReferences &= resolvedExternallyProvidedAssemblyReferences;
                 }
@@ -112,6 +112,7 @@ public void ExecuteWorkItems()
         }
 
         private IReadOnlyList<ElementContainer<IAssemblySymbol>> CreateAssemblySymbols(IReadOnlyList<MetadataInformation> metadataInformation,
+            ApiCompatRunnerOptions options,
             out bool resolvedExternallyProvidedAssemblyReferences)
         {
             string[] aggregatedReferences = metadataInformation.Where(m => m.References != null).SelectMany(m => m.References!).Distinct().ToArray();

src/ApiCompat/Microsoft.DotNet.PackageValidation/ApiCompatRunnerExtensions.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using Microsoft.DotNet.ApiCompatibility;
 using Microsoft.DotNet.ApiCompatibility.Logging;
@@ -25,21 +26,15 @@ public static void QueueApiCompatFromContentItem(this IApiCompatRunner apiCompat
             Package leftPackage,
             Package? rightPackage = null)
         {
+            Debug.Assert(leftContentItems.Count > 0);
+            Debug.Assert(rightContentItems.Count > 0);
+
             // Don't enqueue duplicate items (if no right package is supplied and items match)
-            if (rightPackage == null && ContentItemCollectionEquals(leftContentItems, rightContentItems))
+            if (rightPackage is null && ContentItemCollectionEquals(leftContentItems, rightContentItems))
             {
                 return;
             }
 
-            MetadataInformation[] left = new MetadataInformation[leftContentItems.Count];
-            for (int leftIndex = 0; leftIndex < leftContentItems.Count; leftIndex++)
-            {
-                left[leftIndex] = GetMetadataInformation(log,
-                    leftPackage,
-                    leftContentItems[leftIndex],
-                    options.IsBaselineComparison ? Resources.Baseline + " " + leftContentItems[leftIndex].Path : null);
-            }
-
             MetadataInformation[] right = new MetadataInformation[rightContentItems.Count];
             for (int rightIndex = 0; rightIndex < rightContentItems.Count; rightIndex++)
             {
@@ -48,30 +43,46 @@ public static void QueueApiCompatFromContentItem(this IApiCompatRunner apiCompat
                     rightContentItems[rightIndex]);
             }
 
+            MetadataInformation[] left = new MetadataInformation[leftContentItems.Count];
+            for (int leftIndex = 0; leftIndex < leftContentItems.Count; leftIndex++)
+            {
+                left[leftIndex] = GetMetadataInformation(log,
+                    leftPackage,
+                    leftContentItems[leftIndex],
+                    displayString: options.IsBaselineComparison ? Resources.Baseline + " " + leftContentItems[leftIndex].Path : null,
+                    // Use the assembly references from the right package if the left package doesn't provide them.
+                    assemblyReferences: rightPackage is not null ? right[right.Length > leftIndex ? leftIndex : 0].References : null);
+            }
+
             apiCompatRunner.EnqueueWorkItem(new ApiCompatRunnerWorkItem(left, options, right));
         }
 
         private static MetadataInformation GetMetadataInformation(ISuppressableLog log,
             Package package,
             ContentItem item,
-            string? displayString = null)
+            string? displayString = null,
+            IEnumerable<string>? assemblyReferences = null)
         {
             displayString ??= item.Path;
-            string[]? assemblyReferences = null;
 
             if (item.Properties.TryGetValue("tfm", out object? tfmObj))
             {
-                // Find the nearest set of assembly references for the package item (assembly).
-                NuGetFramework targetFramework = ((NuGetFramework)tfmObj);
-                assemblyReferences = package.FindBestAssemblyReferencesForFramework(targetFramework);
+                string targetFramework = ((NuGetFramework)tfmObj).GetShortFolderName();
 
-                if (package.AssemblyReferences != null && assemblyReferences is null)
+                if (package.AssemblyReferences != null)
                 {
-                    log.LogWarning(new Suppression(DiagnosticIds.SearchDirectoriesNotFoundForTfm) { Target = displayString },
-                        DiagnosticIds.SearchDirectoriesNotFoundForTfm,
-                        string.Format(Resources.MissingSearchDirectory,
-                            targetFramework.GetShortFolderName(),
-                            displayString));
+                    if (package.AssemblyReferences.TryGetValue(targetFramework, out string[]? assemblyReferencesRaw))
+                    {
+                        assemblyReferences = assemblyReferencesRaw;
+                    }
+                    else
+                    {
+                        log.LogWarning(new Suppression(DiagnosticIds.SearchDirectoriesNotFoundForTfm) { Target = displayString },
+                           DiagnosticIds.SearchDirectoriesNotFoundForTfm,
+                           string.Format(Resources.MissingSearchDirectory,
+                               targetFramework,
+                               displayString));
+                    }
                 }
             }
 

src/ApiCompat/Microsoft.DotNet.PackageValidation/Package.cs

@@ -224,23 +224,5 @@ public static Package Create(string? packagePath, Dictionary<string, string[]>?
                 new ReadOnlyCollection<ContentItem>(items) :
                 null;
         }
-
-        /// <summary>
-        /// Finds the best assembly references for a specific framework.
-        /// </summary>
-        /// <param name="framework">The framework where the package needs to be installed.</param>
-        /// <returns>The assembly references for the specified framework.</returns>
-        public string[]? FindBestAssemblyReferencesForFramework(NuGetFramework framework)
-        {
-            if (AssemblyReferences is null)
-                return null;
-
-            string? nearestTfm = NuGetFrameworkUtility.GetNearest(AssemblyReferences.Keys, framework, (key) => NuGetFramework.ParseFolder(key));
-
-            if (nearestTfm is null || !AssemblyReferences.TryGetValue(nearestTfm, out string[]? assemblyReferences))
-                return null;
-
-            return assemblyReferences;
-        }
     }
 }