dependabot-nuget 0.290.0 → 0.292.0

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

@@ -48,15 +48,15 @@ internal static class SdkProjectDiscovery
     {
         if (experimentsManager.UseDirectDiscovery)
         {
-            return await DiscoverWithBinLogAsync(repoRootPath, workspacePath, startingProjectPath, logger);
+            return await DiscoverWithBinLogAsync(repoRootPath, workspacePath, startingProjectPath, experimentsManager, logger);
         }
         else
         {
-            return await DiscoverWithTempProjectAsync(repoRootPath, workspacePath, startingProjectPath, logger);
+            return await DiscoverWithTempProjectAsync(repoRootPath, workspacePath, startingProjectPath, experimentsManager, logger);
         }
     }
 
-    public static async Task<ImmutableArray<ProjectDiscoveryResult>> DiscoverWithBinLogAsync(string repoRootPath, string workspacePath, string startingProjectPath, ILogger logger)
+    public static async Task<ImmutableArray<ProjectDiscoveryResult>> DiscoverWithBinLogAsync(string repoRootPath, string workspacePath, string startingProjectPath, ExperimentsManager experimentsManager, ILogger logger)
     {
         // N.b., there are many paths used in this function.  The MSBuild binary log always reports fully qualified paths, so that's what will be used
         // throughout until the very end when the appropriate kind of relative path is returned.
@@ -84,7 +84,7 @@ internal static class SdkProjectDiscovery
         Dictionary<string, HashSet<string>> additionalFiles = new(PathComparer.Instance);
         //         projectPath, additionalFiles
 
-        var tfms = await MSBuildHelper.GetTargetFrameworkValuesFromProject(repoRootPath, startingProjectPath, logger);
+        var tfms = await MSBuildHelper.GetTargetFrameworkValuesFromProject(repoRootPath, startingProjectPath, experimentsManager, logger);
         foreach (var tfm in tfms)
         {
             // create a binlog
@@ -92,7 +92,7 @@ internal static class SdkProjectDiscovery
             try
             {
                 // TODO: once the updater image has all relevant SDKs installed, we won't have to sideline global.json anymore
-                var (exitCode, stdOut, stdErr) = await MSBuildHelper.SidelineGlobalJsonAsync(startingProjectDirectory, repoRootPath, async () =>
+                var (exitCode, stdOut, stdErr) = await MSBuildHelper.HandleGlobalJsonAsync(startingProjectDirectory, repoRootPath, experimentsManager, async () =>
                 {
                     // the built-in target `GenerateBuildDependencyFile` forces resolution of all NuGet packages, but doesn't invoke a full build
                     var dependencyDiscoveryTargetsPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)!, "DependencyDiscovery.targets");
@@ -102,10 +102,11 @@ internal static class SdkProjectDiscovery
                         startingProjectPath,
                         "/t:_DiscoverDependencies",
                         $"/p:TargetFramework={tfm}",
-                        $"/p:CustomAfterMicrosoftCommonCrossTargetingTargets={dependencyDiscoveryTargetsPath};CustomAfterMicrosoftCommonTargets={dependencyDiscoveryTargetsPath}",
+                        $"/p:CustomAfterMicrosoftCommonCrossTargetingTargets={dependencyDiscoveryTargetsPath}",
+                        $"/p:CustomAfterMicrosoftCommonTargets={dependencyDiscoveryTargetsPath}",
                         $"/bl:{binLogPath}"
                     };
-                    var (exitCode, stdOut, stdErr) = await ProcessEx.RunAsync("dotnet", args, workingDirectory: startingProjectDirectory);
+                    var (exitCode, stdOut, stdErr) = await ProcessEx.RunDotnetWithoutMSBuildEnvironmentVariablesAsync(args, startingProjectDirectory, experimentsManager);
                     return (exitCode, stdOut, stdErr);
                 }, logger, retainMSBuildSdks: true);
                 MSBuildHelper.ThrowOnUnauthenticatedFeed(stdOut);
@@ -411,7 +412,7 @@ internal static class SdkProjectDiscovery
         return property.Value;
     }
 
