dependabot-nuget 0.349.0 → 0.350.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3531f3d69297e8b0afd369fd0757932875c0674b2f0d942f92f9295f868264eb
-  data.tar.gz: 8f62b4d3b6a2bade7ad801141bf4c720dbde9b1af7255ff7ba61f255d3fb746e
+  metadata.gz: 784c940d61ac0b10f0d1b6516c7b33bbaa6e8de03da294ee43245746303e24bb
+  data.tar.gz: 6fddc772c732c7a21c56121fdf90f35d668cc6ce3c5662ae134d6060ae55f291
 SHA512:
-  metadata.gz: 9e28bc682a07a3959675d2b831a78be6dabb1065af1b7db0f1b78dc34b2c68d7b42e6b3eda8ec41e268ed9d0facf578b6c54b21658f2dc5857a62f9f2080b2a4
-  data.tar.gz: 2236ac46be0f2606d395e6e90194329c49da81ec3feba63cf0560ff7e077ee2f64ae072fbe73cf2848781831a760608f5f9eabbb77ba47d48434b82f23b952f1
+  metadata.gz: 82b32710529925d9392c82d7403ad91eea8445f3ef734190a1175ed56a60bd9a2f338f7066956c5074f1478e4f57ff36b94a1670fabc77a068a8362aee442bf7
+  data.tar.gz: 6b5c2ed6e27c43f1c9f264a6dd749f42fc71018e308a66484aa6aa734dfa232e845be87c75797cb0f8cff8a54e71f164f56fb07394faf7ac0fdcfc776713f007

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/DiscoveryWorker.cs

@@ -174,7 +174,7 @@ public partial class DiscoveryWorker : IDiscoveryWorker
         ImmutableArray<string> projects;
         try
         {
-            projects = await ExpandEntryPointsIntoProjectsAsync(entryPoints);
+            projects = await ExpandEntryPointsIntoProjectsAsync(entryPoints, _experimentsManager);
         }
         catch (InvalidProjectFileException e)
         {
@@ -222,10 +222,10 @@ public partial class DiscoveryWorker : IDiscoveryWorker
             .ToImmutableArray();
     }
 
-    private async static Task<ImmutableArray<string>> ExpandEntryPointsIntoProjectsAsync(IEnumerable<string> entryPoints)
+    private async static Task<ImmutableArray<string>> ExpandEntryPointsIntoProjectsAsync(IEnumerable<string> entryPoints, ExperimentsManager experimentsManager)
     {
-        HashSet<string> expandedProjects = new();
-        HashSet<string> seenProjects = new();
+        HashSet<string> expandedProjects = new(PathComparer.Instance);
+        HashSet<string> seenProjects = new(PathComparer.Instance);
         Stack<string> filesToExpand = new(entryPoints);
         while (filesToExpand.Count > 0)
         {
@@ -252,31 +252,51 @@ public partial class DiscoveryWorker : IDiscoveryWorker
                         filesToExpand.Push(projectPath);
                     }
                 }
-                else if (extension == ".proj")
-                {
-                    IEnumerable<string> foundProjects = ExpandItemGroupFilesFromProject(candidateEntryPoint, "ProjectFile", "ProjectReference");
-                    foreach (string foundProject in foundProjects)
-                    {
-                        filesToExpand.Push(foundProject);
-                    }
-                }
-                else
+
+                if (experimentsManager.UseSingleRestore)
                 {
+                    // projects get shunted directly to the result because regular discovery handles it from there
                     switch (extension)
                     {
+                        case ".proj":
                         case ".csproj":
+                        case ".fbproj":
                         case ".fsproj":
-                        case ".vbproj":
-                            // keep this project and check for references
                             expandedProjects.Add(candidateEntryPoint);
-                            IEnumerable<string> referencedProjects = ExpandItemGroupFilesFromProject(candidateEntryPoint, "ProjectReference");
-                            foreach (string referencedProject in referencedProjects)
-                            {
-                                filesToExpand.Push(referencedProject);
-                            }
                             break;
                         default:
-                            continue;
+                            // unsupported project
+                            break;
+                    }
+                }
+                else
+                {
+                    if (extension == ".proj")
+                    {
+                        IEnumerable<string> foundProjects = ExpandItemGroupFilesFromProject(candidateEntryPoint, "ProjectFile", "ProjectReference");
+                        foreach (string foundProject in foundProjects)
+                        {
+                            filesToExpand.Push(foundProject);
+                        }
+                    }
+                    else
+                    {
+                        switch (extension)
+                        {
+                            case ".csproj":
+                            case ".fsproj":
+                            case ".vbproj":
+                                // keep this project and check for references
+                                expandedProjects.Add(candidateEntryPoint);
+                                IEnumerable<string> referencedProjects = ExpandItemGroupFilesFromProject(candidateEntryPoint, "ProjectReference");
+                                foreach (string referencedProject in referencedProjects)
+                                {
+                                    filesToExpand.Push(referencedProject);
+                                }
+                                break;
+                            default:
+                                continue;
+                        }
                     }
                 }
             }
