dependabot-nuget 0.251.0 → 0.253.0

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

@@ -1,13 +1,9 @@
-using System;
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.Linq;
 using System.Text;
 using System.Text.Json;
+using System.Text.Json.Nodes;
 using System.Text.RegularExpressions;
-using System.Threading.Tasks;
 using System.Xml;
 
 using Microsoft.Build.Construction;
@@ -18,111 +14,48 @@ using Microsoft.Build.Locator;
 using Microsoft.Extensions.FileSystemGlobbing;
 
 using NuGet.Configuration;
+using NuGet.Versioning;
 
 using NuGetUpdater.Core.Utilities;
 
 namespace NuGetUpdater.Core;
 
-using EvaluationResult = (MSBuildHelper.EvaluationResultType ResultType, string EvaluatedValue, string? ErrorMessage);
-
 internal static partial class MSBuildHelper
 {
     public static string MSBuildPath { get; private set; } = string.Empty;
 
     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)
+                foreach (var (globalJsonpath, tempGlobalJsonPath) in globalJsonPaths)
                 {
-                    Console.WriteLine("Restoring `global.json` after MSBuild detection.");
-                    File.Move(tempGlobalJsonPath, globalJsonPath);
+                    Console.WriteLine($"Restoring `global.json` to `{Path.GetDirectoryName(globalJsonpath)}` after MSBuild discovery.");
+                    File.Move(tempGlobalJsonPath, globalJsonpath);
                 }
             }
         }
     }
 
-    public static string[] GetTargetFrameworkMonikers(ImmutableArray<ProjectBuildFile> buildFiles)
-    {
-        HashSet<string> targetFrameworkValues = new(StringComparer.OrdinalIgnoreCase);
-        Dictionary<string, string> 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))
-                {
-                    foreach (var tfm in property.Value.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
-                    {
-                        targetFrameworkValues.Add(tfm);
-                    }
-                }
-                else if (property.Name.Equals("TargetFrameworkVersion", StringComparison.OrdinalIgnoreCase))
-                {
-                    // For packages.config projects that use TargetFrameworkVersion, we need to convert it to TargetFramework
-                    targetFrameworkValues.Add($"net{property.Value.TrimStart('v').Replace(".", "")}");
-                }
-                else
-                {
-                    propertyInfo[property.Name] = property.Value;
-                }
-            }
-        }
-
-        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)
     {
         var solution = SolutionFile.Parse(solutionPath);
@@ -190,19 +123,65 @@ internal static partial class MSBuildHelper
         }
     }
 
+    public static IReadOnlyDictionary<string, Property> GetProperties(ImmutableArray<ProjectBuildFile> buildFiles)
+    {
+        Dictionary<string, Property> properties = new(StringComparer.OrdinalIgnoreCase);
+
+        foreach (var buildFile in buildFiles)
+        {
+            var projectRoot = CreateProjectRootElement(buildFile);
+
+            foreach (var property in projectRoot.Properties)
+            {
+                // Short of evaluating the entire project, there's no way to _really_ know what package version is
+                // going to be used, and even then we might not be able to update it.  As a best guess, we'll simply
+                // skip any property that has a condition _or_ where the condition is checking for an empty string.
+                var hasEmptyCondition = string.IsNullOrEmpty(property.Condition);
+                var conditionIsCheckingForEmptyString = string.Equals(property.Condition, $"$({property.Name}) == ''", StringComparison.OrdinalIgnoreCase) ||
+                                                        string.Equals(property.Condition, $"'$({property.Name})' == ''", StringComparison.OrdinalIgnoreCase);
+                if (hasEmptyCondition || conditionIsCheckingForEmptyString)
+                {
+                    properties[property.Name] = new(property.Name, property.Value, buildFile.RelativePath);
+                }
+            }
+        }
+
+        return properties;
+    }
+
     public static IEnumerable<Dependency> GetTopLevelPackageDependencyInfos(ImmutableArray<ProjectBuildFile> buildFiles)
     {
-        Dictionary<string, (string, bool)> packageInfo = new(StringComparer.OrdinalIgnoreCase);
+        Dictionary<string, (string, bool, DependencyType)> packageInfo = new(StringComparer.OrdinalIgnoreCase);
         Dictionary<string, string> packageVersionInfo = new(StringComparer.OrdinalIgnoreCase);
-        Dictionary<string, string> propertyInfo = 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)
+            {
+                // Short of evaluating the entire project, there's no way to _really_ know what package version is
+                // going to be used, and even then we might not be able to update it.  As a best guess, we'll simply
+                // skip any property that has a condition _or_ where the condition is checking for an empty string.
+                var hasEmptyCondition = string.IsNullOrEmpty(property.Condition);
+                var conditionIsCheckingForEmptyString = string.Equals(property.Condition, $"$({property.Name}) == ''", StringComparison.OrdinalIgnoreCase) ||
+                                                        string.Equals(property.Condition, $"'$({property.Name})' == ''", StringComparison.OrdinalIgnoreCase);
+                if (hasEmptyCondition || conditionIsCheckingForEmptyString)
+                {
+                    propertyInfo[property.Name] = new(property.Name, property.Value, buildFile.RelativePath);
+                }
+            }
+
+            if (buildFile.IsOutsideBasePath)
+            {
+                continue;
+            }
+
             foreach (var packageItem in projectRoot.Items
                          .Where(i => (i.ItemType == "PackageReference" || i.ItemType == "GlobalPackageReference")))
             {
+                var dependencyType = packageItem.ItemType == "PackageReference" ? DependencyType.PackageReference : DependencyType.GlobalPackageReference;
                 var versionSpecification = packageItem.Metadata.FirstOrDefault(m => m.Name.Equals("Version", StringComparison.OrdinalIgnoreCase))?.Value
                                            ?? packageItem.Metadata.FirstOrDefault(m => m.Name.Equals("VersionOverride", StringComparison.OrdinalIgnoreCase))?.Value
                                            ?? string.Empty;
@@ -219,12 +198,12 @@ internal static partial class MSBuildHelper
                             var vSpec = string.IsNullOrEmpty(versionSpecification) || existingUpdate ? existingVersion : versionSpecification;
 
                             var isUpdate = existingUpdate && string.IsNullOrEmpty(packageItem.Include);
-                            packageInfo[attributeValue] = (vSpec, isUpdate);
+                            packageInfo[attributeValue] = (vSpec, isUpdate, dependencyType);
                         }
                         else
                         {
                             var isUpdate = !string.IsNullOrEmpty(packageItem.Update);
-                            packageInfo[attributeValue] = (versionSpecification, isUpdate);
+                            packageInfo[attributeValue] = (versionSpecification, isUpdate, dependencyType);
                         }
                     }
                 }