-    public static async Task<ImmutableArray<ProjectDiscoveryResult>> DiscoverWithTempProjectAsync(string repoRootPath, string workspacePath, string projectPath, ILogger logger)
+    public static async Task<ImmutableArray<ProjectDiscoveryResult>> DiscoverWithTempProjectAsync(string repoRootPath, string workspacePath, string projectPath, ExperimentsManager experimentsManager, ILogger logger)
     {
         // Determine which targets and props files contribute to the build.
         var (buildFiles, projectTargetFrameworks) = await MSBuildHelper.LoadBuildFilesAndTargetFrameworksAsync(repoRootPath, projectPath);
@@ -476,7 +477,7 @@ internal static class SdkProjectDiscovery
                     dependencies = dependencies
                         .Select(d => d with { TargetFrameworks = tfms })
                         .ToImmutableArray();
-                    var transitiveDependencies = await GetTransitiveDependencies(repoRootPath, projectPath, tfms, dependencies, logger);
+                    var transitiveDependencies = await GetTransitiveDependencies(repoRootPath, projectPath, tfms, dependencies, experimentsManager, logger);
                     ImmutableArray<Dependency> allDependencies = dependencies.Concat(transitiveDependencies).Concat(sdkDependencies)
                         .OrderBy(d => d.Name)
                         .ToImmutableArray();
@@ -514,12 +515,19 @@ internal static class SdkProjectDiscovery
         return results.ToImmutable();
     }
 
