dependabot-nuget 0.252.0 → 0.253.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6658fe5d81acc16548fe2d8fa0aa6ad631e0699588a4595e6b8de2f382a163d8
-  data.tar.gz: 3ced8b77f453319a715b76ccff47787a8798cb92366fe6a86d6894b855a984bf
+  metadata.gz: 272069533f6bea5533fb423db28c745b469884c904e393d9708091398a93f9a3
+  data.tar.gz: dd0c3fad1ab56f2bc32e509f89552068cc59b02cd21b1878ef1edcca84af45ba
 SHA512:
-  metadata.gz: 958fba1507fdc26ec2e0bc3978702b9103543558552c79188e7cca93b85248f46c1d485686da353076fbab234ea150cc1bb7e11231a1765e87071cf068b2e95c
-  data.tar.gz: 5262c02eeff331fbf8c1399ec2d8fc49bd8942f83f2c1d67a4c9f48a3c7515b0f52710cb5e9f1409c23b025719cbb68d6c43ea2db44f15fe9aa353d80a5b1bd8
+  metadata.gz: a66d28929da003117a1a5ef125be1acd2dd91a522f715fa1c263610a63e333e5b60ec3343836a1d19b6516527595b88425aed9f7df7a5c3f254579b1a12ec77c
+  data.tar.gz: 4fa773a0ff8f2c5e423fd505d111eaf7f84439f99111b68a87e77700290ae0ae97d52318ec9ddabc4d5c80e953bdaef761da96730c82baa8f5c0e36034798e3b

data/helpers/lib/NuGetUpdater/NuGetUpdater.Cli.Test/EntryPointTests.Update.cs

@@ -293,22 +293,30 @@ public partial class EntryPointTests
             );
         }
 
-        [Fact]
-        public async Task UpdaterDoesNotUseRepoGlobalJsonForMSBuildTasks()
+        [Theory]
+        [InlineData(null)]
+        [InlineData("src")]
+        public async Task UpdaterDoesNotUseRepoGlobalJsonForMSBuildTasks(string? workingDirectoryPath)
         {
             // This is a _very_ specific scenario where the `NuGetUpdater.Cli` tool might pick up a `global.json` from
             // the root of the repo under test and use it's `sdk` property when trying to locate MSBuild.  To properly
             // test this, it must be tested in a new process where MSBuild has not been loaded yet and the runner tool
             // must be started with its working directory at the test repo's root.
             using var tempDir = new TemporaryDirectory();
-            await File.WriteAllTextAsync(Path.Join(tempDir.DirectoryPath, "global.json"), """
+            var globalJsonPath = Path.Join(tempDir.DirectoryPath, "global.json");
+            var srcGlobalJsonPath = Path.Join(tempDir.DirectoryPath, "src", "global.json");
+            string globalJsonContent = """
                 {
                   "sdk": {
                     "version": "99.99.99"
                   }
                 }
-                """);
-            await File.WriteAllTextAsync(Path.Join(tempDir.DirectoryPath, "project.csproj"), """
+                """;
+            await File.WriteAllTextAsync(globalJsonPath, globalJsonContent);
+            Directory.CreateDirectory(Path.Join(tempDir.DirectoryPath, "src"));
+            await File.WriteAllTextAsync(srcGlobalJsonPath, globalJsonContent);
+            var projectPath = Path.Join(tempDir.DirectoryPath, "src", "project.csproj");
+            await File.WriteAllTextAsync(projectPath, """
                 <Project Sdk="Microsoft.NET.Sdk">
                   <PropertyGroup>
                     <TargetFramework>net8.0</TargetFramework>
@@ -325,7 +333,7 @@ public partial class EntryPointTests
                 "--repo-root",
                 tempDir.DirectoryPath,
                 "--solution-or-project",
-                Path.Join(tempDir.DirectoryPath, "project.csproj"),
+                projectPath,
                 "--dependency",
                 "Newtonsoft.Json",
                 "--new-version",
@@ -336,15 +344,25 @@ public partial class EntryPointTests
             ]);
 
             // verify base run
-            var (exitCode, output, error) = await ProcessEx.RunAsync(executableName, executableArgs, workingDirectory: tempDir.DirectoryPath);
+            var workingDirectory = tempDir.DirectoryPath;
+            if (workingDirectoryPath is not null)
+            {
+                workingDirectory = Path.Join(workingDirectory, workingDirectoryPath);
+            }
+
+            var (exitCode, output, error) = await ProcessEx.RunAsync(executableName, executableArgs, workingDirectory: workingDirectory);
             Assert.True(exitCode == 0, $"Error running update on unsupported SDK.\nSTDOUT:\n{output}\nSTDERR:\n{error}");
 
             // verify project update
-            var updatedProjectContents = await File.ReadAllTextAsync(Path.Join(tempDir.DirectoryPath, "project.csproj"));
+            var updatedProjectContents = await File.ReadAllTextAsync(projectPath);
             Assert.Contains("13.0.1", updatedProjectContents);
 
             // verify `global.json` untouched
-            var updatedGlobalJsonContents = await File.ReadAllTextAsync(Path.Join(tempDir.DirectoryPath, "global.json"));
+            var updatedGlobalJsonContents = await File.ReadAllTextAsync(globalJsonPath);
+            Assert.Contains("99.99.99", updatedGlobalJsonContents);
+
+            // verify `src/global.json` untouched
+            var updatedSrcGlobalJsonContents = await File.ReadAllTextAsync(srcGlobalJsonPath);
             Assert.Contains("99.99.99", updatedGlobalJsonContents);
         }
 

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