@@ -236,25 +215,11 @@ internal static partial class MSBuildHelper
                 packageVersionInfo[packageItem.Include] = packageItem.Metadata.FirstOrDefault(m => m.Name.Equals("Version", StringComparison.OrdinalIgnoreCase))?.Value
                                                           ?? string.Empty;
             }
-
-            foreach (var property in projectRoot.Properties)
-            {
-                // Short of evaluating the entire project, there's no way to _really_ know what package version is
-                // going to be used, and even then we might not be able to update it.  As a best guess, we'll simply
-                // skip any property that has a condition _or_ where the condition is checking for an empty string.
-                var hasEmptyCondition = string.IsNullOrEmpty(property.Condition);
-                var conditionIsCheckingForEmptyString = string.Equals(property.Condition, $"$({property.Name}) == ''", StringComparison.OrdinalIgnoreCase) ||
-                                                        string.Equals(property.Condition, $"'$({property.Name})' == ''", StringComparison.OrdinalIgnoreCase);
-                if (hasEmptyCondition || conditionIsCheckingForEmptyString)
-                {
-                    propertyInfo[property.Name] = property.Value;
-                }
-            }
         }
 
         foreach (var (name, info) in packageInfo)
         {
-            var (version, isUpdate) = info;
+            var (version, isUpdate, dependencyType) = info;
             if (version.Length != 0 || !packageVersionInfo.TryGetValue(name, out var packageVersion))
             {
                 packageVersion = version;
@@ -262,51 +227,51 @@ internal static partial class MSBuildHelper
 
             // Walk the property replacements until we don't find another one.
             var evaluationResult = GetEvaluatedValue(packageVersion, propertyInfo);
-            if (evaluationResult.ResultType != EvaluationResultType.Success)
-            {
-                // if we can't resolve the package version, don't report the dependency
-                continue;
-            }
-
-            packageVersion = evaluationResult.EvaluatedValue.TrimStart('[', '(').TrimEnd(']', ')');
+            packageVersion = evaluationResult.ResultType == EvaluationResultType.Success
+                ? evaluationResult.EvaluatedValue.TrimStart('[', '(').TrimEnd(']', ')')
+                : evaluationResult.EvaluatedValue;
 
             // We don't know the version for range requirements or wildcard
             // requirements, so return "" for these.
             yield return packageVersion.Contains(',') || packageVersion.Contains('*')
-                ? new Dependency(name, string.Empty, DependencyType.Unknown, IsUpdate: isUpdate)
-                : new Dependency(name, packageVersion, DependencyType.Unknown, IsUpdate: isUpdate);
+                ? new Dependency(name, string.Empty, dependencyType, EvaluationResult: evaluationResult, IsUpdate: isUpdate)
+                : new Dependency(name, packageVersion, dependencyType, EvaluationResult: evaluationResult, IsUpdate: isUpdate);
         }
     }
 
     /// <summary>
     /// Given an MSBuild string and a set of properties, returns our best guess at the final value MSBuild will evaluate to.
     /// </summary>