@@ -329,6 +349,26 @@ public partial class DiscoveryWorker : IDiscoveryWorker
 
         try
         {
+            // get all packages.config results first
+            var expandedProjects = await ExpandEntryPointsIntoProjectsAsync(normalizedProjectPaths, _experimentsManager);
+            foreach (var expandedProject in expandedProjects)
+            {
+                var packagesConfigResult = await PackagesConfigDiscovery.Discover(repoRootPath, workspacePath, expandedProject, _logger);
+                if (packagesConfigResult is not null)
+                {
+                    var relativeProjectPath = Path.GetRelativePath(workspacePath, expandedProject).NormalizePathToUnix();
+                    results[relativeProjectPath] = new ProjectDiscoveryResult()
+                    {
+                        FilePath = relativeProjectPath,
+                        Dependencies = packagesConfigResult.Dependencies,
+                        TargetFrameworks = packagesConfigResult.TargetFrameworks,
+                        ImportedFiles = [], // no imported files resolved for packages.config scenarios
+                        AdditionalFiles = packagesConfigResult.AdditionalFiles,
+                    };
+                }
+            }
+
+            // now check all sdk projects
             foreach (var projectPath in normalizedProjectPaths)
             {
                 if (_processedProjectPaths.Contains(projectPath))
@@ -339,8 +379,7 @@ public partial class DiscoveryWorker : IDiscoveryWorker
                 _processedProjectPaths.Add(projectPath);
 
                 var relativeProjectPath = Path.GetRelativePath(workspacePath, projectPath).NormalizePathToUnix();
-                var packagesConfigResult = await PackagesConfigDiscovery.Discover(repoRootPath, workspacePath, projectPath, _logger);
-                var projectResults = await SdkProjectDiscovery.DiscoverAsync(repoRootPath, workspacePath, projectPath, _logger);
+                var projectResults = await SdkProjectDiscovery.DiscoverAsync(repoRootPath, workspacePath, projectPath, _experimentsManager, _logger);
 
                 // Determine if there were unrestored MSBuildSdks
                 var msbuildSdks = projectResults.SelectMany(p => p.Dependencies.Where(d => d.Type == DependencyType.MSBuildSdk)).ToImmutableArray();
@@ -349,46 +388,25 @@ public partial class DiscoveryWorker : IDiscoveryWorker
                     // If new SDKs were restored, then we need to rerun SdkProjectDiscovery.
                     if (await TryRestoreMSBuildSdksAsync(repoRootPath, workspacePath, msbuildSdks, _logger))
                     {
-                        projectResults = await SdkProjectDiscovery.DiscoverAsync(repoRootPath, workspacePath, projectPath, _logger);
+                        projectResults = await SdkProjectDiscovery.DiscoverAsync(repoRootPath, workspacePath, projectPath, _experimentsManager, _logger);
                     }
                 }
 
                 foreach (var projectResult in projectResults)
                 {
-                    if (results.ContainsKey(projectResult.FilePath))
-                    {
-                        continue;
-                    }
-
                     // If we had packages.config dependencies, merge them with the project dependencies
-                    if (projectResult.FilePath == relativeProjectPath && packagesConfigResult is not null)
+                    if (results.TryGetValue(projectResult.FilePath, out var packagesConfigResult))
                     {
                         var packagesConfigDependencies = packagesConfigResult.Dependencies
                             .Select(d => d with { TargetFrameworks = projectResult.TargetFrameworks })
                             .ToImmutableArray();
 
-                        results[projectResult.FilePath] = projectResult with
-                        {
-                            Dependencies = [.. projectResult.Dependencies, .. packagesConfigDependencies],
-                        };
-                    }
-                    else
-                    {
-                        results[projectResult.FilePath] = projectResult;
-                    }
-                }
-
-                if (packagesConfigResult is not null)
-                {
-                    // we might have to merge this dependency with some others
-                    if (results.TryGetValue(relativeProjectPath, out var existingProjectDiscovery))
-                    {
                         // merge SDK and packages.config results
-                        var mergedDependencies = existingProjectDiscovery.Dependencies.Concat(packagesConfigResult.Dependencies)
+                        var mergedDependencies = projectResult.Dependencies.Concat(packagesConfigResult.Dependencies)
                             .DistinctBy(d => d.Name, StringComparer.OrdinalIgnoreCase)
                             .OrderBy(d => d.Name)
                             .ToImmutableArray();
-                        var mergedTargetFrameworks = existingProjectDiscovery.TargetFrameworks.Concat(packagesConfigResult.TargetFrameworks)
+                        var mergedTargetFrameworks = projectResult.TargetFrameworks.Concat(packagesConfigResult.TargetFrameworks)
                             .Select(t =>
                             {
                                 try
@@ -405,34 +423,27 @@ public partial class DiscoveryWorker : IDiscoveryWorker
                             .Distinct()
                             .OrderBy(tfm => tfm)
                             .ToImmutableArray();
-                        var mergedProperties = existingProjectDiscovery.Properties; // packages.config discovery doesn't produce properties
-                        var mergedImportedFiles = existingProjectDiscovery.ImportedFiles; // packages.config discovery doesn't produce imported files
-                        var mergedAdditionalFiles = existingProjectDiscovery.AdditionalFiles.Concat(packagesConfigResult.AdditionalFiles)
+                        var mergedProperties = projectResult.Properties; // packages.config discovery doesn't produce properties
+                        var mergedImportedFiles = projectResult.ImportedFiles; // packages.config discovery doesn't produce imported files
+                        var mergedAdditionalFiles = projectResult.AdditionalFiles.Concat(packagesConfigResult.AdditionalFiles)
                             .Distinct(StringComparer.OrdinalIgnoreCase)
                             .OrderBy(f => f)
                             .ToImmutableArray();
                         var mergedResult = new ProjectDiscoveryResult()
                         {
-                            FilePath = existingProjectDiscovery.FilePath,
+                            FilePath = projectResult.FilePath,
                             Dependencies = mergedDependencies,
                             TargetFrameworks = mergedTargetFrameworks,
                             Properties = mergedProperties,
                             ImportedFiles = mergedImportedFiles,
                             AdditionalFiles = mergedAdditionalFiles,
                         };
-                        results[relativeProjectPath] = mergedResult;
+                        results[projectResult.FilePath] = mergedResult;
                     }
                     else
                     {
-                        // add packages.config results
-                        results[relativeProjectPath] = new ProjectDiscoveryResult()
-                        {
-                            FilePath = relativeProjectPath,
-                            Dependencies = packagesConfigResult.Dependencies,
-                            TargetFrameworks = packagesConfigResult.TargetFrameworks,
-                            ImportedFiles = [], // no imported files resolved for packages.config scenarios
-                            AdditionalFiles = packagesConfigResult.AdditionalFiles,
-                        };
+                        // nothing to merge, just set it
+                        results[projectResult.FilePath] = projectResult;
                     }
                 }
             }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/SdkProjectDiscovery.cs

@@ -53,8 +53,24 @@ internal static class SdkProjectDiscovery
         "web.config",
     };
 
-    public static async Task<ImmutableArray<ProjectDiscoveryResult>> DiscoverAsync(string repoRootPath, string workspacePath, string startingProjectPath, ILogger logger)
+    // these are the targets that are necessary to evaluate for a single restore operation
+    private static readonly ImmutableArray<string> SingleRestoreTargetNames =
+    [
+        "Restore",
+        "ResolveProjectReferences",
+        "ResolvePackageAssets"
+    ];
+
+    public static async Task<ImmutableArray<ProjectDiscoveryResult>> DiscoverAsync(string repoRootPath, string workspacePath, string startingProjectPath, ExperimentsManager experimentsManager, ILogger logger)
     {
+        var extension = Path.GetExtension(startingProjectPath)?.ToLowerInvariant();
+        switch (extension)
+        {
+            case ".sln":
+            case ".slnx":
+                throw new NotSupportedException("SDK discovery can't be directly called on a solution file.");
+        }
+
         // N.b., there are many paths used in this function.  The MSBuild binary log always reports fully qualified paths, so that's what will be used
         // throughout until the very end when the appropriate kind of relative path is returned.
 
@@ -91,8 +107,10 @@ internal static class SdkProjectDiscovery
         //    projectPath  additionalFiles
 
         var requiresManualPackageResolution = false;
-        var tfms = await MSBuildHelper.GetTargetFrameworkValuesFromProject(repoRootPath, startingProjectPath, logger);
-        foreach (var tfm in tfms)
+        var discoveredTfms = experimentsManager.UseSingleRestore
+            ? ["unused-for-single-restore"] // we need to ensure we do the following just once because it'll restore all relevant projects
+            : await MSBuildHelper.GetTargetFrameworkValuesFromProject(repoRootPath, startingProjectPath, logger);
+        foreach (var discoveredTfm in discoveredTfms)
         {
             // create a binlog
             var binLogPath = Path.Combine(Path.GetTempPath(), $"msbuild_{Guid.NewGuid():d}.binlog");
@@ -106,14 +124,36 @@ internal static class SdkProjectDiscovery
                     "build",
                     startingProjectPath,
                     "/t:_DiscoverDependencies",
-                    $"/p:TargetFramework={tfm}",
+                    $"/p:TargetFramework={discoveredTfm}",
                     $"/p:CustomBeforeMicrosoftCommonProps={dependencyDiscoveryTargetingPacksPropsPath}",
                     $"/p:CustomAfterMicrosoftCommonCrossTargetingTargets={dependencyDiscoveryTargetsPath}",
                     $"/p:CustomAfterMicrosoftCommonTargets={dependencyDiscoveryTargetsPath}",
-                    "/p:TreatWarningsAsErrors=false", // if using CPM and a project also sets TreatWarningsAsErrors to true, this can cause discovery to fail; explicitly don't allow that
-                    "/p:MSBuildTreatWarningsAsErrors=false",
-                    $"/bl:{binLogPath}"
                 };
+
+                if (experimentsManager.UseSingleRestore)
+                {
+                    // when using single restore, we can directly invoke the relevant targets
+                    args = ["msbuild", startingProjectPath];
+                    var targets = await MSBuildHelper.GetProjectTargetsAsync(startingProjectPath, logger);
+                    var useDirectRestore = SingleRestoreTargetNames.All(targets.Contains);
+                    if (useDirectRestore)
+                    {
+                        // directly call the required targets
+                        args.Add($"/t:{string.Join(",", SingleRestoreTargetNames)}");
+                    }
+                    else
+                    {
+                        // delegate to the inner build and call those targets
+                        args.Add("/t:Build");
+                        args.Add($"/p:InnerTargets=\"{string.Join(";", SingleRestoreTargetNames)}\"");
+                    }
+                }
+
+                // if using CPM and a project also sets TreatWarningsAsErrors to true, this can cause discovery to fail; explicitly don't allow that
+                args.Add("/p:TreatWarningsAsErrors=false");
+                args.Add("/p:MSBuildTreatWarningsAsErrors=false");
+                args.Add($"/bl:{binLogPath}");
+
                 var (exitCode, stdOut, stdErr) = await ProcessEx.RunDotnetWithoutMSBuildEnvironmentVariablesAsync(args, startingProjectDirectory);
                 if (exitCode != 0 && stdOut.Contains("error : Object reference not set to an instance of an object."))
                 {
@@ -249,6 +289,12 @@ internal static class SdkProjectDiscovery
                                     break;
                                 }
 
+                                var evaluatedTfm = GetPropertyValueFromProjectEvaluation(projectEvaluation, "TargetFramework");
+                                if (evaluatedTfm is null)
+                                {
+                                    break;
+                                }
+
                                 var removedReferences = target.Children.OfType<RemoveItem>().FirstOrDefault(r => r.Name == "Reference");
                                 var addedReferences = target.Children.OfType<AddItem>().FirstOrDefault(r => r.Name == "Reference");
                                 if (removedReferences is null || addedReferences is null)
@@ -266,7 +312,7 @@ internal static class SdkProjectDiscovery
                                     }
 
                                     var existingProjectPackagesByTfm = packagesPerProject.GetOrAdd(projectEvaluation.ProjectFile, () => new(PathComparer.Instance));
-                                    var existingProjectPackages = existingProjectPackagesByTfm.GetOrAdd(tfm, () => new(StringComparer.OrdinalIgnoreCase));
+                                    var existingProjectPackages = existingProjectPackagesByTfm.GetOrAdd(evaluatedTfm, () => new(StringComparer.OrdinalIgnoreCase));
                                     if (!existingProjectPackages.ContainsKey(removedPackageName))
                                     {
                                         continue;
@@ -296,7 +342,7 @@ internal static class SdkProjectDiscovery
                                     }
 
                                     var packagesPerThisProject = packagesReplacedBySdkPerProject.GetOrAdd(projectEvaluation.ProjectFile, () => new(PathComparer.Instance));
-                                    var packagesPerTfm = packagesPerThisProject.GetOrAdd(tfm, () => new(StringComparer.OrdinalIgnoreCase));
+                                    var packagesPerTfm = packagesPerThisProject.GetOrAdd(evaluatedTfm, () => new(StringComparer.OrdinalIgnoreCase));
                                     packagesPerTfm[removedPackageName] = replacementPackageVersion.ToString();
                                     var relativeProjectPath = Path.GetRelativePath(repoRootPath, projectEvaluation.ProjectFile).NormalizePathToUnix();
                                     logger.Info($"Re-added SDK managed package [{removedPackageName}/{replacementPackageVersion}] to project [{relativeProjectPath}]");
@@ -330,9 +376,10 @@ internal static class SdkProjectDiscovery
             packagesPerProject = await RebuildPackagesPerProject(
                 repoRootPath,
                 startingProjectPath,
-                tfms,
+                discoveredTfms,
                 packagesPerProject,
                 explicitPackageVersionsPerProject,
+                experimentsManager,
                 logger
             );
         }