-    private static async Task<ImmutableArray<Dependency>> GetTransitiveDependencies(string repoRootPath, string projectPath, ImmutableArray<string> tfms, ImmutableArray<Dependency> directDependencies, ILogger logger)
+    private static async Task<ImmutableArray<Dependency>> GetTransitiveDependencies(
+        string repoRootPath,
+        string projectPath,
+        ImmutableArray<string> tfms,
+        ImmutableArray<Dependency> directDependencies,
+        ExperimentsManager experimentsManager,
+        ILogger logger
+    )
     {
         Dictionary<string, Dependency> transitiveDependencies = new(StringComparer.OrdinalIgnoreCase);
         foreach (var tfm in tfms)
         {
-            var tfmDependencies = await MSBuildHelper.GetAllPackageDependenciesAsync(repoRootPath, projectPath, tfm, directDependencies, logger);
+            var tfmDependencies = await MSBuildHelper.GetAllPackageDependenciesAsync(repoRootPath, projectPath, tfm, directDependencies, experimentsManager, logger);
             foreach (var dependency in tfmDependencies.Where(d => d.IsTransitive))
             {
                 if (!transitiveDependencies.TryGetValue(dependency.Name, out var existingDependency))

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

@@ -4,7 +4,9 @@ public enum ErrorType
 {
     None,
     AuthenticationFailure,
+    BadRequirement,
     MissingFile,
     UpdateNotPossible,
+    DependencyFileNotParseable,
     Unknown,
 }

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

@@ -6,6 +6,7 @@ namespace NuGetUpdater.Core;
 
 public record ExperimentsManager
 {
+    public bool InstallDotnetSdks { get; init; } = false;
     public bool UseLegacyDependencySolver { get; init; } = false;
     public bool UseDirectDiscovery { get; init; } = false;
 
@@ -13,6 +14,7 @@ public record ExperimentsManager
     {
         return new()
         {
+            ["nuget_install_dotnet_sdks"] = InstallDotnetSdks,
             ["nuget_legacy_dependency_solver"] = UseLegacyDependencySolver,
             ["nuget_use_direct_discovery"] = UseDirectDiscovery,
         };
@@ -22,24 +24,48 @@ public record ExperimentsManager
     {
         return new ExperimentsManager()
         {
+            InstallDotnetSdks = IsEnabled(experiments, "nuget_install_dotnet_sdks"),
             UseLegacyDependencySolver = IsEnabled(experiments, "nuget_legacy_dependency_solver"),
             UseDirectDiscovery = IsEnabled(experiments, "nuget_use_direct_discovery"),
         };
     }
 
-    public static async Task<ExperimentsManager> FromJobFileAsync(string jobFilePath, ILogger logger)
+    public static async Task<(ExperimentsManager ExperimentsManager, NativeResult? ErrorResult)> FromJobFileAsync(string jobFilePath)
     {
-        var jobFileContent = await File.ReadAllTextAsync(jobFilePath);
+        var experimentsManager = new ExperimentsManager();
+        NativeResult? errorResult = null;
         try
         {
+            var jobFileContent = await File.ReadAllTextAsync(jobFilePath);
             var jobWrapper = RunWorker.Deserialize(jobFileContent);
-            return GetExperimentsManager(jobWrapper.Job.Experiments);
+            experimentsManager = GetExperimentsManager(jobWrapper.Job.Experiments);
+        }
+        catch (BadRequirementException ex)
+        {
+            errorResult = new NativeResult
+            {
+                ErrorType = ErrorType.BadRequirement,
+                ErrorDetails = ex.Message,
+            };
         }
         catch (JsonException ex)
         {
-            logger.Info($"Error deserializing job file: {ex.ToString()}: {jobFileContent}");
-            return new ExperimentsManager();
+            errorResult = new NativeResult
+            {
+                ErrorType = ErrorType.Unknown,
+                ErrorDetails = $"Error deserializing job file: {ex}: {File.ReadAllText(jobFilePath)}",
+            };
+        }
+        catch (Exception ex)
+        {
+            errorResult = new NativeResult
+            {
+                ErrorType = ErrorType.Unknown,
+                ErrorDetails = ex.ToString(),
+            };
         }
+
+        return (experimentsManager, errorResult);
     }
 
     private static bool IsEnabled(Dictionary<string, object>? experiments, string experimentName)

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/NuGetUpdater.Core.csproj

@@ -26,6 +26,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <InternalsVisibleTo Include="NuGetUpdater.Cli" />
     <InternalsVisibleTo Include="NuGetUpdater.Cli.Test" />
     <InternalsVisibleTo Include="NuGetUpdater.Core.Test" />
   </ItemGroup>

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/BadRequirement.cs

@@ -0,0 +1,10 @@
+namespace NuGetUpdater.Core.Run.ApiModel;
+
+public record BadRequirement : JobErrorBase
+{
+    public BadRequirement(string details)
+        : base("illformed_requirement")
+    {
+        Details["message"] = details;
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/CommitOptions.cs

@@ -4,5 +4,5 @@ public record CommitOptions
 {
     public string? Prefix { get; init; } = null;
     public string? PrefixDevelopment { get; init; } = null;
-    public string? IncludeScope { get; init; } = null;
+    public bool? IncludeScope { get; init; } = null;
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/DependencyFileNotFound.cs

@@ -2,9 +2,10 @@ namespace NuGetUpdater.Core.Run.ApiModel;
 
 public record DependencyFileNotFound : JobErrorBase
 {
-    public DependencyFileNotFound(string filePath)
+    public DependencyFileNotFound(string message, string filePath)
         : base("dependency_file_not_found")
     {
-        Details = filePath;
+        Details["message"] = message;
+        Details["file-path"] = filePath;
     }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/JobErrorBase.cs

@@ -13,6 +13,5 @@ public abstract record JobErrorBase
     public string Type { get; }
 
     [JsonPropertyName("error-details")]
-    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
-    public object? Details { get; init; } = null;
+    public Dictionary<string, object> Details { get; init; } = new();
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/JobRepoNotFound.cs

@@ -5,9 +5,6 @@ public record JobRepoNotFound : JobErrorBase
     public JobRepoNotFound(string message)
         : base("job_repo_not_found")
     {
-        Details = new Dictionary<string, string>()
-        {
-            ["message"] = message
-        };
+        Details["message"] = message;
     }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/PrivateSourceAuthenticationFailure.cs

@@ -5,6 +5,6 @@ public record PrivateSourceAuthenticationFailure : JobErrorBase
     public PrivateSourceAuthenticationFailure(string[] urls)
         : base("private_source_authentication_failure")
     {
-        Details = $"({string.Join("|", urls)})";
+        Details["source"] = $"({string.Join("|", urls)})";
     }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/UnknownError.cs

@@ -2,9 +2,13 @@ namespace NuGetUpdater.Core.Run.ApiModel;
 
 public record UnknownError : JobErrorBase
 {
-    public UnknownError(string details)
+    public UnknownError(Exception ex, string jobId)
         : base("unknown_error")
     {
-        Details = details;
+        Details["error-class"] = ex.GetType().Name;
+        Details["error-message"] = ex.Message;
+        Details["error-backtrace"] = ex.StackTrace ?? "<unknown>";
+        Details["package-manager"] = "nuget";
+        Details["job-id"] = jobId;
     }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/UpdateNotPossible.cs

@@ -5,6 +5,6 @@ public record UpdateNotPossible : JobErrorBase
     public UpdateNotPossible(string[] dependencies)
         : base("update_not_possible")
     {
-        Details = dependencies;
+        Details["dependencies"] = dependencies;
     }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/RunWorker.cs

@@ -12,6 +12,7 @@ namespace NuGetUpdater.Core.Run;
 
 public class RunWorker
 {
+    private readonly string _jobId;
     private readonly IApiHandler _apiHandler;
     private readonly ILogger _logger;
     private readonly IDiscoveryWorker _discoveryWorker;
@@ -25,8 +26,9 @@ public class RunWorker
         Converters = { new JsonStringEnumConverter(), new RequirementConverter(), new VersionConverter() },
     };
 
-    public RunWorker(IApiHandler apiHandler, IDiscoveryWorker discoverWorker, IAnalyzeWorker analyzeWorker, IUpdaterWorker updateWorker, ILogger logger)
+    public RunWorker(string jobId, IApiHandler apiHandler, IDiscoveryWorker discoverWorker, IAnalyzeWorker analyzeWorker, IUpdaterWorker updateWorker, ILogger logger)
     {
+        _jobId = jobId;
         _apiHandler = apiHandler;
         _logger = logger;
         _discoveryWorker = discoverWorker;
@@ -87,9 +89,13 @@ public class RunWorker
         {
             error = new PrivateSourceAuthenticationFailure(lastUsedPackageSourceUrls);
         }
+        catch (BadRequirementException ex)
+        {
+            error = new BadRequirement(ex.Message);
+        }
         catch (MissingFileException ex)
         {
-            error = new DependencyFileNotFound(ex.FilePath);
+            error = new DependencyFileNotFound("file not found", ex.FilePath);
         }
         catch (UpdateNotPossibleException ex)
         {
@@ -97,7 +103,7 @@ public class RunWorker
         }
         catch (Exception ex)
         {
-            error = new UnknownError(ex.ToString());
+            error = new UnknownError(ex, _jobId);
         }
 
         if (error is not null)

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

@@ -5,12 +5,13 @@ internal static class LockFileUpdater
     public static async Task UpdateLockFileAsync(
         string repoRootPath,
         string projectPath,
+        ExperimentsManager experimentsManager,
         ILogger logger)
     {
         var projectDirectory = Path.GetDirectoryName(projectPath)!;
-        await MSBuildHelper.SidelineGlobalJsonAsync(projectDirectory, repoRootPath, async () =>
+        await MSBuildHelper.HandleGlobalJsonAsync(projectDirectory, repoRootPath, experimentsManager, async () =>
         {
-            var (exitCode, stdout, stderr) = await ProcessEx.RunAsync("dotnet", ["restore", "--force-evaluate", projectPath], workingDirectory: projectDirectory);
+            var (exitCode, stdout, stderr) = await ProcessEx.RunDotnetWithoutMSBuildEnvironmentVariablesAsync(["restore", "--force-evaluate", "-p:EnableWindowsTargeting=true", projectPath], projectDirectory, experimentsManager);
             if (exitCode != 0)
             {
                 logger.Error($"      Lock file update failed.\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}");

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

@@ -37,17 +37,17 @@ internal static class PackageReferenceUpdater
         // Get the set of all top-level dependencies in the current project
         var topLevelDependencies = MSBuildHelper.GetTopLevelPackageDependencyInfos(buildFiles).ToArray();
 
-        if (!await DoesDependencyRequireUpdateAsync(repoRootPath, projectPath, tfms, topLevelDependencies, dependencyName, newDependencyVersion, logger))
+        if (!await DoesDependencyRequireUpdateAsync(repoRootPath, projectPath, tfms, topLevelDependencies, dependencyName, newDependencyVersion, experimentsManager, logger))
         {
             return;
         }
 
-        var peerDependencies = await GetUpdatedPeerDependenciesAsync(repoRootPath, projectPath, tfms, dependencyName, newDependencyVersion, logger);
+        var peerDependencies = await GetUpdatedPeerDependenciesAsync(repoRootPath, projectPath, tfms, dependencyName, newDependencyVersion, experimentsManager, logger);
         if (experimentsManager.UseLegacyDependencySolver)
         {
             if (isTransitive)
             {
-                await UpdateTransitiveDependencyAsync(repoRootPath, projectPath, dependencyName, newDependencyVersion, buildFiles, logger);
+                await UpdateTransitiveDependencyAsync(repoRootPath, projectPath, dependencyName, newDependencyVersion, buildFiles, experimentsManager, logger);
             }
             else
             {
@@ -56,7 +56,7 @@ internal static class PackageReferenceUpdater
                     return;
                 }
 
-                await UpdateTopLevelDepdendency(repoRootPath, buildFiles, tfms, dependencyName, previousDependencyVersion, newDependencyVersion, peerDependencies, logger);
+                await UpdateTopLevelDepdendency(repoRootPath, buildFiles, tfms, dependencyName, previousDependencyVersion, newDependencyVersion, peerDependencies, experimentsManager, logger);
             }
         }
         else
@@ -66,10 +66,10 @@ internal static class PackageReferenceUpdater
                 return;
             }
 
-            await UpdateDependencyWithConflictResolution(repoRootPath, buildFiles, tfms, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive, peerDependencies, logger);
+            await UpdateDependencyWithConflictResolution(repoRootPath, buildFiles, tfms, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive, peerDependencies, experimentsManager, logger);
         }
 
-        if (!await AreDependenciesCoherentAsync(repoRootPath, projectPath, dependencyName, logger, buildFiles, tfms))
+        if (!await AreDependenciesCoherentAsync(repoRootPath, projectPath, dependencyName, buildFiles, tfms, experimentsManager, logger))
         {
             return;
         }
@@ -87,6 +87,7 @@ internal static class PackageReferenceUpdater
         string newDependencyVersion,
         bool isTransitive,
         IDictionary<string, string> peerDependencies,
+        ExperimentsManager experimentsManager,
         ILogger logger)
     {
         var topLevelDependencies = MSBuildHelper.GetTopLevelPackageDependencyInfos(buildFiles).ToArray();
@@ -107,7 +108,7 @@ internal static class PackageReferenceUpdater
         {
             foreach (var tfm in targetFrameworks)
             {
-                var resolvedDependencies = await MSBuildHelper.ResolveDependencyConflicts(repoRootPath, projectFile.Path, tfm, topLevelDependencies, dependenciesToUpdate, logger);
+                var resolvedDependencies = await MSBuildHelper.ResolveDependencyConflicts(repoRootPath, projectFile.Path, tfm, topLevelDependencies, dependenciesToUpdate, experimentsManager, logger);
                 if (resolvedDependencies is null)
                 {
                     logger.Warn($"    Unable to resolve dependency conflicts for {projectFile.Path}.");
@@ -118,7 +119,7 @@ internal static class PackageReferenceUpdater
                 if (isTransitive && !isDependencyTopLevel && isDependencyInResolutionSet)
                 {
                     // a transitive dependency had to be pinned; add it here
-                    await UpdateTransitiveDependencyAsync(repoRootPath, projectPath, dependencyName, newDependencyVersion, buildFiles, logger);
+                    await UpdateTransitiveDependencyAsync(repoRootPath, projectPath, dependencyName, newDependencyVersion, buildFiles, experimentsManager, logger);
                 }
 
                 // update all resolved dependencies that aren't the initial dependency
@@ -143,6 +144,7 @@ internal static class PackageReferenceUpdater
         Dependency[] topLevelDependencies,
         string dependencyName,
         string newDependencyVersion,
+        ExperimentsManager experimentsManager,
         ILogger logger)
     {
         var newDependencyNuGetVersion = NuGetVersion.Parse(newDependencyVersion);
@@ -157,6 +159,7 @@ internal static class PackageReferenceUpdater
                 projectPath,
                 tfm,
                 topLevelDependencies,
+                experimentsManager,
                 logger);
             foreach (var dependency in dependencies)
             {
@@ -203,7 +206,15 @@ internal static class PackageReferenceUpdater
         return true;
     }
 
-    private static async Task UpdateTransitiveDependencyAsync(string repoRootPath, string projectPath, string dependencyName, string newDependencyVersion, ImmutableArray<ProjectBuildFile> buildFiles, ILogger logger)
+    private static async Task UpdateTransitiveDependencyAsync(
+        string repoRootPath,
+        string projectPath,
+        string dependencyName,
+        string newDependencyVersion,
+        ImmutableArray<ProjectBuildFile> buildFiles,
+        ExperimentsManager experimentsManager,
+        ILogger logger
+    )
     {
         var directoryPackagesWithPinning = buildFiles.OfType<ProjectBuildFile>()
             .FirstOrDefault(bf => IsCpmTransitivePinningEnabled(bf));
@@ -213,7 +224,7 @@ internal static class PackageReferenceUpdater
         }
         else
         {
-            await AddTransitiveDependencyAsync(repoRootPath, projectPath, dependencyName, newDependencyVersion, logger);
+            await AddTransitiveDependencyAsync(repoRootPath, projectPath, dependencyName, newDependencyVersion, experimentsManager, logger);
         }
     }
 
@@ -302,15 +313,19 @@ internal static class PackageReferenceUpdater
         directoryPackages.Update(updatedXml);
     }
 
-    private static async Task AddTransitiveDependencyAsync(string repoRootPath, string projectPath, string dependencyName, string newDependencyVersion, ILogger logger)
+    private static async Task AddTransitiveDependencyAsync(string repoRootPath, string projectPath, string dependencyName, string newDependencyVersion, ExperimentsManager experimentsManager, ILogger logger)
     {
         var projectDirectory = Path.GetDirectoryName(projectPath)!;
-        await MSBuildHelper.SidelineGlobalJsonAsync(projectDirectory, repoRootPath, async () =>
+        await MSBuildHelper.HandleGlobalJsonAsync(projectDirectory, repoRootPath, experimentsManager, async () =>
         {
             logger.Info($"    Adding [{dependencyName}/{newDependencyVersion}] as a top-level package reference.");
 
             // see https://learn.microsoft.com/nuget/consume-packages/install-use-packages-dotnet-cli
-            var (exitCode, stdout, stderr) = await ProcessEx.RunAsync("dotnet", ["add", projectPath, "package", dependencyName, "--version", newDependencyVersion], workingDirectory: projectDirectory);
+            var (exitCode, stdout, stderr) = await ProcessEx.RunDotnetWithoutMSBuildEnvironmentVariablesAsync(
+                ["add", projectPath, "package", dependencyName, "--version", newDependencyVersion],
+                projectDirectory,
+                experimentsManager
+            );
             MSBuildHelper.ThrowOnUnauthenticatedFeed(stdout);
             if (exitCode != 0)
             {
@@ -331,13 +346,14 @@ internal static class PackageReferenceUpdater
         string[] tfms,
         string dependencyName,
         string newDependencyVersion,
+        ExperimentsManager experimentsManager,
         ILogger logger)
     {
         var newDependency = new[] { new Dependency(dependencyName, newDependencyVersion, DependencyType.Unknown) };
         var tfmsAndDependencies = new Dictionary<string, Dependency[]>();
         foreach (var tfm in tfms)
         {
-            var dependencies = await MSBuildHelper.GetAllPackageDependenciesAsync(repoRootPath, projectPath, tfm, newDependency, logger);
+            var dependencies = await MSBuildHelper.GetAllPackageDependenciesAsync(repoRootPath, projectPath, tfm, newDependency, experimentsManager, logger);
             tfmsAndDependencies[tfm] = dependencies;
         }
 
@@ -386,6 +402,7 @@ internal static class PackageReferenceUpdater
         string previousDependencyVersion,
         string newDependencyVersion,
         IDictionary<string, string> peerDependencies,
+        ExperimentsManager experimentsManager,
         ILogger logger)
     {
         // update dependencies...
@@ -407,7 +424,7 @@ internal static class PackageReferenceUpdater
         {
             foreach (string tfm in targetFrameworks)
             {
-                var resolvedDependencies = await MSBuildHelper.ResolveDependencyConflictsWithBruteForce(repoRootPath, projectFile.Path, tfm, updatedTopLevelDependencies, logger);
+                var resolvedDependencies = await MSBuildHelper.ResolveDependencyConflictsWithBruteForce(repoRootPath, projectFile.Path, tfm, updatedTopLevelDependencies, experimentsManager, logger);
                 if (resolvedDependencies is null)
                 {
                     logger.Info($"    Unable to resolve dependency conflicts for {projectFile.Path}.");
@@ -697,13 +714,21 @@ internal static class PackageReferenceUpdater
                     ?? e.GetAttributeOrSubElementValue("VersionOverride", StringComparison.OrdinalIgnoreCase)) is not null;
         });
 
-    private static async Task<bool> AreDependenciesCoherentAsync(string repoRootPath, string projectPath, string dependencyName, ILogger logger, ImmutableArray<ProjectBuildFile> buildFiles, string[] tfms)
+    private static async Task<bool> AreDependenciesCoherentAsync(
+        string repoRootPath,
+        string projectPath,
+        string dependencyName,
+        ImmutableArray<ProjectBuildFile> buildFiles,
+        string[] tfms,
+        ExperimentsManager experimentsManager,
+        ILogger logger
+    )
     {
         var updatedTopLevelDependencies = MSBuildHelper.GetTopLevelPackageDependencyInfos(buildFiles).ToArray();
         foreach (var tfm in tfms)
         {
-            var updatedPackages = await MSBuildHelper.GetAllPackageDependenciesAsync(repoRootPath, projectPath, tfm, updatedTopLevelDependencies, logger);
-            var dependenciesAreCoherent = await MSBuildHelper.DependenciesAreCoherentAsync(repoRootPath, projectPath, tfm, updatedPackages, logger);
+            var updatedPackages = await MSBuildHelper.GetAllPackageDependenciesAsync(repoRootPath, projectPath, tfm, updatedTopLevelDependencies, experimentsManager, logger);
+            var dependenciesAreCoherent = await MSBuildHelper.DependenciesAreCoherentAsync(repoRootPath, projectPath, tfm, updatedPackages, experimentsManager, logger);
             if (!dependenciesAreCoherent)
             {
                 logger.Warn($"    Package [{dependencyName}] could not be updated in [{projectPath}] because it would cause a dependency conflict.");

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

@@ -232,7 +232,7 @@ public class UpdaterWorker : IUpdaterWorker
         var packagesLockFullPath = additionalFiles.Where(p => Path.GetFileName(p).Equals(ProjectHelper.PackagesLockJsonFileName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
         if (packagesLockFullPath is not null)
         {
-            await LockFileUpdater.UpdateLockFileAsync(repoRootPath, projectPath, _logger);
+            await LockFileUpdater.UpdateLockFileAsync(repoRootPath, projectPath, _experimentsManager, _logger);
         }
     }
 }

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

@@ -13,7 +13,18 @@ namespace NuGetUpdater.Core.Updater
                 getContent: () => File.ReadAllText(projectFilePath),
                 setContent: s => File.WriteAllText(projectFilePath, s),
                 nodeFinder: doc => doc.Descendants()
-                    .FirstOrDefault(e => e.Name == "Import" && e.GetAttributeValue("Project") == @"$(VSToolsPath)\WebApplications\Microsoft.WebApplication.targets")
+                    .Where(e => e.Name == "Import")
+                    .FirstOrDefault(e =>
+                    {
+                        var projectPath = e.GetAttributeValue("Project");
+                        if (projectPath is not null)
+                        {
+                            var projectFileName = Path.GetFileName(projectPath.NormalizePathToUnix());
+                            return projectFileName.Equals("Microsoft.WebApplication.targets", StringComparison.OrdinalIgnoreCase);
+                        }
+
+                        return false;
+                    })
                     as XmlNodeSyntax,
                 preProcessor: n =>
                 {

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

@@ -395,7 +395,6 @@ public class PackageManager
                                     if (await AreAllParentsCompatibleAsync(existingPackages, existingPackage, targetFramework, projectDirectory, logger) == true)
                                     {
                                         existingPackage.CurrentVersion = dependencyOldVersion;
-                                        string NewVersion = dependency.CurrentVersion;
                                         existingPackage.NewVersion = dependency.CurrentVersion;
                                         await UpdateVersion(existingPackages, existingPackage, targetFramework, projectDirectory, logger);
                                     }
@@ -593,12 +592,6 @@ public class PackageManager
             return null;
         }
 
-        // If the current version of the parent is less than the current version of the dependency
-        else if (CurrentVersion < currentVersionDependency)
-        {
-            return currentVersionDependency;
-        }
-
         // Loop from the current version to the latest version, use next patch as a limit (unless there's a limit) so it doesn't look for versions that don't exist
         for (NuGetVersion version = CurrentVersion; version <= latestVersion; version = NextPatch(version, versions))
         {