-    public static EvaluationResult GetEvaluatedValue(string msbuildString, Dictionary<string, string> propertyInfo, params string[] propertiesToIgnore)
+    public static EvaluationResult GetEvaluatedValue(string msbuildString, IReadOnlyDictionary<string, Property> propertyInfo, params string[] propertiesToIgnore)
     {
         var ignoredProperties = new HashSet<string>(propertiesToIgnore, StringComparer.OrdinalIgnoreCase);
         var seenProperties = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
 
+        string originalValue = msbuildString;
+        string? rootPropertyName = null;
         while (TryGetPropertyName(msbuildString, out var propertyName))
         {
+            rootPropertyName = propertyName;
+
             if (ignoredProperties.Contains(propertyName))
             {
-                return (EvaluationResultType.PropertyIgnored, msbuildString, $"Property '{propertyName}' is ignored.");
+                return new(EvaluationResultType.PropertyIgnored, originalValue, msbuildString, rootPropertyName, $"Property '{propertyName}' is ignored.");
             }
 
             if (!seenProperties.Add(propertyName))
             {
-                return (EvaluationResultType.CircularReference, msbuildString, $"Property '{propertyName}' has a circular reference.");
+                return new(EvaluationResultType.CircularReference, originalValue, msbuildString, rootPropertyName, $"Property '{propertyName}' has a circular reference.");
             }
 
-            if (!propertyInfo.TryGetValue(propertyName, out var propertyValue))
+            if (!propertyInfo.TryGetValue(propertyName, out var property))
             {
-                return (EvaluationResultType.PropertyNotFound, msbuildString, $"Property '{propertyName}' was not found.");
+                return new(EvaluationResultType.PropertyNotFound, originalValue, msbuildString, rootPropertyName, $"Property '{propertyName}' was not found.");
             }
 
-            msbuildString = msbuildString.Replace($"$({propertyName})", propertyValue);
+            msbuildString = msbuildString.Replace($"$({propertyName})", property.Value);
         }
 
-        return (EvaluationResultType.Success, msbuildString, null);
+        return new(EvaluationResultType.Success, originalValue, msbuildString, rootPropertyName, null);
     }
 
     public static bool TryGetPropertyName(string versionContent, [NotNullWhen(true)] out string? propertyName)
@@ -344,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();
@@ -373,12 +456,13 @@ internal static partial class MSBuildHelper
         }
     }
 