@@ -26,7 +26,7 @@ public partial class DiscoveryWorker
 
     public async Task RunAsync(string repoRootPath, string workspacePath, string outputPath)
     {
-        MSBuildHelper.RegisterMSBuild();
+        MSBuildHelper.RegisterMSBuild(Environment.CurrentDirectory, repoRootPath);
 
         // When running under unit tests, the workspace path may not be rooted.
         if (!Path.IsPathRooted(workspacePath) || !Directory.Exists(workspacePath))

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

@@ -9,86 +9,87 @@ internal static class SdkProjectDiscovery
     public static async Task<ImmutableArray<ProjectDiscoveryResult>> DiscoverAsync(string repoRootPath, string workspacePath, string projectPath, Logger logger)
     {
         // Determine which targets and props files contribute to the build.
-        var buildFiles = await MSBuildHelper.LoadBuildFilesAsync(repoRootPath, projectPath, includeSdkPropsAndTargets: true);
+        var (buildFiles, projectTargetFrameworks) = await MSBuildHelper.LoadBuildFilesAndTargetFrameworksAsync(repoRootPath, projectPath);
+        var tfms = projectTargetFrameworks.Order().ToImmutableArray();
 
         // Get all the dependencies which are directly referenced from the project file or indirectly referenced from
         // targets and props files.
         var topLevelDependencies = MSBuildHelper.GetTopLevelPackageDependencyInfos(buildFiles);
 
         var results = ImmutableArray.CreateBuilder<ProjectDiscoveryResult>();
-        foreach (var buildFile in buildFiles)
+        if (tfms.Length > 0)
         {
-            // Only include build files that exist beneath the RepoRootPath.
-            if (buildFile.IsOutsideBasePath)
+            foreach (var buildFile in buildFiles)
             {
-                continue;
-            }
-
-            // The build file dependencies have the correct DependencyType and the TopLevelDependencies have the evaluated version.
-            // Combine them to have the set of dependencies that are directly referenced from the build file.
-            var fileDependencies = BuildFile.GetDependencies(buildFile)
-                .ToDictionary(d => d.Name, StringComparer.OrdinalIgnoreCase);
-            var sdkDependencies = fileDependencies.Values
-                .Where(d => d.Type == DependencyType.MSBuildSdk)
-                .ToImmutableArray();
-            var indirectDependencies = topLevelDependencies
-                .Where(d => !fileDependencies.ContainsKey(d.Name))
-                .ToImmutableArray();
-            var directDependencies = topLevelDependencies
-                .Where(d => fileDependencies.ContainsKey(d.Name))
-                .Select(d =>
+                // Only include build files that exist beneath the RepoRootPath.
+                if (buildFile.IsOutsideBasePath)
                 {
-                    var dependency = fileDependencies[d.Name];
-                    return d with
-                    {
-                        Type = dependency.Type,
-                        IsDirect = true
-                    };
-                }).ToImmutableArray();
-
-            if (buildFile.GetFileType() == ProjectBuildFileType.Project)
-            {
-                // Collect information that is specific to the project file.
-                var tfms = MSBuildHelper.GetTargetFrameworkMonikers(buildFiles)
-                    .OrderBy(tfm => tfm)
-                    .ToImmutableArray();
-                var properties = MSBuildHelper.GetProperties(buildFiles).Values
-                    .Where(p => !p.SourceFilePath.StartsWith(".."))
-                    .OrderBy(p => p.Name)
-                    .ToImmutableArray();
-                var referencedProjectPaths = MSBuildHelper.GetProjectPathsFromProject(projectPath)
-                    .Select(path => Path.GetRelativePath(workspacePath, path))
-                    .OrderBy(p => p)
-                    .ToImmutableArray();
+                    continue;
+                }
 
-                // Get the complete set of dependencies including transitive dependencies.
-                var dependencies = indirectDependencies.Concat(directDependencies).ToImmutableArray();
-                dependencies = dependencies
-                    .Select(d => d with { TargetFrameworks = tfms })
+                // The build file dependencies have the correct DependencyType and the TopLevelDependencies have the evaluated version.
+                // Combine them to have the set of dependencies that are directly referenced from the build file.
+                var fileDependencies = BuildFile.GetDependencies(buildFile)
+                    .ToDictionary(d => d.Name, StringComparer.OrdinalIgnoreCase);
+                var sdkDependencies = fileDependencies.Values
+                    .Where(d => d.Type == DependencyType.MSBuildSdk)
                     .ToImmutableArray();
-                var transitiveDependencies = await GetTransitiveDependencies(repoRootPath, projectPath, tfms, dependencies, logger);
-                ImmutableArray<Dependency> allDependencies = dependencies.Concat(transitiveDependencies).Concat(sdkDependencies)
-                    .OrderBy(d => d.Name)
+                var indirectDependencies = topLevelDependencies
+                    .Where(d => !fileDependencies.ContainsKey(d.Name))
                     .ToImmutableArray();
+                var directDependencies = topLevelDependencies
+                    .Where(d => fileDependencies.ContainsKey(d.Name))
+                    .Select(d =>
+                    {
+                        var dependency = fileDependencies[d.Name];
+                        return d with
+                        {
+                            Type = dependency.Type,
+                            IsDirect = true
+                        };
+                    }).ToImmutableArray();
 
-                results.Add(new()
+                if (buildFile.GetFileType() == ProjectBuildFileType.Project)
                 {
-                    FilePath = Path.GetRelativePath(workspacePath, buildFile.Path),
-                    Properties = properties,
-                    TargetFrameworks = tfms,
-                    ReferencedProjectPaths = referencedProjectPaths,
-                    Dependencies = allDependencies,
-                });
-            }
-            else
-            {
-                results.Add(new()
-                {
-                    FilePath = Path.GetRelativePath(workspacePath, buildFile.Path),
-                    Dependencies = directDependencies.Concat(sdkDependencies)
+                    // Collect information that is specific to the project file.
+                    var properties = MSBuildHelper.GetProperties(buildFiles).Values
+                        .Where(p => !p.SourceFilePath.StartsWith(".."))
+                        .OrderBy(p => p.Name)
+                        .ToImmutableArray();
+                    var referencedProjectPaths = MSBuildHelper.GetProjectPathsFromProject(projectPath)
+                        .Select(path => Path.GetRelativePath(workspacePath, path))
+                        .OrderBy(p => p)
+                        .ToImmutableArray();
+
+                    // Get the complete set of dependencies including transitive dependencies.
+                    var dependencies = indirectDependencies.Concat(directDependencies).ToImmutableArray();
+                    dependencies = dependencies
+                        .Select(d => d with { TargetFrameworks = tfms })
+                        .ToImmutableArray();
+                    var transitiveDependencies = await GetTransitiveDependencies(repoRootPath, projectPath, tfms, dependencies, logger);
+                    ImmutableArray<Dependency> allDependencies = dependencies.Concat(transitiveDependencies).Concat(sdkDependencies)
                         .OrderBy(d => d.Name)
-                        .ToImmutableArray(),
-                });
+                        .ToImmutableArray();
+
+                    results.Add(new()
+                    {
+                        FilePath = Path.GetRelativePath(workspacePath, buildFile.Path),
+                        Properties = properties,
+                        TargetFrameworks = tfms,
+                        ReferencedProjectPaths = referencedProjectPaths,
+                        Dependencies = allDependencies,
+                    });
+                }
+                else
+                {
+                    results.Add(new()
+                    {
+                        FilePath = Path.GetRelativePath(workspacePath, buildFile.Path),
+                        Dependencies = directDependencies.Concat(sdkDependencies)
+                            .OrderBy(d => d.Name)
+                            .ToImmutableArray(),
+                    });
+                }
             }
         }
 

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

@@ -20,8 +20,7 @@ internal static class SdkPackageUpdater
         // SDK-style project, modify the XML directly
         logger.Log("  Running for SDK-style project");
 
-        var buildFiles = await MSBuildHelper.LoadBuildFilesAsync(repoRootPath, projectPath);
-        var tfms = MSBuildHelper.GetTargetFrameworkMonikers(buildFiles);
+        (ImmutableArray<ProjectBuildFile> buildFiles, string[] tfms) = await MSBuildHelper.LoadBuildFilesAndTargetFrameworksAsync(repoRootPath, projectPath);
 
         // Get the set of all top-level dependencies in the current project
         var topLevelDependencies = MSBuildHelper.GetTopLevelPackageDependencyInfos(buildFiles).ToArray();
@@ -42,7 +41,7 @@ internal static class SdkPackageUpdater
                 return;
             }
 
-            UpdateTopLevelDepdendency(buildFiles, dependencyName, previousDependencyVersion, newDependencyVersion, peerDependencies, logger);
+            await UpdateTopLevelDepdendency(repoRootPath, buildFiles, tfms, dependencyName, previousDependencyVersion, newDependencyVersion, peerDependencies, logger);
         }
 
         if (!await AreDependenciesCoherentAsync(repoRootPath, projectPath, dependencyName, logger, buildFiles, tfms))