@@ -557,6 +604,7 @@ internal static class SdkProjectDiscovery
         ImmutableArray<string> targetFrameworks,
         Dictionary<string, Dictionary<string, Dictionary<string, string>>> packagesPerProject,
         Dictionary<string, Dictionary<string, Dictionary<string, string>>> explicitPackageVersionsPerProject,
+        ExperimentsManager experimentsManager,
         ILogger logger
     )
     {
@@ -573,7 +621,7 @@ internal static class SdkProjectDiscovery
 
             var tempProjectPath = await MSBuildHelper.CreateTempProjectAsync(tempDirectory, repoRootPath, projectPath, targetFrameworks, topLevelDependencies, logger);
             var tempProjectDirectory = Path.GetDirectoryName(tempProjectPath)!;
-            var rediscoveredDependencies = await DiscoverAsync(tempProjectDirectory, tempProjectDirectory, tempProjectPath, logger);
+            var rediscoveredDependencies = await DiscoverAsync(tempProjectDirectory, tempProjectDirectory, tempProjectPath, experimentsManager, logger);
             var rediscoveredDependenciesForThisProject = rediscoveredDependencies.Single(); // we started with a single temp project, this will be the only result
 
             // re-build packagesPerProject

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/ExperimentsManager.cs

@@ -8,12 +8,14 @@ namespace NuGetUpdater.Core;
 public record ExperimentsManager
 {
     public bool GenerateSimplePrBody { get; init; } = false;
+    public bool UseSingleRestore { get; init; } = false;
 
     public Dictionary<string, object> ToDictionary()
     {
         return new()
         {
             ["nuget_generate_simple_pr_body"] = GenerateSimplePrBody,
+            ["nuget_use_single_restore"] = UseSingleRestore,
         };
     }
 
@@ -22,6 +24,7 @@ public record ExperimentsManager
         return new ExperimentsManager()
         {
             GenerateSimplePrBody = IsEnabled(experiments, "nuget_generate_simple_pr_body"),
+            UseSingleRestore = IsEnabled(experiments, "nuget_use_single_restore"),
         };
     }
 

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

@@ -493,7 +493,8 @@ internal static partial class MSBuildHelper
             var topLevelPackagesNames = packages.Select(p => p.Name).ToHashSet(StringComparer.OrdinalIgnoreCase);
             var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages, logger, importDependencyTargets: false);
 
-            var projectDiscovery = await SdkProjectDiscovery.DiscoverAsync(repoRoot, tempDirectory.FullName, tempProjectPath, logger);
+            var experimentsManager = new ExperimentsManager() { UseSingleRestore = false }; // single restore is meaningless here
+            var projectDiscovery = await SdkProjectDiscovery.DiscoverAsync(repoRoot, tempDirectory.FullName, tempProjectPath, experimentsManager, logger);
             var allDependencies = projectDiscovery
                 .Where(p => p.FilePath == Path.GetFileName(tempProjectPath))
                 .FirstOrDefault()
@@ -513,6 +514,37 @@ internal static partial class MSBuildHelper
         }
     }
 
+    public static async Task<HashSet<string>> GetProjectTargetsAsync(string projectPath, ILogger logger)
+    {
+        var extension = Path.GetExtension(projectPath)?.ToLowerInvariant();
+        if (extension == ".sln" || extension == ".slnx")
+        {
+            // solution files don't specify targets, so we can skip the process invocation
+            return [];
+        }
+
+        var projectDirectory = Path.GetDirectoryName(projectPath)!;
+        var args = new[]
+        {
+            "msbuild",
+            projectPath,
+            "-targets"
+        };
+        var (exitCode, stdOut, stdErr) = await ProcessEx.RunDotnetWithoutMSBuildEnvironmentVariablesAsync(args, projectDirectory);
+        if (exitCode != 0)
+        {
+            logger.Warn($"Unable to determine targets for project [{projectPath}]:\nSTDOUT:\n{stdOut}\nSTDERR:\n{stdErr}\n");
+            return [];
+        }
+
+        var targets = stdOut.Split('\n')
+            .Skip(1) // first line is msbuild info
+            .Select(l => l.Trim())
+            .Where(l => !string.IsNullOrEmpty(l))
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+        return targets;
+    }
+
     internal static string? GetMissingFile(string output)
     {
         var missingFilePatterns = new[]

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

@@ -8,7 +8,11 @@ public static class ProcessEx
     /// <summary>
     /// Run the `dotnet` command with the given values.  This will exclude all `MSBuild*` environment variables from the execution.
     /// </summary>
-    public static Task<(int ExitCode, string Output, string Error)> RunDotnetWithoutMSBuildEnvironmentVariablesAsync(IEnumerable<string> arguments, string workingDirectory)
+    public static Task<(int ExitCode, string Output, string Error)> RunDotnetWithoutMSBuildEnvironmentVariablesAsync(
+        IEnumerable<string> arguments,
+        string workingDirectory,
+        IEnumerable<(string Name, string? Value)>? extraEnvironmentVariables = null
+    )
     {
         // When using the SDK specified by a `global.json` file, these environment variables need to be unset to
         // allow the new process to discover the correct MSBuild binaries to load, and not load the ones that
@@ -24,6 +28,11 @@ public static class ProcessEx
         };
 
         var environmentVariableOverrides = environmentVariablesToUnset.Select(name => (name, (string?)null));
+        if (extraEnvironmentVariables is not null)
+        {
+            environmentVariableOverrides = environmentVariableOverrides.Concat(extraEnvironmentVariables);
+        }
+
         return RunAsync("dotnet",
             arguments,
             workingDirectory,

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

@@ -61,10 +61,13 @@ public partial class DiscoveryWorkerTests
             );
         }
 