-    private static async Task<string> CreateTempProjectAsync(
+    internal static async Task<string> CreateTempProjectAsync(
         DirectoryInfo tempDir,
         string repoRoot,
         string projectPath,
         string targetFramework,
-        IReadOnlyCollection<Dependency> packages)
+        IReadOnlyCollection<Dependency> packages,
+        bool usePackageDownload = false)
     {
         var projectDirectory = Path.GetDirectoryName(projectPath);
         projectDirectory ??= repoRoot;
@@ -410,9 +494,9 @@ internal static partial class MSBuildHelper
             Environment.NewLine,
             packages
                 // empty `Version` attributes will cause the temporary project to not build
-                .Where(p => !string.IsNullOrWhiteSpace(p.Version))
+                .Where(p => (p.EvaluationResult is null || p.EvaluationResult.ResultType == EvaluationResultType.Success) && !string.IsNullOrWhiteSpace(p.Version))
                 // If all PackageReferences for a package are update-only mark it as such, otherwise it can cause package incoherence errors which do not exist in the repo.
-                .Select(static p => $"<PackageReference {(p.IsUpdate ? "Update" : "Include")}=\"{p.Name}\" Version=\"[{p.Version}]\" />"));
+                .Select(p => $"<{(usePackageDownload ? "PackageDownload" : "PackageReference")} {(p.IsUpdate ? "Update" : "Include")}=\"{p.Name}\" Version=\"[{p.Version}]\" />"));
 
         var projectContents = $"""
             <Project Sdk="Microsoft.NET.Sdk">
@@ -465,23 +549,34 @@ internal static partial class MSBuildHelper
     }
 
     internal static async Task<Dependency[]> GetAllPackageDependenciesAsync(
-        string repoRoot, string projectPath, string targetFramework, IReadOnlyCollection<Dependency> packages, Logger? logger = null)
+        string repoRoot,
+        string projectPath,
+        string targetFramework,
+        IReadOnlyCollection<Dependency> packages,
+        Logger? logger = null)
     {
         var tempDirectory = Directory.CreateTempSubdirectory("package-dependency-resolution_");
         try
         {
+            var topLevelPackagesNames = packages.Select(p => p.Name).ToHashSet(StringComparer.OrdinalIgnoreCase);
             var tempProjectPath = await CreateTempProjectAsync(tempDirectory, repoRoot, projectPath, targetFramework, packages);
 
             var (exitCode, stdout, stderr) = await ProcessEx.RunAsync("dotnet", $"build \"{tempProjectPath}\" /t:_ReportDependencies", workingDirectory: tempDirectory.FullName);
 
             if (exitCode == 0)
             {
+                ImmutableArray<string> tfms = [targetFramework];
                 var lines = stdout.Split('\n').Select(line => line.Trim());
                 var pattern = PackagePattern();
                 var allDependencies = lines
                     .Select(line => pattern.Match(line))
                     .Where(match => match.Success)
-                    .Select(match => new Dependency(match.Groups["PackageName"].Value, match.Groups["PackageVersion"].Value, DependencyType.Unknown))
+                    .Select(match =>
+                    {
+                        var packageName = match.Groups["PackageName"].Value;
+                        var isTransitive = !topLevelPackagesNames.Contains(packageName);
+                        return new Dependency(packageName, match.Groups["PackageVersion"].Value, DependencyType.Unknown, TargetFrameworks: tfms, IsTransitive: isTransitive);
+                    })
                     .ToArray();
 
                 return allDependencies;
@@ -504,12 +599,25 @@ internal static partial class MSBuildHelper
         }
     }
 
-    internal static string? GetGlobalJsonPath(string repoRootPath, string projectPath)
+    internal static bool TryGetGlobalJsonPath(string repoRootPath, string workspacePath, [NotNullWhen(returnValue: true)] out string? globalJsonPath)
+    {
+        globalJsonPath = PathHelper.GetFileInDirectoryOrParent(workspacePath, repoRootPath, "global.json", caseSensitive: false);
+        return globalJsonPath is not null;
+    }
+
+    internal static bool TryGetDotNetToolsJsonPath(string repoRootPath, string workspacePath, [NotNullWhen(returnValue: true)] out string? dotnetToolsJsonJsonPath)
     {
-        return PathHelper.GetFileInDirectoryOrParent(Path.GetDirectoryName(projectPath)!, repoRootPath, "global.json");
+        dotnetToolsJsonJsonPath = PathHelper.GetFileInDirectoryOrParent(workspacePath, repoRootPath, "./.config/dotnet-tools.json", caseSensitive: false);
+        return dotnetToolsJsonJsonPath is not null;
     }
 
-    internal static async Task<ImmutableArray<ProjectBuildFile>> LoadBuildFiles(string repoRootPath, string projectPath)
+    internal static bool TryGetDirectoryPackagesPropsPath(string repoRootPath, string workspacePath, [NotNullWhen(returnValue: true)] out string? directoryPackagesPropsPath)
+    {
+        directoryPackagesPropsPath = PathHelper.GetFileInDirectoryOrParent(workspacePath, repoRootPath, "./Directory.Packages.props", caseSensitive: false);
+        return directoryPackagesPropsPath is not null;
+    }
+
+    internal static async Task<(ImmutableArray<ProjectBuildFile> ProjectBuildFiles, string[] TargetFrameworks)> LoadBuildFilesAndTargetFrameworksAsync(string repoRootPath, string projectPath)
     {
         var buildFileList = new List<string>
         {
@@ -517,8 +625,9 @@ internal static partial class MSBuildHelper
         };
 
         // a global.json file might cause problems with the dotnet msbuild command; create a safe version temporarily
-        var globalJsonPath = GetGlobalJsonPath(repoRootPath, projectPath);
+        TryGetGlobalJsonPath(repoRootPath, projectPath, out var globalJsonPath);
         var safeGlobalJsonName = $"{globalJsonPath}{Guid.NewGuid()}";
+        HashSet<string> targetFrameworks = new(StringComparer.OrdinalIgnoreCase);
 
         try
         {
@@ -547,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
         {
@@ -567,25 +711,22 @@ internal static partial class MSBuildHelper
         }
 
         var repoRootPathPrefix = repoRootPath.NormalizePathToUnix() + "/";
-        var buildFilesInRepo = buildFileList
+        var buildFiles = buildFileList
             .Where(f => f.StartsWith(repoRootPathPrefix, StringComparison.OrdinalIgnoreCase))
+            .Distinct();
+        var result = buildFiles
             .Where(File.Exists)
-            .Distinct()
-            .ToArray();
-        var result = buildFilesInRepo
             .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();
 
-    internal enum EvaluationResultType
-    {
-        Success,
-        PropertyIgnored,
-        CircularReference,
-        PropertyNotFound,
-    }
+    // 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();
 }