@@ -226,10 +225,10 @@ internal static class SdkPackageUpdater
         logger.Log($"    Adding [{dependencyName}/{newDependencyVersion}] as a top-level package reference.");
 
         // see https://learn.microsoft.com/nuget/consume-packages/install-use-packages-dotnet-cli
-        var (exitCode, _, _) = await ProcessEx.RunAsync("dotnet", $"add {projectPath} package {dependencyName} --version {newDependencyVersion}", workingDirectory: Path.GetDirectoryName(projectPath));
+        var (exitCode, stdout, stderr) = await ProcessEx.RunAsync("dotnet", $"add {projectPath} package {dependencyName} --version {newDependencyVersion}", workingDirectory: Path.GetDirectoryName(projectPath));
         if (exitCode != 0)
         {
-            logger.Log($"    Transitive dependency [{dependencyName}/{newDependencyVersion}] was not added.");
+            logger.Log($"    Transitive dependency [{dependencyName}/{newDependencyVersion}] was not added.\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}");
         }
     }
 
@@ -288,8 +287,10 @@ internal static class SdkPackageUpdater
         return packagesAndVersions;
     }
 
-    private static void UpdateTopLevelDepdendency(
+    private static async Task UpdateTopLevelDepdendency(
+        string repoRootPath,
         ImmutableArray<ProjectBuildFile> buildFiles,
+        string[] targetFrameworks,
         string dependencyName,
         string previousDependencyVersion,
         string newDependencyVersion,
@@ -307,6 +308,43 @@ internal static class SdkPackageUpdater
         {
             TryUpdateDependencyVersion(buildFiles, packageName, previousDependencyVersion: null, newDependencyVersion: packageVersion, logger);
         }
+
+        // now make all dependency requirements coherent
+        Dependency[] updatedTopLevelDependencies = MSBuildHelper.GetTopLevelPackageDependencyInfos(buildFiles).ToArray();
+        foreach (ProjectBuildFile projectFile in buildFiles)
+        {
+            foreach (string tfm in targetFrameworks)
+            {
+                Dependency[]? resolvedDependencies = await MSBuildHelper.ResolveDependencyConflicts(repoRootPath, projectFile.Path, tfm, updatedTopLevelDependencies, logger);
+                if (resolvedDependencies is null)
+                {
+                    logger.Log($"    Unable to resolve dependency conflicts for {projectFile.Path}.");
+                    continue;
+                }
+
+                // ensure the originally requested dependency was resolved to the correct version
+                var specificResolvedDependency = resolvedDependencies.Where(d => d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
+                if (specificResolvedDependency is null)
+                {
+                    logger.Log($"    Unable resolve requested dependency for {dependencyName} in {projectFile.Path}.");
+                    continue;
+                }
+
+                if (!newDependencyVersion.Equals(specificResolvedDependency.Version, StringComparison.OrdinalIgnoreCase))
+                {
+                    logger.Log($"    Inconsistent resolution for {dependencyName}; attempted upgrade to {newDependencyVersion} but resolved {specificResolvedDependency.Version}.");
+                    continue;
+                }
+
+                // update all other dependencies
+                foreach (Dependency resolvedDependency in resolvedDependencies
+                                                          .Where(d => !d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase))
+                                                          .Where(d => d.Version is not null))
+                {
+                    TryUpdateDependencyVersion(buildFiles, resolvedDependency.Name, previousDependencyVersion: null, newDependencyVersion: resolvedDependency.Version!, logger);
+                }
+            }
+        }
     }
 
     private static UpdateResult TryUpdateDependencyVersion(

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

@@ -12,7 +12,7 @@ public class UpdaterWorker
 
     public async Task RunAsync(string repoRootPath, string workspacePath, string dependencyName, string previousDependencyVersion, string newDependencyVersion, bool isTransitive)
     {
-        MSBuildHelper.RegisterMSBuild();
+        MSBuildHelper.RegisterMSBuild(Environment.CurrentDirectory, repoRootPath);
 
         if (!Path.IsPathRooted(workspacePath) || !File.Exists(workspacePath))
         {

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

@@ -2,6 +2,7 @@ using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
 using System.Text;
 using System.Text.Json;
+using System.Text.Json.Nodes;
 using System.Text.RegularExpressions;
 using System.Xml;
 
@@ -13,6 +14,7 @@ using Microsoft.Build.Locator;
 using Microsoft.Extensions.FileSystemGlobbing;
 
 using NuGet.Configuration;
+using NuGet.Versioning;
 
 using NuGetUpdater.Core.Utilities;
 
@@ -24,106 +26,34 @@ internal static partial class MSBuildHelper
 
     public static bool IsMSBuildRegistered => MSBuildPath.Length > 0;
 
-    static MSBuildHelper()
-    {
-        RegisterMSBuild();
-    }
-
-    public static void RegisterMSBuild()
+    public static void RegisterMSBuild(string currentDirectory, string rootDirectory)
     {
         // Ensure MSBuild types are registered before calling a method that loads the types
         if (!IsMSBuildRegistered)
         {
-            var globalJsonPath = "global.json";
-            var tempGlobalJsonPath = globalJsonPath + Guid.NewGuid().ToString();
-            var globalJsonExists = File.Exists(globalJsonPath);
-            try
+            var candidateDirectories = PathHelper.GetAllDirectoriesToRoot(currentDirectory, rootDirectory);
+            var globalJsonPaths = candidateDirectories.Select(d => Path.Combine(d, "global.json")).Where(File.Exists).Select(p => (p, p + Guid.NewGuid().ToString())).ToArray();
+            foreach (var (globalJsonPath, tempGlobalJsonPath) in globalJsonPaths)
             {
-                if (globalJsonExists)
-                {
-                    Console.WriteLine("Temporarily removing `global.json` for MSBuild detection.");
-                    File.Move(globalJsonPath, tempGlobalJsonPath);
-                }
+                Console.WriteLine($"Temporarily removing `global.json` from `{Path.GetDirectoryName(globalJsonPath)}` for MSBuild detection.");
+                File.Move(globalJsonPath, tempGlobalJsonPath);
+            }
 
+            try
+            {
                 var defaultInstance = MSBuildLocator.QueryVisualStudioInstances().First();
                 MSBuildPath = defaultInstance.MSBuildPath;
                 MSBuildLocator.RegisterInstance(defaultInstance);
             }
             finally
             {
-                if (globalJsonExists)
-                {
-                    Console.WriteLine("Restoring `global.json` after MSBuild detection.");
-                    File.Move(tempGlobalJsonPath, globalJsonPath);
-                }
-            }
-        }
-    }
-
-    public static string[] GetTargetFrameworkMonikers(ImmutableArray<ProjectBuildFile> buildFiles)
-    {
-        HashSet<string> targetFrameworkValues = new(StringComparer.OrdinalIgnoreCase);
-        Dictionary<string, Property> propertyInfo = new(StringComparer.OrdinalIgnoreCase);
-
-        foreach (var buildFile in buildFiles)
-        {
-            var projectRoot = CreateProjectRootElement(buildFile);
-
-            foreach (var property in projectRoot.Properties)
-            {
-                if (property.Name.Equals("TargetFramework", StringComparison.OrdinalIgnoreCase) ||
-                    property.Name.Equals("TargetFrameworks", StringComparison.OrdinalIgnoreCase))
-                {
-                    if (buildFile.IsOutsideBasePath)
-                    {
-                        continue;
-                    }
-
-                    foreach (var tfm in property.Value.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
-                    {
-                        targetFrameworkValues.Add(tfm);
-                    }
-                }
-                else if (property.Name.Equals("TargetFrameworkVersion", StringComparison.OrdinalIgnoreCase))
+                foreach (var (globalJsonpath, tempGlobalJsonPath) in globalJsonPaths)
                 {
-                    if (buildFile.IsOutsideBasePath)
-                    {
-                        continue;
-                    }
-
-                    // For packages.config projects that use TargetFrameworkVersion, we need to convert it to TargetFramework
-                    targetFrameworkValues.Add($"net{property.Value.TrimStart('v').Replace(".", "")}");
+                    Console.WriteLine($"Restoring `global.json` to `{Path.GetDirectoryName(globalJsonpath)}` after MSBuild discovery.");
+                    File.Move(tempGlobalJsonPath, globalJsonpath);
                 }
-                else
-                {
-                    propertyInfo[property.Name] = new(property.Name, property.Value, buildFile.RelativePath);
-                }
-            }
-        }
-
-        HashSet<string> targetFrameworks = new(StringComparer.OrdinalIgnoreCase);
-
-        foreach (var targetFrameworkValue in targetFrameworkValues)
-        {
-            var (resultType, _, tfms, _, errorMessage) =
-                GetEvaluatedValue(targetFrameworkValue, propertyInfo, propertiesToIgnore: ["TargetFramework", "TargetFrameworks"]);
-            if (resultType != EvaluationResultType.Success)
-            {
-                continue;
-            }
-
-            if (string.IsNullOrEmpty(tfms))
-            {
-                continue;
-            }
-
-            foreach (var tfm in tfms.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
-            {
-                targetFrameworks.Add(tfm);
             }
         }
-
-        return targetFrameworks.ToArray();
     }
 
     public static IEnumerable<string> GetProjectPathsFromSolution(string solutionPath)
@@ -379,6 +309,124 @@ internal static partial class MSBuildHelper
         }
     }
 
+    internal static async Task<Dependency[]?> ResolveDependencyConflicts(string repoRoot, string projectPath, string targetFramework, Dependency[] packages, Logger logger)
+    {
+        var tempDirectory = Directory.CreateTempSubdirectory("package-dependency-coherence_");
+        try
+        {
+            var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages);
+            var (exitCode, stdOut, stdErr) = await ProcessEx.RunAsync("dotnet", $"restore \"{tempProjectPath}\"", workingDirectory: tempDirectory.FullName);
+
+            // simple cases first
+            // if restore failed, nothing we can do
+            if (exitCode != 0)
+            {
+                return null;
+            }
+
+            // if no problems found, just return the current set
+            if (!stdOut.Contains("NU1608"))
+            {
+                return packages;
+            }
+
+            // now it gets complicated; look for the packages with issues
+            MatchCollection matches = PackageIncompatibilityWarningPattern().Matches(stdOut);
+            (string, NuGetVersion)[] badPackagesAndVersions = matches.Select(m => (m.Groups["PackageName"].Value, NuGetVersion.Parse(m.Groups["PackageVersion"].Value))).ToArray();
+            Dictionary<string, HashSet<NuGetVersion>> badPackagesAndCandidateVersionsDictionary = new(StringComparer.OrdinalIgnoreCase);
+
+            // and for each of those packages, find all versions greater than the one that's currently installed
+            foreach ((string packageName, NuGetVersion packageVersion) in badPackagesAndVersions)
+            {
+                // this command dumps a JSON object with all versions of the specified package from all package sources
+                (exitCode, stdOut, stdErr) = await ProcessEx.RunAsync("dotnet", $"package search {packageName} --exact-match --format json", workingDirectory: tempDirectory.FullName);
+                if (exitCode != 0)
+                {
+                    continue;
+                }
+
+                // ensure collection exists
+                if (!badPackagesAndCandidateVersionsDictionary.ContainsKey(packageName))
+                {
+                    badPackagesAndCandidateVersionsDictionary.Add(packageName, new HashSet<NuGetVersion>());
+                }
+
+                HashSet<NuGetVersion> foundVersions = badPackagesAndCandidateVersionsDictionary[packageName];
+
+                var json = JsonHelper.ParseNode(stdOut);
+                if (json?["searchResult"] is JsonArray searchResults)
+                {
+                    foreach (var searchResult in searchResults)
+                    {
+                        if (searchResult?["packages"] is JsonArray packagesArray)
+                        {
+                            foreach (var package in packagesArray)
+                            {
+                                // in 8.0.xxx SDKs, the package version is in the `latestVersion` property, but in 9.0.xxx, it's `version`
+                                var packageVersionProperty = package?["version"] ?? package?["latestVersion"];
+                                if (packageVersionProperty is JsonValue latestVersion &&
+                                    latestVersion.GetValueKind() == JsonValueKind.String &&
+                                    NuGetVersion.TryParse(latestVersion.ToString(), out var nugetVersion) &&
+                                    nugetVersion > packageVersion)
+                                {
+                                    foundVersions.Add(nugetVersion);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // generate all possible combinations
+            (string Key, NuGetVersion v)[][] expandedLists = badPackagesAndCandidateVersionsDictionary.Select(kvp => kvp.Value.Order().Select(v => (kvp.Key, v)).ToArray()).ToArray();
+            IEnumerable<(string PackageName, NuGetVersion PackageVersion)>[] product = expandedLists.CartesianProduct().ToArray();
+
+            // FUTURE WORK: pre-filter individual known package incompatibilities to reduce the number of combinations, e.g., if Package.A v1.0.0
+            // is incompatible with Package.B v2.0.0, then remove _all_ combinations with that pair
+
+            // this is the slow part
+            foreach (IEnumerable<(string PackageName, NuGetVersion PackageVersion)> candidateSet in product)
+            {
+                // 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 =>
+                {
+                    if (packageVersions.TryGetValue(p.Name, out var version))
+                    {
+                        // create a new dependency with the updated version
+                        return new Dependency(p.Name, version.ToString(), p.Type, IsDevDependency: p.IsDevDependency, IsOverride: p.IsOverride, IsUpdate: p.IsUpdate);
+                    }
+
+                    // not the dependency we're looking for, use whatever it already was in this set
+                    return p;
+                }).ToArray();
+
+                if (await DependenciesAreCoherentAsync(repoRoot, projectPath, targetFramework, candidatePackages, logger))
+                {
+                    // return as soon as we find a coherent set
+                    return candidatePackages;
+                }
+            }
+
+            // no package resolution set found
+            return null;
+        }
+        finally
+        {
+            tempDirectory.Delete(recursive: true);
+        }
+    }
+
+    // fully expand all possible combinations using the algorithm from here:
+    // https://ericlippert.com/2010/06/28/computing-a-cartesian-product-with-linq/
+    private static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this IEnumerable<IEnumerable<T>> sequences)
+    {
+        IEnumerable<IEnumerable<T>> emptyProduct = [[]];
+        return sequences.Aggregate(emptyProduct, (accumulator, sequence) => from accseq in accumulator
+                                                                            from item in sequence
+                                                                            select accseq.Concat([item]));
+    }
+
     private static ProjectRootElement CreateProjectRootElement(ProjectBuildFile buildFile)
     {
         var xmlString = buildFile.Contents.ToFullString();
@@ -569,7 +617,7 @@ internal static partial class MSBuildHelper
         return directoryPackagesPropsPath is not null;
     }
 
-    internal static async Task<ImmutableArray<ProjectBuildFile>> LoadBuildFilesAsync(string repoRootPath, string projectPath, bool includeSdkPropsAndTargets = false)
+    internal static async Task<(ImmutableArray<ProjectBuildFile> ProjectBuildFiles, string[] TargetFrameworks)> LoadBuildFilesAndTargetFrameworksAsync(string repoRootPath, string projectPath)
     {
         var buildFileList = new List<string>
         {
@@ -579,6 +627,7 @@ internal static partial class MSBuildHelper
         // a global.json file might cause problems with the dotnet msbuild command; create a safe version temporarily
         TryGetGlobalJsonPath(repoRootPath, projectPath, out var globalJsonPath);
         var safeGlobalJsonName = $"{globalJsonPath}{Guid.NewGuid()}";
+        HashSet<string> targetFrameworks = new(StringComparer.OrdinalIgnoreCase);
 
         try
         {
@@ -607,16 +656,51 @@ internal static partial class MSBuildHelper
             // load the project even if it imports a file that doesn't exist (e.g. a file that's generated at restore
             // or build time).
             using var projectCollection = new ProjectCollection(); // do this in a one-off instance and don't pollute the global collection
-            var project = Project.FromFile(projectPath, new ProjectOptions
+            Project project = Project.FromFile(projectPath, new ProjectOptions
             {
                 LoadSettings = ProjectLoadSettings.IgnoreMissingImports,
                 ProjectCollection = projectCollection,
             });
             buildFileList.AddRange(project.Imports.Select(i => i.ImportedProject.FullPath.NormalizePathToUnix()));
+
+            // use the MSBuild-evaluated value so we don't have to try to manually parse XML
+            IEnumerable<ProjectProperty> targetFrameworkProperties = project.Properties.Where(p => p.Name.Equals("TargetFramework", StringComparison.OrdinalIgnoreCase)).ToList();
+            IEnumerable<ProjectProperty> targetFrameworksProperties = project.Properties.Where(p => p.Name.Equals("TargetFrameworks", StringComparison.OrdinalIgnoreCase)).ToList();
+            IEnumerable<ProjectProperty> targetFrameworkVersionProperties = project.Properties.Where(p => p.Name.Equals("TargetFrameworkVersion", StringComparison.OrdinalIgnoreCase)).ToList();
+            foreach (ProjectProperty tfm in targetFrameworkProperties)
+            {
+                if (!string.IsNullOrWhiteSpace(tfm.EvaluatedValue))
+                {
+                    targetFrameworks.Add(tfm.EvaluatedValue);
+                }
+            }
+
+            foreach (ProjectProperty tfms in targetFrameworksProperties)
+            {
+                foreach (string tfmValue in tfms.EvaluatedValue.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
+                {
+                    targetFrameworks.Add(tfmValue);
+                }
+            }
+
+            if (targetFrameworks.Count == 0)
+            {
+                // Only try this if we haven't been able to resolve anything yet.  This is because deep in the SDK, a
+                // `TargetFramework` of `netstandard2.0` (eventually) gets turned into `v2.0` and we don't want to
+                // interpret that as a .NET Framework 2.0 project.
+                foreach (ProjectProperty tfvm in targetFrameworkVersionProperties)
+                {
+                    // `v0.0` is an error case where no TFM could be evaluated
+                    if (tfvm.EvaluatedValue != "v0.0")
+                    {
+                        targetFrameworks.Add($"net{tfvm.EvaluatedValue.TrimStart('v').Replace(".", "")}");
+                    }
+                }
+            }
         }
         catch (InvalidProjectFileException)
         {
-            return [];
+            return ([], []);
         }
         finally
         {
@@ -627,18 +711,22 @@ internal static partial class MSBuildHelper
         }
 
         var repoRootPathPrefix = repoRootPath.NormalizePathToUnix() + "/";
-        var buildFiles = includeSdkPropsAndTargets
-            ? buildFileList.Distinct()
-            : buildFileList
-                .Where(f => f.StartsWith(repoRootPathPrefix, StringComparison.OrdinalIgnoreCase))
-                .Distinct();
+        var buildFiles = buildFileList
+            .Where(f => f.StartsWith(repoRootPathPrefix, StringComparison.OrdinalIgnoreCase))
+            .Distinct();
         var result = buildFiles
             .Where(File.Exists)
             .Select(path => ProjectBuildFile.Open(repoRootPath, path))
             .ToImmutableArray();
-        return result;
+        return (result, targetFrameworks.ToArray());
     }
 
     [GeneratedRegex("^\\s*NuGetData::Package=(?<PackageName>[^,]+), Version=(?<PackageVersion>.+)$")]
     private static partial Regex PackagePattern();
+
+    // Example output:
+    //   NU1608: Detected package version outside of dependency constraint: SpecFlow.Tools.MsBuild.Generation 3.3.30 requires SpecFlow(= 3.3.30) but version SpecFlow 3.9.74 was resolved.
+    //                                                          PackageName-|+++++++++++++++++++++++++++++++| |++++|-PackageVersion
+    [GeneratedRegex("NU1608: [^:]+: (?<PackageName>[^ ]+) (?<PackageVersion>[^ ]+)")]
+    private static partial Regex PackageIncompatibilityWarningPattern();
 }

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

@@ -34,20 +34,11 @@ internal static class PathHelper
     public static string GetFullPathFromRelative(string rootPath, string relativePath)
         => Path.GetFullPath(JoinPath(rootPath, relativePath.NormalizePathToUnix()));
 
-    /// <summary>
-    /// Check in every directory from <paramref name="initialPath"/> up to <paramref name="rootPath"/> for the file specified in <paramref name="fileName"/>.
-    /// </summary>
-    /// <returns>The path of the found file or null.</returns>
-    public static string? GetFileInDirectoryOrParent(string initialPath, string rootPath, string fileName, bool caseSensitive = true)
+    public static string[] GetAllDirectoriesToRoot(string initialDirectoryPath, string rootDirectoryPath)
     {
-        if (File.Exists(initialPath))
-        {
-            initialPath = Path.GetDirectoryName(initialPath)!;
-        }
-
         var candidatePaths = new List<string>();
-        var rootDirectory = new DirectoryInfo(rootPath);
-        var candidateDirectory = new DirectoryInfo(initialPath);
+        var rootDirectory = new DirectoryInfo(rootDirectoryPath);
+        var candidateDirectory = new DirectoryInfo(initialDirectoryPath);
         while (candidateDirectory.FullName != rootDirectory.FullName)
         {
             candidatePaths.Add(candidateDirectory.FullName);
@@ -58,8 +49,22 @@ internal static class PathHelper
             }
         }
 
-        candidatePaths.Add(rootPath);
+        candidatePaths.Add(rootDirectoryPath);
+        return candidatePaths.ToArray();
+    }
+
+    /// <summary>
+    /// Check in every directory from <paramref name="initialPath"/> up to <paramref name="rootPath"/> for the file specified in <paramref name="fileName"/>.
+    /// </summary>
+    /// <returns>The path of the found file or null.</returns>
+    public static string? GetFileInDirectoryOrParent(string initialPath, string rootPath, string fileName, bool caseSensitive = true)
+    {
+        if (File.Exists(initialPath))
+        {
+            initialPath = Path.GetDirectoryName(initialPath)!;
+        }
 
+        var candidatePaths = GetAllDirectoriesToRoot(initialPath, rootPath);
         foreach (var candidatePath in candidatePaths)
         {
             try

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

@@ -1,4 +1,5 @@
 using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
 using System.Text.Json;
 
 using NuGetUpdater.Core.Discover;
@@ -29,7 +30,7 @@ public class DiscoveryWorkerTestBase
     protected static void ValidateWorkspaceResult(ExpectedWorkspaceDiscoveryResult expectedResult, WorkspaceDiscoveryResult actualResult)
     {
         Assert.NotNull(actualResult);
-        Assert.Equal(expectedResult.FilePath, actualResult.FilePath);
+        Assert.Equal(expectedResult.FilePath.NormalizePathToUnix(), actualResult.FilePath.NormalizePathToUnix());
         ValidateDirectoryPackagesProps(expectedResult.DirectoryPackagesProps, actualResult.DirectoryPackagesProps);
         ValidateResultWithDependencies(expectedResult.GlobalJson, actualResult.GlobalJson);
         ValidateResultWithDependencies(expectedResult.DotNetToolsJson, actualResult.DotNetToolsJson);
@@ -50,7 +51,7 @@ public class DiscoveryWorkerTestBase
                 Assert.NotNull(actualResult);
             }
 
-            Assert.Equal(expectedResult.FilePath, actualResult.FilePath);
+            Assert.Equal(expectedResult.FilePath.NormalizePathToUnix(), actualResult.FilePath.NormalizePathToUnix());
             ValidateDependencies(expectedResult.Dependencies, actualResult.Dependencies);
             Assert.Equal(expectedResult.ExpectedDependencyCount ?? expectedResult.Dependencies.Length, actualResult.Dependencies.Length);
         }
@@ -64,12 +65,12 @@ public class DiscoveryWorkerTestBase
 
             foreach (var expectedProject in expectedProjects)
             {
-                var actualProject = actualProjects.Single(p => p.FilePath == expectedProject.FilePath);
+                var actualProject = actualProjects.Single(p => p.FilePath.NormalizePathToUnix() == expectedProject.FilePath.NormalizePathToUnix());
 
-                Assert.Equal(expectedProject.FilePath, actualProject.FilePath);
-                AssertEx.Equal(expectedProject.Properties, actualProject.Properties);
+                Assert.Equal(expectedProject.FilePath.NormalizePathToUnix(), actualProject.FilePath.NormalizePathToUnix());
+                AssertEx.Equal(expectedProject.Properties, actualProject.Properties, PropertyComparer.Instance);
                 AssertEx.Equal(expectedProject.TargetFrameworks, actualProject.TargetFrameworks);
-                AssertEx.Equal(expectedProject.ReferencedProjectPaths, actualProject.ReferencedProjectPaths);
+                AssertEx.Equal(expectedProject.ReferencedProjectPaths.Select(PathHelper.NormalizePathToUnix), actualProject.ReferencedProjectPaths.Select(PathHelper.NormalizePathToUnix));
                 ValidateDependencies(expectedProject.Dependencies, actualProject.Dependencies);
                 Assert.Equal(expectedProject.ExpectedDependencyCount ?? expectedProject.Dependencies.Length, actualProject.Dependencies.Length);
             }
@@ -114,4 +115,21 @@ public class DiscoveryWorkerTestBase
         var resultJson = await File.ReadAllTextAsync(resultPath);
         return JsonSerializer.Deserialize<WorkspaceDiscoveryResult>(resultJson, DiscoveryWorker.SerializerOptions)!;
     }
+
+    internal class PropertyComparer : IEqualityComparer<Property>
+    {
+        public static PropertyComparer Instance { get; } = new();
+
+        public bool Equals(Property? x, Property? y)
+        {
+            return x?.Name == y?.Name &&
+                   x?.Value == y?.Value &&
+                   x?.SourceFilePath.NormalizePathToUnix() == y?.SourceFilePath.NormalizePathToUnix();
+        }
+
+        public int GetHashCode([DisallowNull] Property obj)
+        {
+            throw new NotImplementedException();
+        }
+    }
 }

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

@@ -25,11 +25,14 @@ public partial class DiscoveryWorkerTests
                           <package id="NuGet.Core" version="2.11.1" targetFramework="net46" />
                           <package id="NuGet.Server" version="2.11.2" targetFramework="net46" />
                           <package id="RouteMagic" version="1.3" targetFramework="net46" />
-                          <package id="WebActivatorEx" version="2.1.0" targetFramework="net46"></package>
+                          <package id="WebActivatorEx" version="2.1.0" targetFramework="net46" />
                         </packages>
                         """),
                     ("myproj.csproj", """
                         <Project>
+                          <PropertyGroup>
+                            <TargetFramework>net46</TargetFramework>
+                          </PropertyGroup>
                         </Project>
                         """)
                 ],
@@ -40,16 +43,21 @@ public partial class DiscoveryWorkerTests
                         new()
                         {
                             FilePath = "myproj.csproj",
+                            Properties = [
+                                new("TargetFramework", "net46", "myproj.csproj"),
+                            ],
+                            TargetFrameworks = ["net46"],
                             Dependencies = [
-                                new("Microsoft.CodeDom.Providers.DotNetCompilerPlatform", "1.0.0", DependencyType.PackagesConfig, TargetFrameworks: []),
-                                new("Microsoft.Net.Compilers", "1.0.1", DependencyType.PackagesConfig, TargetFrameworks: []),
-                                new("Microsoft.Web.Infrastructure", "1.0.0.0", DependencyType.PackagesConfig, TargetFrameworks: []),
-                                new("Microsoft.Web.Xdt", "2.1.1", DependencyType.PackagesConfig, TargetFrameworks: []),
-                                new("Newtonsoft.Json", "8.0.3", DependencyType.PackagesConfig, TargetFrameworks: []),
-                                new("NuGet.Core", "2.11.1", DependencyType.PackagesConfig, TargetFrameworks: []),
-                                new("NuGet.Server", "2.11.2", DependencyType.PackagesConfig, TargetFrameworks: []),
-                                new("RouteMagic", "1.3", DependencyType.PackagesConfig, TargetFrameworks: []),
-                                new("WebActivatorEx", "2.1.0", DependencyType.PackagesConfig, TargetFrameworks: []),
+                                new("Microsoft.NETFramework.ReferenceAssemblies", "1.0.3", DependencyType.Unknown, TargetFrameworks: ["net46"], IsTransitive: true),
+                                new("Microsoft.CodeDom.Providers.DotNetCompilerPlatform", "1.0.0", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("Microsoft.Net.Compilers", "1.0.1", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("Microsoft.Web.Infrastructure", "1.0.0.0", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("Microsoft.Web.Xdt", "2.1.1", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("Newtonsoft.Json", "8.0.3", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("NuGet.Core", "2.11.1", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("NuGet.Server", "2.11.2", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("RouteMagic", "1.3", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
+                                new("WebActivatorEx", "2.1.0", DependencyType.PackagesConfig, TargetFrameworks: ["net46"]),
                             ],
                         }
                     ],

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

@@ -376,5 +376,30 @@ public partial class DiscoveryWorkerTests
                     ],
                 });
         }
+
+        [Fact]
+
+        public async Task NoDependenciesReturnedIfNoTargetFrameworkCanBeResolved()
+        {
+            await TestDiscoveryAsync(
+                workspacePath: "",
+                files: [
+                    ("myproj.csproj", """
+                        <Project Sdk="Microsoft.NET.Sdk">
+                          <PropertyGroup>
+                            <TargetFramework>$(SomeCommonTfmThatCannotBeResolved)</TargetFramework>
+                          </PropertyGroup>
+                          <ItemGroup>
+                            <PackageReference Include="Some.Package" Version="1.2.3" />
+                          </ItemGroup>
+                        </Project>
+                        """)
+                ],
+                expectedResult: new()
+                {
+                    FilePath = "",
+                    Projects = []
+                });
+        }
     }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/TestBase.cs

@@ -0,0 +1,10 @@
+namespace NuGetUpdater.Core.Test
+{
+    public abstract class TestBase
+    {
+        protected TestBase()
+        {
+            MSBuildHelper.RegisterMSBuild(Environment.CurrentDirectory, Environment.CurrentDirectory);
+        }
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/PackagesConfigUpdaterTests.cs

@@ -1,16 +1,9 @@
-using System.Collections.Generic;
-
 using Xunit;
 
 namespace NuGetUpdater.Core.Test.Update;
 
-public class PackagesConfigUpdaterTests
+public class PackagesConfigUpdaterTests : TestBase
 {
-    public PackagesConfigUpdaterTests()
-    {
-        MSBuildHelper.RegisterMSBuild();
-    }
-
     [Theory]
     [MemberData(nameof(PackagesDirectoryPathTestData))]
     public void PathToPackagesDirectoryCanBeDetermined(string projectContents, string dependencyName, string dependencyVersion, string expectedPackagesDirectoryPath)

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTestBase.cs

@@ -10,7 +10,7 @@ namespace NuGetUpdater.Core.Test.Update;
 using TestFile = (string Path, string Content);
 using TestProject = (string Path, string Content, Guid ProjectId);
 
-public abstract class UpdateWorkerTestBase
+public abstract class UpdateWorkerTestBase : TestBase
 {
     protected static Task TestNoChange(
         string dependencyName,

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTests.DirsProj.cs

@@ -10,11 +10,6 @@ public partial class UpdateWorkerTests
 {
     public class DirsProj : UpdateWorkerTestBase
     {
-        public DirsProj()
-        {
-            MSBuildHelper.RegisterMSBuild();
-        }
-
         [Fact]
         public async Task UpdateSingleDependencyInDirsProj()
         {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTests.DotNetTools.cs

@@ -8,11 +8,6 @@ public partial class UpdateWorkerTests
 {
     public class DotNetTools : UpdateWorkerTestBase
     {
-        public DotNetTools()
-        {
-            MSBuildHelper.RegisterMSBuild();
-        }
-
         [Fact]
         public async Task NoChangeWhenDotNetToolsJsonNotFound()
         {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTests.GlobalJson.cs

@@ -8,11 +8,6 @@ public partial class UpdateWorkerTests
 {
     public class GlobalJson : UpdateWorkerTestBase
     {
-        public GlobalJson()
-        {
-            MSBuildHelper.RegisterMSBuild();
-        }
-
         [Fact]
         public async Task NoChangeWhenGlobalJsonNotFound()
         {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTests.Mixed.cs

@@ -8,11 +8,6 @@ public partial class UpdateWorkerTests
 {
     public class Mixed : UpdateWorkerTestBase
     {
-        public Mixed()
-        {
-            MSBuildHelper.RegisterMSBuild();
-        }
-
         [Fact]
         public async Task ForPackagesProject_UpdatePackageReference_InBuildProps()
         {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTests.PackagesConfig.cs

@@ -9,11 +9,6 @@ public partial class UpdateWorkerTests
 {
     public class PackagesConfig : UpdateWorkerTestBase
     {
-        public PackagesConfig()
-        {
-            MSBuildHelper.RegisterMSBuild();
-        }
-
         [Fact]
         public async Task UpdateSingleDependencyInPackagesConfig()
         {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTests.Sdk.cs

@@ -8,11 +8,6 @@ public partial class UpdateWorkerTests
 {
     public class Sdk : UpdateWorkerTestBase
     {
-        public Sdk()
-        {
-            MSBuildHelper.RegisterMSBuild();
-        }
-
         [Theory]
         [InlineData("net472")]
         [InlineData("netstandard2.0")]
@@ -175,24 +170,6 @@ public partial class UpdateWorkerTests
                 ]);
         }
 
-        [Fact]
-        public async Task NoChange_WhenPackageHasVersionConstraint()
-        {
-            // Dependency package has version constraint
-            await TestNoChangeforProject("AWSSDK.Core", "3.3.21.19", "3.7.300.20",
-                projectContents: $"""
-                <Project Sdk="Microsoft.NET.Sdk">
-                  <PropertyGroup>
-                    <TargetFramework>netstandard2.0</TargetFramework>
-                  </PropertyGroup>
-                  <ItemGroup>
-                    <PackageReference Include="AWSSDK.S3" Version="3.3.17.3" />
-                    <PackageReference Include="AWSSDK.Core" Version="3.3.21.19" />
-                  </ItemGroup>
-                </Project>
-                """);
-        }
-
         [Fact]
         public async Task UpdateVersionAttribute_InProjectFile_ForPackageReferenceInclude_Windows()
         {
@@ -2558,5 +2535,35 @@ public partial class UpdateWorkerTests
                     """
             );
         }
+
+        [Fact]
+        public async Task UpdatingPackageAlsoUpdatesAnythingWithADependencyOnTheUpdatedPackage()
+        {
+            // updating SpecFlow from 3.3.30 requires that SpecFlow.Tools.MsBuild.Generation also be updated
+            await TestUpdateForProject("SpecFlow", "3.3.30", "3.4.3",
+                projectContents: """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>netstandard2.0</TargetFramework>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="SpecFlow" Version="3.3.30" />
+                        <PackageReference Include="SpecFlow.Tools.MsBuild.Generation" Version="3.3.30" />
+                      </ItemGroup>
+                    </Project>
+                    """,
+                expectedProjectContents: """
+                    <Project Sdk="Microsoft.NET.Sdk">
+                      <PropertyGroup>
+                        <TargetFramework>netstandard2.0</TargetFramework>
+                      </PropertyGroup>
+                      <ItemGroup>
+                        <PackageReference Include="SpecFlow" Version="3.4.3" />
+                        <PackageReference Include="SpecFlow.Tools.MsBuild.Generation" Version="3.4.3" />
+                      </ItemGroup>
+                    </Project>
+                    """
+                );
+        }
     }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Utilities/MSBuildHelperTests.cs

@@ -6,13 +6,8 @@ namespace NuGetUpdater.Core.Test.Utilities;
 
 using TestFile = (string Path, string Content);
 
-public class MSBuildHelperTests
+public class MSBuildHelperTests : TestBase
 {
-    public MSBuildHelperTests()
-    {
-        MSBuildHelper.RegisterMSBuild();
-    }
-
     [Fact]
     public void GetRootedValue_FindsValue()
     {
@@ -110,15 +105,16 @@ public class MSBuildHelperTests
     [InlineData("<Project><PropertyGroup><TargetFrameworks>netstandard2.0</TargetFrameworks></PropertyGroup></Project>", "netstandard2.0", null)]
     [InlineData("<Project><PropertyGroup><TargetFrameworks>  ; netstandard2.0 ; </TargetFrameworks></PropertyGroup></Project>", "netstandard2.0", null)]
     [InlineData("<Project><PropertyGroup><TargetFrameworks>netstandard2.0 ; netstandard2.1 ; </TargetFrameworks></PropertyGroup></Project>", "netstandard2.0", "netstandard2.1")]
-    public void TfmsCanBeDeterminedFromProjectContents(string projectContents, string? expectedTfm1, string? expectedTfm2)
+    [InlineData("<Project><PropertyGroup><TargetFramework>netstandard2.0</TargetFramework><TargetFrameworkVersion Condition='False'>v4.7.2</TargetFrameworkVersion></PropertyGroup></Project>", "netstandard2.0", null)]
+    [InlineData("<Project><PropertyGroup><TargetFramework>$(PropertyThatCannotBeResolved)</TargetFramework></PropertyGroup></Project>", null, null)]
+    public async Task TfmsCanBeDeterminedFromProjectContents(string projectContents, string? expectedTfm1, string? expectedTfm2)
     {
         var projectPath = Path.GetTempFileName();
         try
         {
             File.WriteAllText(projectPath, projectContents);
             var expectedTfms = new[] { expectedTfm1, expectedTfm2 }.Where(tfm => tfm is not null).ToArray();
-            var buildFile = ProjectBuildFile.Open(Path.GetDirectoryName(projectPath)!, projectPath);
-            var actualTfms = MSBuildHelper.GetTargetFrameworkMonikers(ImmutableArray.Create(buildFile));
+            var (_buildFiles, actualTfms) = await MSBuildHelper.LoadBuildFilesAndTargetFrameworksAsync(Path.GetDirectoryName(projectPath)!, projectPath);
             AssertEx.Equal(expectedTfms, actualTfms);
         }
         finally
@@ -493,6 +489,45 @@ public class MSBuildHelperTests
         }
     }
 
+    [Fact]
+    public async Task DependencyConflictsCanBeResolved()
+    {
+        // the package `SpecFlow` was already updated from 3.3.30 to 3.4.3, but this causes a conflict with
+        // `SpecFlow.Tools.MsBuild.Generation` that needs to be resolved
+        var repoRoot = Directory.CreateTempSubdirectory($"test_{nameof(DependencyConflictsCanBeResolved)}_");
+        try
+        {
+            var projectPath = Path.Join(repoRoot.FullName, "project.csproj");
+            await File.WriteAllTextAsync(projectPath, """
+                <Project Sdk="Microsoft.NET.Sdk">
+                  <PropertyGroup>
+                    <TargetFramework>netstandard2.0</TargetFramework>
+                  </PropertyGroup>
+                  <ItemGroup>
+                    <PackageReference Include="SpecFlow" Version="3.4.3" />
+                    <PackageReference Include="SpecFlow.Tools.MsBuild.Generation" Version="3.3.30" />
+                  </ItemGroup>
+                </Project>
+                """);
+            var dependencies = new[]
+            {
+                new Dependency("SpecFlow", "3.4.3", DependencyType.PackageReference),
+                new Dependency("SpecFlow.Tools.MsBuild.Generation", "3.3.30", DependencyType.PackageReference),
+            };
+            var resolvedDependencies = await MSBuildHelper.ResolveDependencyConflicts(repoRoot.FullName, projectPath, "netstandard2.0", dependencies, new Logger(true));
+            Assert.NotNull(resolvedDependencies);
+            Assert.Equal(2, resolvedDependencies.Length);
+            Assert.Equal("SpecFlow", resolvedDependencies[0].Name);
+            Assert.Equal("3.4.3", resolvedDependencies[0].Version);
+            Assert.Equal("SpecFlow.Tools.MsBuild.Generation", resolvedDependencies[1].Name);
+            Assert.Equal("3.4.3", resolvedDependencies[1].Version);
+        }
+        finally
+        {
+            repoRoot.Delete(recursive: true);
+        }
+    }
+
     public static IEnumerable<object[]> GetTopLevelPackageDependencyInfosTestData()
     {
         // simple case

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Utilities/SdkPackageUpdaterHelperTests.cs

@@ -167,7 +167,7 @@ namespace NuGetUpdater.Core.Test.Utilities
 
         private static async Task<string[]> LoadBuildFilesFromTemp(TemporaryDirectory temporaryDirectory, string relativeProjectPath)
         {
-            var buildFiles = await MSBuildHelper.LoadBuildFilesAsync(temporaryDirectory.DirectoryPath, $"{temporaryDirectory.DirectoryPath}/{relativeProjectPath}");
+            var (buildFiles, _tfms) = await MSBuildHelper.LoadBuildFilesAndTargetFrameworksAsync(temporaryDirectory.DirectoryPath, $"{temporaryDirectory.DirectoryPath}/{relativeProjectPath}");
             var buildFilePaths = buildFiles.Select(f => f.RelativePath.NormalizePathToUnix()).ToArray();
             return buildFilePaths;
         }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dependabot-nuget
 version: !ruby/object:Gem::Version
-  version: 0.252.0
+  version: 0.253.0
 platform: ruby
 authors:
 - Dependabot
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-11 00:00:00.000000000 Z
+date: 2024-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dependabot-common
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.252.0
+        version: 0.253.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.252.0
+        version: 0.253.0
 - !ruby/object:Gem::Dependency
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
@@ -184,20 +184,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.7.3
-- !ruby/object:Gem::Dependency
-  name: stackprof
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.2.16
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.2.16
 - !ruby/object:Gem::Dependency
   name: turbo_tests
   requirement: !ruby/object:Gem::Requirement
@@ -314,6 +300,7 @@ files:
 - helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/FrameworkChecker/SupportedFrameworkFacts.cs
 - helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/NuGetUpdater.Core.Test.csproj
 - helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/TemporaryDirectory.cs
+- helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/TestBase.cs
 - helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/TestExtensions.cs
 - helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/PackagesConfigUpdaterTests.cs
 - helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Update/UpdateWorkerTestBase.cs
@@ -417,7 +404,7 @@ licenses:
 - Nonstandard
 metadata:
   bug_tracker_uri: https://github.com/dependabot/dependabot-core/issues
-  changelog_uri: https://github.com/dependabot/dependabot-core/releases/tag/v0.252.0
+  changelog_uri: https://github.com/dependabot/dependabot-core/releases/tag/v0.253.0
 post_install_message: 
 rdoc_options: []
 require_paths: