dependabot-nuget 0.302.0 → 0.303.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/UpdateOperationBase.cs

@@ -0,0 +1,209 @@
+using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Serialization;
+
+using NuGet.Versioning;
+
+using NuGetUpdater.Core.Utilities;
+
+
+namespace NuGetUpdater.Core.Updater;
+
+[JsonDerivedType(typeof(DirectUpdate))]
+[JsonDerivedType(typeof(PinnedUpdate))]
+[JsonDerivedType(typeof(ParentUpdate))]
+public abstract record UpdateOperationBase
+{
+    public abstract string Type { get; }
+    public required string DependencyName { get; init; }
+    public required NuGetVersion NewVersion { get; init; }
+    public required ImmutableArray<string> UpdatedFiles { get; init; }
+
+    public abstract string GetReport();
+
+    internal static string GenerateUpdateOperationReport(IEnumerable<UpdateOperationBase> updateOperations)
+    {
+        var updateMessages = updateOperations.Select(u => u.GetReport()).ToImmutableArray();
+        if (updateMessages.Length == 0)
+        {
+            return string.Empty;
+        }
+
+        var separator = "\n    ";
+        var report = $"Performed the following updates:{separator}{string.Join(separator, updateMessages.Select(m => $"- {m}"))}";
+        return report;
+    }
+
+    internal static ImmutableArray<UpdateOperationBase> NormalizeUpdateOperationCollection(string repoRootPath, IEnumerable<UpdateOperationBase> updateOperations)
+    {
+        var groupedByKindWithCombinedFiles = updateOperations
+            .GroupBy(u => (u.GetType(), u.DependencyName, u.NewVersion))
+            .Select(g =>
+            {
+                if (g.Key.Item1 == typeof(DirectUpdate))
+                {
+                    return new DirectUpdate()
+                    {
+                        DependencyName = g.Key.DependencyName,
+                        NewVersion = g.Key.NewVersion,
+                        UpdatedFiles = [.. g.SelectMany(u => u.UpdatedFiles)],
+                    } as UpdateOperationBase;
+                }
+                else if (g.Key.Item1 == typeof(PinnedUpdate))
+                {
+                    return new PinnedUpdate()
+                    {
+                        DependencyName = g.Key.DependencyName,
+                        NewVersion = g.Key.NewVersion,
+                        UpdatedFiles = [.. g.SelectMany(u => u.UpdatedFiles)],
+                    };
+                }
+                else if (g.Key.Item1 == typeof(ParentUpdate))
+                {
+                    var parentUpdate = (ParentUpdate)g.First();
+                    return new ParentUpdate()
+                    {
+                        DependencyName = g.Key.DependencyName,
+                        NewVersion = g.Key.NewVersion,
+                        UpdatedFiles = [.. g.SelectMany(u => u.UpdatedFiles)],
+                        ParentDependencyName = parentUpdate.ParentDependencyName,
+                        ParentNewVersion = parentUpdate.ParentNewVersion,
+                    };
+                }
+                else
+                {
+                    throw new NotImplementedException(g.Key.Item1.FullName);
+                }
+            })
+            .ToImmutableArray();
+        var withNormalizedAndDistinctPaths = groupedByKindWithCombinedFiles
+            .Select(u => u with { UpdatedFiles = [.. u.UpdatedFiles.Select(f => Path.GetRelativePath(repoRootPath, f).FullyNormalizedRootedPath()).Distinct(PathComparer.Instance).OrderBy(f => f, StringComparer.Ordinal)] })
+            .ToImmutableArray();
+        var uniqueUpdateOperations = withNormalizedAndDistinctPaths.Distinct(UpdateOperationBaseComparer.Instance).ToImmutableArray();
+        var ordered = uniqueUpdateOperations
+            .OrderBy(u => u.GetType().Name)
+            .ThenBy(u => u.DependencyName)
+            .ThenBy(u => u.NewVersion)
+            .ThenBy(u => u.UpdatedFiles.Length)
+            .ThenBy(u => string.Join(",", u.UpdatedFiles))
+            .ThenBy(u => u is ParentUpdate parentUpdate ? parentUpdate.ParentDependencyName : string.Empty)
+            .ThenBy(u => u is ParentUpdate parentUpdate ? parentUpdate.ParentNewVersion : u.NewVersion)
+            .ToImmutableArray();
+        return ordered;
+    }
+
+    public override int GetHashCode()
+    {
+        var hash = new HashCode();
+        hash.Add(DependencyName);
+        hash.Add(NewVersion);
+        hash.Add(UpdatedFiles.Length);
+        for (int i = 0; i < UpdatedFiles.Length; i++)
+        {
+            hash.Add(UpdatedFiles[i]);
+        }
+
+        return hash.ToHashCode();
+    }
+
+    protected string GetString() => $"{GetType().Name} {{ {nameof(DependencyName)} = {DependencyName}, {nameof(NewVersion)} = {NewVersion}, {nameof(UpdatedFiles)} = {string.Join(",", UpdatedFiles)} }}";
+}
+
+public record DirectUpdate : UpdateOperationBase
+{
+    public override string Type => nameof(DirectUpdate);
+    public override string GetReport() => $"Updated {DependencyName} to {NewVersion} in {string.Join("", UpdatedFiles)}";
+    public sealed override string ToString() => GetString();
+}
+
+public record PinnedUpdate : UpdateOperationBase
+{
+    public override string Type => nameof(PinnedUpdate);
+    public override string GetReport() => $"Pinned {DependencyName} at {NewVersion} in {string.Join("", UpdatedFiles)}";
+    public sealed override string ToString() => GetString();
+}
+
+public record ParentUpdate : UpdateOperationBase, IEquatable<UpdateOperationBase>
+{
+    public override string Type => nameof(ParentUpdate);
+    public required string ParentDependencyName { get; init; }
+    public required NuGetVersion ParentNewVersion { get; init; }
+
+    public override string GetReport() => $"Updated {DependencyName} to {NewVersion} indirectly via {ParentDependencyName}/{ParentNewVersion} in {string.Join("", UpdatedFiles)}";
+
+    bool IEquatable<UpdateOperationBase>.Equals(UpdateOperationBase? other)
+    {
+        if (!base.Equals(other))
+        {
+            return false;
+        }
+
+        if (other is not ParentUpdate otherParentUpdate)
+        {
+            return false;
+        }
+
+        return ParentDependencyName == otherParentUpdate.ParentDependencyName
+            && ParentNewVersion == otherParentUpdate.ParentNewVersion;
+    }
+
+    public override int GetHashCode()
+    {
+        var hash = new HashCode();
+        hash.Add(base.GetHashCode());
+        hash.Add(ParentDependencyName);
+        hash.Add(ParentNewVersion);
+        return hash.ToHashCode();
+    }
+
+    public sealed override string ToString() => $"{GetType().Name} {{ {nameof(DependencyName)} = {DependencyName}, {nameof(NewVersion)} = {NewVersion}, {nameof(ParentDependencyName)} = {ParentDependencyName}, {nameof(ParentNewVersion)} = {ParentNewVersion}, {nameof(UpdatedFiles)} = {string.Join(",", UpdatedFiles)} }}";
+}
+
+public class UpdateOperationBaseComparer : IEqualityComparer<UpdateOperationBase>
+{
+    public static UpdateOperationBaseComparer Instance = new();
+
+    public bool Equals(UpdateOperationBase? x, UpdateOperationBase? y)
+    {
+        if (x is null && y is null)
+        {
+            return true;
+        }
+
+        if (x is null || y is null)
+        {
+            return false;
+        }
+
+        if (ReferenceEquals(x, y))
+        {
+            return true;
+        }
+
+        if (x.GetType() != y.GetType())
+        {
+            return false;
+        }
+
+        if (x.DependencyName != y.DependencyName ||
+            x.NewVersion != y.NewVersion ||
+            !x.UpdatedFiles.SequenceEqual(y.UpdatedFiles))
+        {
+            return false;
+        }
+
+        if (x is ParentUpdate px && y is ParentUpdate py)
+        {
+            // the `.GetType()` check above ensures this is safe
+            if (px.ParentDependencyName != py.ParentDependencyName ||
+                px.ParentNewVersion != py.ParentNewVersion)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public int GetHashCode([DisallowNull] UpdateOperationBase obj) => obj.GetHashCode();
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/UpdateOperationResult.cs

@@ -1,5 +1,8 @@
+using System.Collections.Immutable;
+
 namespace NuGetUpdater.Core.Updater;
 
 public record UpdateOperationResult : NativeResult
 {
+    public required ImmutableArray<UpdateOperationBase> UpdateOperations { get; init; }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/UpdaterWorker.cs

@@ -1,3 +1,4 @@
+using System.Collections.Immutable;
 using System.Net;
 using System.Text.Json;
 using System.Text.Json.Serialization;
@@ -19,7 +20,7 @@ public class UpdaterWorker : IUpdaterWorker
     internal static readonly JsonSerializerOptions SerializerOptions = new()
     {
         WriteIndented = true,
-        Converters = { new JsonStringEnumConverter() },
+        Converters = { new JsonStringEnumConverter(), new VersionConverter() },
     };
 
     public UpdaterWorker(string jobId, ExperimentsManager experimentsManager, ILogger logger)
@@ -41,10 +42,10 @@ public class UpdaterWorker : IUpdaterWorker
     // this is a convenient method for tests
     internal async Task<UpdateOperationResult> RunWithErrorHandlingAsync(string repoRootPath, string workspacePath, string dependencyName, string previousDependencyVersion, string newDependencyVersion, bool isTransitive)
     {
-        UpdateOperationResult result = new(); // assumed to be ok until proven otherwise
         try
         {
-            result = await RunAsync(repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
+            var result = await RunAsync(repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
+            return result;
         }
         catch (Exception ex)
         {
@@ -52,13 +53,15 @@ public class UpdaterWorker : IUpdaterWorker
             {
                 workspacePath = Path.GetFullPath(Path.Join(repoRootPath, workspacePath));
             }
-            result = new()
+
+            var error = JobErrorBase.ErrorFromException(ex, _jobId, workspacePath);
+            var result = new UpdateOperationResult()
             {
-                Error = JobErrorBase.ErrorFromException(ex, _jobId, workspacePath),
+                UpdateOperations = [],
+                Error = error,
             };
+            return result;
         }
-
-        return result;
     }
 
     public async Task<UpdateOperationResult> RunAsync(string repoRootPath, string workspacePath, string dependencyName, string previousDependencyVersion, string newDependencyVersion, bool isTransitive)
@@ -76,40 +79,60 @@ public class UpdaterWorker : IUpdaterWorker
             await GlobalJsonUpdater.UpdateDependencyAsync(repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, _logger);
         }
 
+        UpdateOperationResult result;
         var extension = Path.GetExtension(workspacePath).ToLowerInvariant();
         switch (extension)
         {
             case ".sln":
-                await RunForSolutionAsync(repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
+                result = await RunForSolutionAsync(repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
                 break;
             case ".proj":
-                await RunForProjFileAsync(repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
+                result = await RunForProjFileAsync(repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
                 break;
             case ".csproj":
             case ".fsproj":
             case ".vbproj":
-                await RunForProjectAsync(repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
+                result = await RunForProjectAsync(repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
                 break;
             default:
                 _logger.Info($"File extension [{extension}] is not supported.");
+                result = new UpdateOperationResult()
+                {
+                    UpdateOperations = [],
+                };
                 break;
         }
 
+        result = result with { UpdateOperations = UpdateOperationBase.NormalizeUpdateOperationCollection(repoRootPath, result.UpdateOperations) };
+
+        if (!_experimentsManager.NativeUpdater)
+        {
+            // native updater reports the changes elsewhere
+            var updateReport = UpdateOperationBase.GenerateUpdateOperationReport(result.UpdateOperations);
+            _logger.Info(updateReport);
+        }
+
         _logger.Info("Update complete.");
 
         _processedProjectPaths.Clear();
-        return new UpdateOperationResult();
+        return result;
+    }
+
+    internal static string Serialize(UpdateOperationResult result)
+    {
+        var resultJson = JsonSerializer.Serialize(result, SerializerOptions);
+        return resultJson;
     }
 
     internal static async Task WriteResultFile(UpdateOperationResult result, string resultOutputPath, ILogger logger)
     {
         logger.Info($"  Writing update result to [{resultOutputPath}].");
 
-        var resultJson = JsonSerializer.Serialize(result, SerializerOptions);
+        var resultJson = Serialize(result);
         await File.WriteAllTextAsync(resultOutputPath, resultJson);
     }
 
-    private async Task RunForSolutionAsync(
+    private async Task<UpdateOperationResult> RunForSolutionAsync(
         string repoRootPath,
         string solutionPath,
         string dependencyName,
@@ -118,14 +141,21 @@ public class UpdaterWorker : IUpdaterWorker
         bool isTransitive)
     {
         _logger.Info($"Running for solution [{Path.GetRelativePath(repoRootPath, solutionPath)}]");
+        var updateOperations = new List<UpdateOperationBase>();
         var projectPaths = MSBuildHelper.GetProjectPathsFromSolution(solutionPath);
         foreach (var projectPath in projectPaths)
         {
-            await RunForProjectAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
+            var projectResult = await RunForProjectAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
+            updateOperations.AddRange(projectResult.UpdateOperations);
         }
+
+        return new UpdateOperationResult()
+        {
+            UpdateOperations = updateOperations.ToImmutableArray(),
+        };
     }
 
-    private async Task RunForProjFileAsync(
+    private async Task<UpdateOperationResult> RunForProjFileAsync(
         string repoRootPath,
         string projFilePath,
         string dependencyName,
@@ -137,21 +167,31 @@ public class UpdaterWorker : IUpdaterWorker
         if (!File.Exists(projFilePath))
         {
             _logger.Info($"File [{projFilePath}] does not exist.");
-            return;
+            return new UpdateOperationResult()
+            {
+                UpdateOperations = [],
+            };
         }
 
+        var updateOperations = new List<UpdateOperationBase>();
         var projectFilePaths = MSBuildHelper.GetProjectPathsFromProject(projFilePath);
         foreach (var projectFullPath in projectFilePaths)
         {
             // If there is some MSBuild logic that needs to run to fully resolve the path skip the project
             if (File.Exists(projectFullPath))
             {
-                await RunForProjectAsync(repoRootPath, projectFullPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
+                var projectResult = await RunForProjectAsync(repoRootPath, projectFullPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
+                updateOperations.AddRange(projectResult.UpdateOperations);
             }
         }
+
+        return new UpdateOperationResult()
+        {
+            UpdateOperations = updateOperations.ToImmutableArray(),
+        };
     }
 
-    private async Task RunForProjectAsync(
+    private async Task<UpdateOperationResult> RunForProjectAsync(
         string repoRootPath,
         string projectPath,
         string dependencyName,
@@ -163,21 +203,31 @@ public class UpdaterWorker : IUpdaterWorker
         if (!File.Exists(projectPath))
         {
             _logger.Info($"File [{projectPath}] does not exist.");
-            return;
+            return new UpdateOperationResult()
+            {
+                UpdateOperations = [],
+            };
         }
 
+        var updateOperations = new List<UpdateOperationBase>();
         var projectFilePaths = MSBuildHelper.GetProjectPathsFromProject(projectPath);
         foreach (var projectFullPath in projectFilePaths.Concat([projectPath]))
         {
             // If there is some MSBuild logic that needs to run to fully resolve the path skip the project
             if (File.Exists(projectFullPath))
             {
-                await RunUpdaterAsync(repoRootPath, projectFullPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
+                var performedOperations = await RunUpdaterAsync(repoRootPath, projectFullPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
+                updateOperations.AddRange(performedOperations);
             }
         }
+
+        return new UpdateOperationResult()
+        {
+            UpdateOperations = updateOperations.ToImmutableArray(),
+        };
     }
 
-    private async Task RunUpdaterAsync(
+    private async Task<IEnumerable<UpdateOperationBase>> RunUpdaterAsync(
         string repoRootPath,
         string projectPath,
         string dependencyName,
@@ -187,22 +237,25 @@ public class UpdaterWorker : IUpdaterWorker
     {
         if (_processedProjectPaths.Contains(projectPath))
         {
-            return;
+            return [];
         }
 
         _processedProjectPaths.Add(projectPath);
 
         _logger.Info($"Updating project [{projectPath}]");
 
+        var updateOperations = new List<UpdateOperationBase>();
         var additionalFiles = ProjectHelper.GetAllAdditionalFilesFromProject(projectPath, ProjectHelper.PathFormat.Full);
         var packagesConfigFullPath = additionalFiles.Where(p => Path.GetFileName(p).Equals(ProjectHelper.PackagesConfigFileName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
         if (packagesConfigFullPath is not null)
         {
-            await PackagesConfigUpdater.UpdateDependencyAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, packagesConfigFullPath, _logger);
+            var packagesConfigOperations = await PackagesConfigUpdater.UpdateDependencyAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, packagesConfigFullPath, _logger);
+            updateOperations.AddRange(packagesConfigOperations);
         }
 
         // Some repos use a mix of packages.config and PackageReference
-        await PackageReferenceUpdater.UpdateDependencyAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive, _experimentsManager, _logger);
+        var packageReferenceOperations = await PackageReferenceUpdater.UpdateDependencyAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive, _experimentsManager, _logger);
+        updateOperations.AddRange(packageReferenceOperations);
 
         // Update lock file if exists
         var packagesLockFullPath = additionalFiles.Where(p => Path.GetFileName(p).Equals(ProjectHelper.PackagesLockJsonFileName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
@@ -210,5 +263,7 @@ public class UpdaterWorker : IUpdaterWorker
         {
             await LockFileUpdater.UpdateLockFileAsync(repoRootPath, projectPath, _experimentsManager, _logger);
         }
+
+        return updateOperations;
     }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Utilities/MSBuildHelper.cs

@@ -341,7 +341,7 @@ internal static partial class MSBuildHelper
         return false;
     }
 
-    internal static async Task<bool> DependenciesAreCoherentAsync(string repoRoot, string projectPath, string targetFramework, Dependency[] packages, ExperimentsManager experimentsManager, ILogger logger)
+    internal static async Task<bool> DependenciesAreCoherentAsync(string repoRoot, string projectPath, string targetFramework, ImmutableArray<Dependency> packages, ExperimentsManager experimentsManager, ILogger logger)
     {
         var tempDirectory = Directory.CreateTempSubdirectory("package-dependency-coherence_");
         try
@@ -359,7 +359,7 @@ internal static partial class MSBuildHelper
         }
     }
 
-    internal static async Task<Dependency[]?> ResolveDependencyConflicts(string repoRoot, string projectPath, string targetFramework, Dependency[] packages, Dependency[] update, ExperimentsManager experimentsManager, ILogger logger)
+    internal static async Task<ImmutableArray<Dependency>?> ResolveDependencyConflicts(string repoRoot, string projectPath, string targetFramework, ImmutableArray<Dependency> packages, ImmutableArray<Dependency> update, ExperimentsManager experimentsManager, ILogger logger)
     {
         var tempDirectory = Directory.CreateTempSubdirectory("package-dependency-coherence_");
         PackageManager packageManager = new PackageManager(repoRoot, projectPath);
@@ -477,7 +477,7 @@ internal static partial class MSBuildHelper
             .ToList();
 
             // Return as array
-            Dependency[] candidatePackagesArray = candidatePackages.ToArray();
+            var candidatePackagesArray = candidatePackages.ToImmutableArray();
 
             var targetFrameworks = new NuGetFramework[] { NuGetFramework.Parse(targetFramework) };
 
@@ -517,7 +517,7 @@ internal static partial class MSBuildHelper
         }
     }
 
-    internal static async Task<Dependency[]?> ResolveDependencyConflictsWithBruteForce(string repoRoot, string projectPath, string targetFramework, Dependency[] packages, ExperimentsManager experimentsManager, ILogger logger)
+    internal static async Task<ImmutableArray<Dependency>?> ResolveDependencyConflictsWithBruteForce(string repoRoot, string projectPath, string targetFramework, ImmutableArray<Dependency> packages, ExperimentsManager experimentsManager, ILogger logger)
     {
         var tempDirectory = Directory.CreateTempSubdirectory("package-dependency-coherence_");
         try
@@ -599,7 +599,7 @@ internal static partial class MSBuildHelper
             {
                 // rebuild candidate dependency list with the relevant versions
                 Dictionary<string, NuGetVersion> packageVersions = candidateSet.ToDictionary(candidateSet => candidateSet.PackageName, candidateSet => candidateSet.PackageVersion);
-                Dependency[] candidatePackages = packages.Select(p =>
+                var candidatePackages = packages.Select(p =>
                 {
                     if (packageVersions.TryGetValue(p.Name, out var version))
                     {
@@ -609,7 +609,7 @@ internal static partial class MSBuildHelper
 
                     // not the dependency we're looking for, use whatever it already was in this set
                     return p;
-                }).ToArray();
+                }).ToImmutableArray();
 
                 if (await DependenciesAreCoherentAsync(repoRoot, projectPath, targetFramework, candidatePackages, experimentsManager, logger))
                 {
@@ -748,7 +748,7 @@ internal static partial class MSBuildHelper
                 // empty `Version` attributes will cause the temporary project to not build
                 .Where(p => (p.EvaluationResult is null || p.EvaluationResult.ResultType == EvaluationResultType.Success) && !string.IsNullOrWhiteSpace(p.Version))
                 // If all PackageReferences for a package are update-only mark it as such, otherwise it can cause package incoherence errors which do not exist in the repo.
-                .Select(p => $"<{(usePackageDownload ? "PackageDownload" : "PackageReference")} {(p.IsUpdate ? "Update" : "Include")}=\"{p.Name}\" Version=\"[{p.Version}]\" />"));
+                .Select(p => $"<{(usePackageDownload ? "PackageDownload" : "PackageReference")} {(p.IsUpdate ? "Update" : "Include")}=\"{p.Name}\" Version=\"{(p.Version!.Contains("*") ? p.Version : $"[{p.Version}]")}\" />"));
 
         var dependencyTargetsImport = importDependencyTargets
             ? $"""<Import Project="{GetFileFromRuntimeDirectory("DependencyDiscovery.targets")}" />"""
@@ -880,7 +880,7 @@ internal static partial class MSBuildHelper
         return tfms;
     }
 
-    internal static async Task<Dependency[]> GetAllPackageDependenciesAsync(
+    internal static async Task<ImmutableArray<Dependency>> GetAllPackageDependenciesAsync(
         string repoRoot,
         string projectPath,
         string targetFramework,
@@ -895,14 +895,14 @@ internal static partial class MSBuildHelper
             var topLevelPackagesNames = packages.Select(p => p.Name).ToHashSet(StringComparer.OrdinalIgnoreCase);
             var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages, experimentsManager, logger, importDependencyTargets: !experimentsManager.UseDirectDiscovery);
 
-            Dependency[] allDependencies;
+            ImmutableArray<Dependency> allDependencies;
             if (experimentsManager.UseDirectDiscovery)
             {
                 var projectDiscovery = await SdkProjectDiscovery.DiscoverAsync(repoRoot, tempDirectory.FullName, tempProjectPath, experimentsManager, logger);
                 allDependencies = projectDiscovery
                     .Where(p => p.FilePath == Path.GetFileName(tempProjectPath))
                     .FirstOrDefault()
-                    ?.Dependencies.ToArray() ?? [];
+                    ?.Dependencies.ToImmutableArray() ?? [];
             }
             else
             {
@@ -923,7 +923,7 @@ internal static partial class MSBuildHelper
                             var isTransitive = !topLevelPackagesNames.Contains(PackageName);
                             return new Dependency(PackageName, match.Groups["PackageVersion"].Value, DependencyType.Unknown, TargetFrameworks: tfms, IsTransitive: isTransitive);
                         })
-                        .ToArray();
+                        .ToImmutableArray();
                 }
                 else
                 {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Discover/DiscoveryWorkerTests.PackagesConfig.cs

@@ -176,13 +176,13 @@ public partial class DiscoveryWorkerTests
         public async Task DirectDiscoveryWorksEvenWithTargetsImportsOnlyProvidedByVisualStudio()
         {
             await TestDiscoveryAsync(
-                workspacePath: "",
+                workspacePath: "project1/",
                 experimentsManager: new ExperimentsManager() { UseDirectDiscovery = true },
                 packages: [
                     MockNuGetPackage.CreateSimplePackage("Some.Package", "1.0.0", "net48"),
                 ],
                 files: [
-                    ("project.csproj", """
+                    ("project1/project1.csproj", """
                         <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
                           <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
                           <PropertyGroup>
@@ -192,24 +192,38 @@ public partial class DiscoveryWorkerTests
                           <ItemGroup>
                             <None Include="packages.config" />
                           </ItemGroup>
+                          <ItemGroup>
+                            <ProjectReference Include="..\project2\project2.csproj" />
+                          </ItemGroup>
                           <Import Project="$(VSToolsPath)\SomeSubPath\WebApplications\Microsoft.WebApplication.targets" />
                           <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
                         </Project>
                         """),
-                    ("packages.config", """
+                    ("project1/packages.config", """
                         <?xml version="1.0" encoding="utf-8"?>
                         <packages>
                           <package id="Some.Package" version="1.0.0" targetFramework="net48" />
                         </packages>
+                        """),
+                    ("project2/project2.csproj", """
+                        <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+                          <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+                          <PropertyGroup>
+                            <OutputType>Library</OutputType>
+                            <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
+                          </PropertyGroup>
+                          <Import Project="$(VSToolsPath)\SomeSubPath\WebApplications\Microsoft.WebApplication.targets" />
+                          <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+                        </Project>
                         """)
                 ],
                 expectedResult: new()
                 {
-                    Path = "",
+                    Path = "project1/",
                     Projects = [
                         new()
                         {
-                            FilePath = "project.csproj",
+                            FilePath = "project1.csproj",
                             Properties = [],
                             TargetFrameworks = ["net48"],
                             Dependencies = [