-        [Fact]
-        public async Task DiscoveryIsMergedWithPackageReferences()
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public async Task DiscoveryIsMergedWithPackageReferences(bool useSingleRestore)
         {
             await TestDiscoveryAsync(
+                experimentsManager: new ExperimentsManager() { UseSingleRestore = useSingleRestore },
                 packages:
                 [
                     MockNuGetPackage.CreateSimplePackage("Package.A", "1.0.0", "net46"),

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

@@ -163,10 +163,13 @@ public partial class DiscoveryWorkerTests : DiscoveryWorkerTestBase
         );
     }
 
-    [Fact]
-    public async Task TestDependenciesSeparatedBySemicolon()
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task TestDependenciesSeparatedBySemicolon(bool useSingleRestore)
     {
         await TestDiscoveryAsync(
+            experimentsManager: new ExperimentsManager() { UseSingleRestore = useSingleRestore },
             packages:
             [
                 MockNuGetPackage.CreateSimplePackage("Some.Package", "9.0.1", "net8.0"),
@@ -368,9 +371,10 @@ public partial class DiscoveryWorkerTests : DiscoveryWorkerTestBase
     [Theory]
     [InlineData(true)]
     [InlineData(false)]
-    public async Task TestPackageConfig(bool useDirectDiscovery)
+    public async Task TestPackageConfig(bool useSingleRestore)
     {
         await TestDiscoveryAsync(
+            experimentsManager: new ExperimentsManager() { UseSingleRestore = useSingleRestore },
             packages:
             [
                 MockNuGetPackage.CreateSimplePackage("Some.Package", "7.0.1", "net45"),
@@ -487,11 +491,14 @@ public partial class DiscoveryWorkerTests : DiscoveryWorkerTestBase
         );
     }
 
-    [Fact]
-    public async Task TestRepo()
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task TestRepo(bool useSingleRestore)
     {
         var solutionPath = "solution.sln";
         await TestDiscoveryAsync(
+            experimentsManager: new ExperimentsManager() { UseSingleRestore = useSingleRestore },
             packages:
             [
                 MockNuGetPackage.CreateSimplePackage("Some.Package", "9.0.1", "net7.0"),
@@ -617,11 +624,110 @@ public partial class DiscoveryWorkerTests : DiscoveryWorkerTestBase
         );
     }
 
-    [Fact]
-    public async Task TestRepo_DirectDiscovery_Slnx()
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task TestRepo_Sln(bool useSingleRestore)
+    {
+        await TestDiscoveryAsync(
+            experimentsManager: new ExperimentsManager() { UseSingleRestore = useSingleRestore },
+            packages: [
+                MockNuGetPackage.CreateSimplePackage("Package.A", "1.2.3", "net8.0"),
+                MockNuGetPackage.CreateSimplePackage("Package.B", "4.5.6", "net8.0"),
+            ],
+            workspacePath: "src",
+            files: [
+                ("src/solution.sln", """
+                    Microsoft Visual Studio Solution File, Format Version 12.00
+                    # Visual Studio 14
+                    VisualStudioVersion = 14.0.22705.0
+                    MinimumVisualStudioVersion = 10.0.40219.1
+                    Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Project.A", "client\client.csproj", "{782E0C0A-10D3-444D-9640-263D03D2B20C}"
+                    EndProject
+                    Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Project.B", "server\server.csproj", "{782E0C0A-10D3-444D-9640-263D03D2B20D}"
+                    EndProject
+                    Global
+                      GlobalSection(SolutionConfigurationPlatforms) = preSolution
+                        Debug|Any CPU = Debug|Any CPU
+                        Release|Any CPU = Release|Any CPU
+                      EndGlobalSection
+                      GlobalSection(ProjectConfigurationPlatforms) = postSolution
+                        {782E0C0A-10D3-444D-9640-263D03D2B20C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+                        {782E0C0A-10D3-444D-9640-263D03D2B20C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+                        {782E0C0A-10D3-444D-9640-263D03D2B20C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+                        {782E0C0A-10D3-444D-9640-263D03D2B20C}.Release|Any CPU.Build.0 = Release|Any CPU
+                        {782E0C0A-10D3-444D-9640-263D03D2B20D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+                        {782E0C0A-10D3-444D-9640-263D03D2B20D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+                        {782E0C0A-10D3-444D-9640-263D03D2B20D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+                        {782E0C0A-10D3-444D-9640-263D03D2B20D}.Release|Any CPU.Build.0 = Release|Any CPU
+                      EndGlobalSection
+                      GlobalSection(SolutionProperties) = preSolution
+                        HideSolutionNode = FALSE
+                      EndGlobalSection
+                    EndGlobal
+                    """),
+                ("src/client/client.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>net8.0</TargetFramework>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="Package.A" Version="1.2.3" />
+                      </ItemGroup>
+                    </Project>
+                    """),
+                ("src/server/server.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>net8.0</TargetFramework>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="Package.B" Version="4.5.6" />
+                      </ItemGroup>
+                    </Project>
+                    """)
+            ],
+            expectedResult: new()
+            {
+                Path = "src",
+                Projects = [
+                    new()
+                    {
+                        FilePath = "client/client.csproj",
+                        TargetFrameworks = ["net8.0"],
+                        Dependencies = [new("Package.A", "1.2.3", DependencyType.PackageReference, IsDirect: true, TargetFrameworks: ["net8.0"])],
+                        Properties = [
+                            new("TargetFramework", "net8.0", "src/client/client.csproj"),
+                        ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
+                    },
+                    new()
+                    {
+                        FilePath = "server/server.csproj",
+                        TargetFrameworks = ["net8.0"],
+                        Dependencies = [new("Package.B", "4.5.6", DependencyType.PackageReference, IsDirect: true, TargetFrameworks: ["net8.0"])],
+                        Properties = [
+                            new("TargetFramework", "net8.0", "src/server/server.csproj"),
+                        ],
+                        ReferencedProjectPaths = [],
+                        ImportedFiles = [],
+                        AdditionalFiles = [],
+                    }
+                ]
+            }
+        );
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task TestRepo_Slnx(bool useSingleRestore)
     {
         var solutionPath = "solution.slnx";
         await TestDiscoveryAsync(
+            experimentsManager: new ExperimentsManager() { UseSingleRestore = useSingleRestore },
             packages:
             [
                 MockNuGetPackage.CreateSimplePackage("Some.Package", "9.0.1", "net7.0"),

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Discover/SdkProjectDiscoveryTests.cs

@@ -587,6 +587,7 @@ public class SdkProjectDiscoveryTests : DiscoveryWorkerTestBase
         // Normally this would cause a restore failure which means discovery would also fail
         // This test ensures we can still run discovery
         await TestDiscoverAsync(
+            useSingleRestore: false,
             packages: [
                 MockNuGetPackage.CreateSimplePackage("Package.A", "1.0.0", "net8.0", [(null, [("Transitive.Package", "2.0.0")])]),
                 MockNuGetPackage.CreateSimplePackage("Transitive.Package", "1.0.0", "net8.0"),
@@ -629,7 +630,136 @@ public class SdkProjectDiscoveryTests : DiscoveryWorkerTestBase
         );
     }
 
-    private static async Task TestDiscoverAsync(string startingDirectory, string projectPath, TestFile[] files, ImmutableArray<ExpectedSdkProjectDiscoveryResult> expectedProjects, MockNuGetPackage[]? packages = null)
+    [Fact]
+    public async Task DependenciesCanBeDiscoveredWithoutCompiling_FromProjectWithSingleTfm()
+    {
+        using var tempDir = new TemporaryDirectory();
+        var errorSentinelPath = Path.Combine(tempDir.DirectoryPath, "error-sentinel.txt");
+        await TestDiscoverAsync(
+            useSingleRestore: true,
+            startingDirectory: "src",
+            packages: [
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "1.0.0", "net8.0"),
+            ],
+            projectPath: "src/project.csproj",
+            files: [
+                ("src/project.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>net8.0</TargetFramework>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="Some.Package" Version="1.0.0" />
+                      </ItemGroup>
+                    </Project>
+                    """),
+                ("src/Directory.Build.props", "<Project />"),
+                ("src/Directory.Packages.props", "<Project />"),
+                ("src/Directory.Build.targets", $"""
+                    <Project>
+                      <Target Name="_TEST_ThisShouldNotExecute_" AfterTargets="CoreCompile">
+                        <WriteLinesToFile File="{errorSentinelPath}" Lines="this should not have happened" Overwrite="true" />
+                      </Target>
+                    </Project>
+                    """),
+            ],
+            expectedProjects: [
+                new()
+                {
+                    FilePath = "project.csproj",
+                    Dependencies =
+                    [
+                        new("Some.Package", "1.0.0", DependencyType.PackageReference, TargetFrameworks: ["net8.0"], IsDirect: true)
+                    ],
+                    ImportedFiles = ["Directory.Build.props", "Directory.Build.targets", "Directory.Packages.props"],
+                    Properties =
+                    [
+                        new("TargetFramework", "net8.0", "src/project.csproj"),
+                    ],
+                    TargetFrameworks = ["net8.0"],
+                    ReferencedProjectPaths = [],
+                    AdditionalFiles = [],
+                },
+            ]
+        );
+        Assert.False(File.Exists(errorSentinelPath), "Build targets should not have executed during discovery");
+    }
+
+    [Fact]
+    public async Task DependenciesCanBeDiscoveredWithoutCompiling_FromProjectWithMultipleTfms()
+    {
+        using var tempDir = new TemporaryDirectory();
+        var errorSentinelPath = Path.Combine(tempDir.DirectoryPath, "error-sentinel.txt");
+        await TestDiscoverAsync(
+            useSingleRestore: true,
+            startingDirectory: "src",
+            packages: [
+                MockNuGetPackage.CreateSimplePackage("Some.Package", "1.0.0", "net8.0"),
+            ],
+            projectPath: "src/project.csproj",
+            files: [
+                ("src/project.csproj", """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="Some.Package" Version="1.0.0" />
+                      </ItemGroup>
+                    </Project>
+                    """),
+                ("src/Directory.Build.props", "<Project />"),
+                ("src/Directory.Packages.props", "<Project />"),
+                ("src/Directory.Build.targets", $"""
+                    <Project>
+                      <Target Name="_TEST_ThisShouldNotExecute_" AfterTargets="CoreCompile">
+                        <WriteLinesToFile File="{errorSentinelPath}" Lines="this should not have happened" Overwrite="true" />
+                      </Target>
+                    </Project>
+                    """),
+            ],
+            expectedProjects: [
+                new()
+                {
+                    FilePath = "project.csproj",
+                    Dependencies =
+                    [
+                        new("Some.Package", "1.0.0", DependencyType.PackageReference, TargetFrameworks: ["net8.0", "net9.0"], IsDirect: true)
+                    ],
+                    ImportedFiles = ["Directory.Build.props", "Directory.Build.targets", "Directory.Packages.props"],
+                    Properties =
+                    [
+                        new("TargetFrameworks", "net8.0;net9.0", "src/project.csproj"),
+                    ],
+                    TargetFrameworks = ["net8.0", "net9.0"],
+                    ReferencedProjectPaths = [],
+                    AdditionalFiles = [],
+                },
+            ]
+        );
+        Assert.False(File.Exists(errorSentinelPath), "Build targets should not have executed during discovery");
+    }
+
+    private static async Task TestDiscoverAsync(
+        string startingDirectory,
+        string projectPath,
+        TestFile[] files,
+        ImmutableArray<ExpectedSdkProjectDiscoveryResult> expectedProjects,
+        MockNuGetPackage[]? packages = null
+    )
+    {
+        await TestDiscoverAsync(useSingleRestore: true, startingDirectory, projectPath, files, expectedProjects, packages);
+        await TestDiscoverAsync(useSingleRestore: false, startingDirectory, projectPath, files, expectedProjects, packages);
+    }
+
+    private static async Task TestDiscoverAsync(
+        bool useSingleRestore,
+        string startingDirectory,
+        string projectPath,
+        TestFile[] files,
+        ImmutableArray<ExpectedSdkProjectDiscoveryResult> expectedProjects,
+        MockNuGetPackage[]? packages = null
+    )
     {
         using var testDirectory = await TemporaryDirectory.CreateWithContentsAsync(files);
 
@@ -637,7 +767,8 @@ public class SdkProjectDiscoveryTests : DiscoveryWorkerTestBase
 
         var logger = new TestLogger();
         var fullProjectPath = Path.Combine(testDirectory.DirectoryPath, projectPath);
-        var projectDiscovery = await SdkProjectDiscovery.DiscoverAsync(testDirectory.DirectoryPath, Path.GetDirectoryName(fullProjectPath)!, fullProjectPath, logger);
+        var experimentsManager = new ExperimentsManager() { UseSingleRestore = useSingleRestore };
+        var projectDiscovery = await SdkProjectDiscovery.DiscoverAsync(testDirectory.DirectoryPath, Path.GetDirectoryName(fullProjectPath)!, fullProjectPath, experimentsManager, logger);
         ValidateProjectResults(expectedProjects, projectDiscovery);
     }
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dependabot-nuget
 version: !ruby/object:Gem::Version
-  version: 0.349.0
+  version: 0.350.0
 platform: ruby
 authors:
 - Dependabot
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.349.0
+        version: 0.350.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.349.0
+        version: 0.350.0
 - !ruby/object:Gem::Dependency
   name: debug
   requirement: !ruby/object:Gem::Requirement
@@ -552,7 +552,7 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/dependabot/dependabot-core/issues
-  changelog_uri: https://github.com/dependabot/dependabot-core/releases/tag/v0.349.0
+  changelog_uri: https://github.com/dependabot/dependabot-core/releases/tag/v0.350.0
 rdoc_options: []
 require_paths:
 - lib