dependabot-nuget 0.263.0 → 0.265.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/Extensions.cs

@@ -0,0 +1,36 @@
+using System.Collections.Immutable;
+
+using NuGet.Frameworks;
+using NuGet.Versioning;
+
+using NuGetUpdater.Core;
+
+internal static class Extensions
+{
+    public static ImmutableArray<Dependency> GetDependencies(this ImmutableDictionary<NuGetFramework, ImmutableArray<Dependency>> dependenciesByTfm)
+    {
+        Dictionary<string, Dependency> dependencies = [];
+        foreach (var (_framework, dependenciesForTfm) in dependenciesByTfm)
+        {
+            foreach (var dependency in dependenciesForTfm)
+            {
+                if (dependencies.TryGetValue(dependency.Name, out Dependency? value))
+                {
+                    if (NuGetVersion.Parse(value.Version!) < NuGetVersion.Parse(dependency.Version!))
+                    {
+                        dependencies[dependency.Name] = dependency with
+                        {
+                            TargetFrameworks = [.. value.TargetFrameworks ?? [], .. dependency.TargetFrameworks ?? []]
+                        };
+                    }
+                }
+                else
+                {
+                    dependencies.Add(dependency.Name, dependency);
+                }
+            }
+        }
+
+        return [.. dependencies.Values];
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/NuGetContext.cs

@@ -0,0 +1,128 @@
+using System.Collections.Immutable;
+using System.Text;
+
+using NuGet.CommandLine;
+using NuGet.Common;
+using NuGet.Configuration;
+using NuGet.Packaging.Core;
+using NuGet.Protocol;
+using NuGet.Protocol.Core.Types;
+using NuGet.Versioning;
+
+namespace NuGetUpdater.Core.Analyze;
+
+internal record NuGetContext : IDisposable
+{
+    public SourceCacheContext SourceCacheContext { get; }
+    public PackageDownloadContext PackageDownloadContext { get; }
+    public string CurrentDirectory { get; }
+    public ISettings Settings { get; }
+    public IMachineWideSettings MachineWideSettings { get; }
+    public ImmutableArray<PackageSource> PackageSources { get; }
+    public ILogger Logger { get; }
+    public string TempPackageDirectory { get; }
+
+    public NuGetContext(string? currentDirectory = null, ILogger? logger = null)
+    {
+        SourceCacheContext = new SourceCacheContext();
+        PackageDownloadContext = new PackageDownloadContext(SourceCacheContext);
+        CurrentDirectory = currentDirectory ?? Environment.CurrentDirectory;
+        MachineWideSettings = new CommandLineMachineWideSettings();
+        Settings = NuGet.Configuration.Settings.LoadDefaultSettings(
+            CurrentDirectory,
+            configFileName: null,
+            MachineWideSettings);
+        var sourceProvider = new PackageSourceProvider(Settings);
+        PackageSources = sourceProvider.LoadPackageSources()
+            .Where(p => p.IsEnabled)
+            .ToImmutableArray();
+        Logger = logger ?? NullLogger.Instance;
+        TempPackageDirectory = Path.Combine(Path.GetTempPath(), ".dependabot", "packages");
+    }
+
+    public void Dispose()
+    {
+        SourceCacheContext.Dispose();
+    }
+
+    private readonly Dictionary<PackageIdentity, string?> _packageInfoUrlCache = new();
+
+    public async Task<string?> GetPackageInfoUrlAsync(string packageId, string packageVersion, CancellationToken cancellationToken)
+    {
+        var packageIdentity = new PackageIdentity(packageId, NuGetVersion.Parse(packageVersion));
+        if (_packageInfoUrlCache.TryGetValue(packageIdentity, out var cachedUrl))
+        {
+            return cachedUrl;
+        }
+
+        var infoUrl = await FindPackageInfoUrlAsync(packageIdentity, cancellationToken);
+        _packageInfoUrlCache[packageIdentity] = infoUrl;
+
+        return infoUrl;
+    }
+
+    private async Task<string?> FindPackageInfoUrlAsync(PackageIdentity packageIdentity, CancellationToken cancellationToken)
+    {
+        var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(Settings);
+        var sourceMapping = PackageSourceMapping.GetPackageSourceMapping(Settings);
+        var packageSources = sourceMapping.GetConfiguredPackageSources(packageIdentity.Id).ToHashSet();
+        var sources = packageSources.Count == 0
+            ? PackageSources
+            : PackageSources
+                .Where(p => packageSources.Contains(p.Name))
+                .ToImmutableArray();
+
+        var message = new StringBuilder();
+        message.AppendLine($"finding info url for {packageIdentity}, using package sources: {string.Join(", ", sources.Select(s => s.Name))}");
+
+        foreach (var source in sources)
+        {
+            message.AppendLine($"  checking {source.Name}");
+            var sourceRepository = Repository.Factory.GetCoreV3(source);
+            var feed = await sourceRepository.GetResourceAsync<MetadataResource>(cancellationToken);
+            if (feed is null)
+            {
+                message.AppendLine($"    feed for {source.Name} was null");
+                continue;
+            }
+
+            var existsInFeed = await feed.Exists(
+                packageIdentity,
+                includeUnlisted: false,
+                SourceCacheContext,
+                NullLogger.Instance,
+                cancellationToken);
+            if (!existsInFeed)
+            {
+                message.AppendLine($"    package {packageIdentity} does not exist in {source.Name}");
+                continue;
+            }
+
+            var downloadResource = await sourceRepository.GetResourceAsync<DownloadResource>(cancellationToken);
+            using var downloadResult = await downloadResource.GetDownloadResourceResultAsync(packageIdentity, PackageDownloadContext, globalPackagesFolder, Logger, cancellationToken);
+            if (downloadResult.Status == DownloadResourceResultStatus.Available)
+            {
+                var repositoryMetadata = downloadResult.PackageReader.NuspecReader.GetRepositoryMetadata();
+                message.AppendLine($"    repometadata: type=[{repositoryMetadata.Type}], url=[{repositoryMetadata.Url}], branch=[{repositoryMetadata.Branch}], commit=[{repositoryMetadata.Commit}]");
+                if (!string.IsNullOrEmpty(repositoryMetadata.Url))
+                {
+                    return repositoryMetadata.Url;
+                }
+            }
+            else
+            {
+                message.AppendLine($"    download result status: {downloadResult.Status}");
+            }
+
+            var metadataResource = await sourceRepository.GetResourceAsync<PackageMetadataResource>(cancellationToken);
+            var metadata = await metadataResource.GetMetadataAsync(packageIdentity, SourceCacheContext, Logger, cancellationToken);
+            var url = metadata.ProjectUrl ?? metadata.LicenseUrl;
+            if (url is not null)
+            {
+                return url.ToString();
+            }
+        }
+
+        return null;
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/Requirement.cs

@@ -0,0 +1,105 @@
+using System.Collections.Immutable;
+
+using NuGet.Versioning;
+
+namespace NuGetUpdater.Core.Analyze;
+
+/// <summary>
+/// A Requirement is a set of one or more version restrictions. It supports a
+/// few (=, !=, >, <, >=, <=, ~>) different restriction operators.
+/// </summary>
+/// <remarks>
+/// See Gem::Version for a description on how versions and requirements work
+/// together in RubyGems.
+/// </remarks>
+public class Requirement
+{
+    private static readonly ImmutableDictionary<string, Func<NuGetVersion, NuGetVersion, bool>> Operators = new Dictionary<string, Func<NuGetVersion, NuGetVersion, bool>>()
+    {
+        ["="] = (v, r) => v == r,
+        ["!="] = (v, r) => v != r,
+        [">"] = (v, r) => v > r,
+        ["<"] = (v, r) => v < r,
+        [">="] = (v, r) => v >= r,
+        ["<="] = (v, r) => v <= r,
+        ["~>"] = (v, r) => v >= r && v.Version < Bump(r),
+    }.ToImmutableDictionary();
+
+    public static Requirement Parse(string requirement)
+    {
+        var splitIndex = requirement.LastIndexOfAny(['=', '>', '<']);
+
+        // Throw if the requirement is all operator and no version.
+        if (splitIndex == requirement.Length - 1)
+        {
+            throw new ArgumentException($"`{requirement}` is a invalid requirement string", nameof(requirement));
+        }
+
+        string[] parts = splitIndex == -1
+            ? [requirement.Trim()]
+            : [requirement[..(splitIndex + 1)].Trim(), requirement[(splitIndex + 1)..].Trim()];
+
+        var op = parts.Length == 1 ? "=" : parts[0];
+        var version = NuGetVersion.Parse(parts[^1]);
+
+        return new Requirement(op, version);
+    }
+
+    public string Operator { get; }
+    public NuGetVersion Version { get; }
+
+    public Requirement(string op, NuGetVersion version)
+    {
+        if (!Operators.ContainsKey(op))
+        {
+            throw new ArgumentException("Invalid operator", nameof(op));
+        }
+
+        Operator = op;
+        Version = version;
+    }
+
+    public override string ToString()
+    {
+        return $"{Operator} {Version}";
+    }
+
+    public bool IsSatisfiedBy(NuGetVersion version)
+    {
+        return Operators[Operator](version, Version);
+    }
+
+    private static readonly Dictionary<string, Version> BumpMap = [];
+    /// <summary>
+    /// Return a new version object where the next to the last revision
+    /// number is one greater (e.g., 5.3.1 => 5.4).
+    /// </summary>
+    /// <remarks>
+    /// This logic intended to be similar to RubyGems Gem::Version#bump
+    /// </remarks>
+    public static Version Bump(NuGetVersion version)
+    {
+        if (BumpMap.TryGetValue(version.OriginalVersion!, out var bumpedVersion))
+        {
+            return bumpedVersion;
+        }
+
+        var versionParts = version.OriginalVersion! // Get the original string this version was created from
+            .Split('-')[0] // Get the version part without pre-release
+            .Split('.') // Split into Major.Minor.Patch.Revision if present
+            .Select(int.Parse)
+            .ToArray();
+
+        if (versionParts.Length > 1)
+        {
+            versionParts = versionParts[..^1]; // Remove the last part
+        }
+
+        versionParts[^1]++; // Increment the new last part
+
+        bumpedVersion = NuGetVersion.Parse(string.Join('.', versionParts)).Version;
+        BumpMap[version.OriginalVersion!] = bumpedVersion;
+
+        return bumpedVersion;
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/RequirementConverter.cs

@@ -0,0 +1,17 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace NuGetUpdater.Core.Analyze;
+
+public class RequirementConverter : JsonConverter<Requirement>
+{
+    public override Requirement? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        return Requirement.Parse(reader.GetString()!);
+    }
+
+    public override void Write(Utf8JsonWriter writer, Requirement value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString());
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/SecurityVulnerability.cs

@@ -0,0 +1,11 @@
+using System.Collections.Immutable;
+
+namespace NuGetUpdater.Core.Analyze;
+
+public sealed record SecurityVulnerability
+{
+    public required string DependencyName { get; init; }
+    public required string PackageManager { get; init; }
+    public required ImmutableArray<Requirement> VulnerableVersions { get; init; }
+    public required ImmutableArray<Requirement> SafeVersions { get; init; }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/SecurityVulnerabilityExtensions.cs

@@ -0,0 +1,36 @@
+using NuGet.Versioning;
+
+namespace NuGetUpdater.Core.Analyze;
+
+public static class SecurityVulnerabilityExtensions
+{
+    // This logic taken from Dependabot security_advisory.rb
+    public static bool IsVulnerable(this SecurityVulnerability vulnerability, NuGetVersion version)
+    {
+        var inSafeRange = vulnerability.SafeVersions
+            .Any(r => r.IsSatisfiedBy(version));
+        if (inSafeRange)
+        {
+            // If version is known safe for this advisory, it's not vulnerable
+            return false;
+        }
+
+        var inVulnerableRange = vulnerability.VulnerableVersions
+            .Any(r => r.IsSatisfiedBy(version));
+        if (inVulnerableRange)
+        {
+            // If in the vulnerable range and not known safe, it's vulnerable
+            return true;
+        }
+
+        if (vulnerability.VulnerableVersions.Length > 0)
+        {
+            // If a vulnerable range present but not met, it's not vulnerable
+            return false;
+        }
+
+        // Finally, if no vulnerable range provided, but a safe range provided,
+        // and this versions isn't included (checked earlier), it's vulnerable
+        return vulnerability.SafeVersions.Length > 0;
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/VersionFinder.cs

@@ -0,0 +1,179 @@
+using System.Collections.Immutable;
+
+using NuGet.Common;
+using NuGet.Configuration;
+using NuGet.Packaging.Core;
+using NuGet.Protocol;
+using NuGet.Protocol.Core.Types;
+using NuGet.Versioning;
+
+namespace NuGetUpdater.Core.Analyze;
+
+internal static class VersionFinder
+{
+    public static Task<VersionResult> GetVersionsAsync(
+        string packageId,
+        NuGetVersion currentVersion,
+        NuGetContext nugetContext,
+        Logger logger,
+        CancellationToken cancellationToken)
+    {
+        var versionFilter = CreateVersionFilter(currentVersion);
+
+        return GetVersionsAsync(packageId, currentVersion, versionFilter, nugetContext, logger, cancellationToken);
+    }
+
+    public static Task<VersionResult> GetVersionsAsync(
+        DependencyInfo dependencyInfo,
+        NuGetContext nugetContext,
+        Logger logger,
+        CancellationToken cancellationToken)
+    {
+        var packageId = dependencyInfo.Name;
+        var versionRange = VersionRange.Parse(dependencyInfo.Version);
+        var currentVersion = versionRange.MinVersion!;
+        var versionFilter = CreateVersionFilter(dependencyInfo, versionRange);
+
+        return GetVersionsAsync(packageId, currentVersion, versionFilter, nugetContext, logger, cancellationToken);
+    }
+
+    public static async Task<VersionResult> GetVersionsAsync(
+        string packageId,
+        NuGetVersion currentVersion,
+        Func<NuGetVersion, bool> versionFilter,
+        NuGetContext nugetContext,
+        Logger logger,
+        CancellationToken cancellationToken)
+    {
+        var includePrerelease = currentVersion.IsPrerelease;
+        VersionResult result = new(currentVersion);
+
+        var sourceMapping = PackageSourceMapping.GetPackageSourceMapping(nugetContext.Settings);
+        var packageSources = sourceMapping.GetConfiguredPackageSources(packageId).ToHashSet();
+        var sources = packageSources.Count == 0
+            ? nugetContext.PackageSources
+            : nugetContext.PackageSources
+                .Where(p => packageSources.Contains(p.Name))
+                .ToImmutableArray();
+
+        foreach (var source in sources)
+        {
+            var sourceRepository = Repository.Factory.GetCoreV3(source);
+            var feed = await sourceRepository.GetResourceAsync<MetadataResource>();
+            if (feed is null)
+            {
+                logger.Log($"Failed to get MetadataResource for [{source.Source}]");
+                continue;
+            }
+
+            var existsInFeed = await feed.Exists(
+                packageId,
+                includePrerelease,
+                includeUnlisted: false,
+                nugetContext.SourceCacheContext,
+                NullLogger.Instance,
+                cancellationToken);
+            if (!existsInFeed)
+            {
+                continue;
+            }
+
+            var feedVersions = (await feed.GetVersions(
+                packageId,
+                includePrerelease,
+                includeUnlisted: false,
+                nugetContext.SourceCacheContext,
+                NullLogger.Instance,
+                CancellationToken.None)).ToHashSet();
+
+            if (feedVersions.Contains(currentVersion))
+            {
+                result.AddCurrentVersionSource(source);
+            }
+
+            result.AddRange(source, feedVersions.Where(versionFilter));
+        }
+
+        return result;
+    }
+
+    internal static Func<NuGetVersion, bool> CreateVersionFilter(DependencyInfo dependencyInfo, VersionRange versionRange)
+    {
+        // If we are floating to the absolute latest version, we should not filter pre-release versions at all.
+        var currentVersion = versionRange.Float?.FloatBehavior != NuGetVersionFloatBehavior.AbsoluteLatest
+            ? versionRange.MinVersion
+            : null;
+
+        return version => (currentVersion is null || version > currentVersion)
+            && versionRange.Satisfies(version)
+            && (currentVersion is null || !currentVersion.IsPrerelease || !version.IsPrerelease || version.Version == currentVersion.Version)
+            && !dependencyInfo.IgnoredVersions.Any(r => r.IsSatisfiedBy(version))
+            && !dependencyInfo.Vulnerabilities.Any(v => v.IsVulnerable(version));
+    }
+
+    internal static Func<NuGetVersion, bool> CreateVersionFilter(NuGetVersion currentVersion)
+    {
+        return version => version > currentVersion
+            && (currentVersion is null || !currentVersion.IsPrerelease || !version.IsPrerelease || version.Version == currentVersion.Version);
+    }
+
+    public static async Task<bool> DoVersionsExistAsync(
+        IEnumerable<string> packageIds,
+        NuGetVersion version,
+        NuGetContext nugetContext,
+        Logger logger,
+        CancellationToken cancellationToken)
+    {
+        foreach (var packageId in packageIds)
+        {
+            if (!await DoesVersionExistAsync(packageId, version, nugetContext, logger, cancellationToken))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public static async Task<bool> DoesVersionExistAsync(
+        string packageId,
+        NuGetVersion version,
+        NuGetContext nugetContext,
+        Logger logger,
+        CancellationToken cancellationToken)
+    {
+        var includePrerelease = version.IsPrerelease;
+
+        var sourceMapping = PackageSourceMapping.GetPackageSourceMapping(nugetContext.Settings);
+        var packageSources = sourceMapping.GetConfiguredPackageSources(packageId).ToHashSet();
+        var sources = packageSources.Count == 0
+            ? nugetContext.PackageSources
+            : nugetContext.PackageSources
+                .Where(p => packageSources.Contains(p.Name))
+                .ToImmutableArray();
+
+        foreach (var source in sources)
+        {
+            var sourceRepository = Repository.Factory.GetCoreV3(source);
+            var feed = await sourceRepository.GetResourceAsync<MetadataResource>();
+            if (feed is null)
+            {
+                logger.Log($"Failed to get MetadataResource for [{source.Source}]");
+                continue;
+            }
+
+            var existsInFeed = await feed.Exists(
+                new PackageIdentity(packageId, version),
+                includeUnlisted: false,
+                nugetContext.SourceCacheContext,
+                NullLogger.Instance,
+                cancellationToken);
+            if (existsInFeed)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/VersionResult.cs

@@ -0,0 +1,54 @@
+using System.Collections.Immutable;
+
+using NuGet.Configuration;
+using NuGet.Versioning;
+
+namespace NuGetUpdater.Core.Analyze;
+
+internal class VersionResult
+{
+    private readonly Dictionary<NuGetVersion, List<PackageSource>> _versions = [];
+    private readonly List<PackageSource> _currentVersionSources = [];
+
+    public NuGetVersion CurrentVersion { get; }
+
+    public VersionResult(NuGetVersion currentVersion)
+    {
+        CurrentVersion = currentVersion;
+    }
+
+    public void AddCurrentVersionSource(PackageSource source)
+    {
+        _currentVersionSources.Add(source);
+    }
+
+    public void AddRange(PackageSource source, IEnumerable<NuGetVersion> versions)
+    {
+        foreach (var version in versions)
+        {
+            if (_versions.ContainsKey(version))
+            {
+                _versions[version].Add(source);
+            }
+            else
+            {
+                _versions.Add(version, [source]);
+            }
+        }
+    }
+
+    public ImmutableArray<PackageSource> GetPackageSources(NuGetVersion version)
+    {
+        if (version == CurrentVersion)
+        {
+            return [.. _currentVersionSources];
+        }
+
+        return [.. _versions[version]];
+    }
+
+    public ImmutableArray<NuGetVersion> GetVersions()
+    {
+        return [.. _versions.Keys];
+    }
+}

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

@@ -14,7 +14,8 @@ public sealed record Dependency(
     bool IsDirect = false,
     bool IsTransitive = false,
     bool IsOverride = false,
-    bool IsUpdate = false) : IEquatable<Dependency>
+    bool IsUpdate = false,
+    string? InfoUrl = null) : IEquatable<Dependency>
 {
     public bool Equals(Dependency? other)
     {
@@ -37,7 +38,8 @@ public sealed record Dependency(
                IsDirect == other.IsDirect &&
                IsTransitive == other.IsTransitive &&
                IsOverride == other.IsOverride &&
-               IsUpdate == other.IsUpdate;
+               IsUpdate == other.IsUpdate &&
+               InfoUrl == other.InfoUrl;
     }
 
     public override int GetHashCode()
@@ -53,6 +55,7 @@ public sealed record Dependency(
         hash.Add(IsTransitive);
         hash.Add(IsOverride);
         hash.Add(IsUpdate);
+        hash.Add(InfoUrl);
         return hash.ToHashCode();
     }
 }

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

@@ -39,6 +39,7 @@ public partial class DiscoveryWorker
             workspacePath = workspacePath[1..];
         }
 
+        string initialWorkspacePath = workspacePath;
         workspacePath = Path.Combine(repoRootPath, workspacePath);
 
         DotNetToolsJsonDiscoveryResult? dotNetToolsJsonDiscovery = null;
@@ -75,7 +76,7 @@ public partial class DiscoveryWorker
 
         var result = new WorkspaceDiscoveryResult
         {
-            FilePath = repoRootPath != workspacePath ? Path.GetRelativePath(repoRootPath, workspacePath) : string.Empty,
+            Path = initialWorkspacePath,
             DotNetToolsJson = dotNetToolsJsonDiscovery,
             GlobalJson = globalJsonDiscovery,
             DirectoryPackagesProps = directoryPackagesPropsDiscovery,

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

@@ -2,9 +2,9 @@ using System.Collections.Immutable;
 
 namespace NuGetUpdater.Core.Discover;
 
-public sealed record WorkspaceDiscoveryResult : IDiscoveryResult
+public sealed record WorkspaceDiscoveryResult
 {
-    public required string FilePath { get; init; }
+    public required string Path { get; init; }
     public bool IsSuccess { get; init; } = true;
     public ImmutableArray<ProjectDiscoveryResult> Projects { get; init; }
     public DirectoryPackagesPropsDiscoveryResult? DirectoryPackagesProps { get; init; }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/FrameworkChecker/CompatabilityChecker.cs

@@ -1,5 +1,3 @@
-using System.Linq;
-
 using NuGet.Frameworks;
 
 namespace NuGetUpdater.Core.FrameworkChecker;

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/FrameworkChecker/FrameworkCompatibilityService.cs

@@ -1,9 +1,6 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
-using System;
-using System.Collections.Generic;
-
 using NuGet.Frameworks;
 
 using NuGetGallery.Frameworks;

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/FrameworkChecker/SupportedFrameworks.cs

@@ -1,9 +1,6 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
-using System;
-using System.Collections.Generic;
-
 using NuGet.Frameworks;
 
 using static NuGet.Frameworks.FrameworkConstants;

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

@@ -1,10 +1,5 @@
 extern alias CoreV2;
 
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
 using System.Xml.Linq;
 
 using CoreV2::NuGet.Runtime;

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

@@ -1,10 +1,6 @@
 extern alias CoreV2;
 
-using System;
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using System.IO;
-using System.Linq;
 using System.Reflection;
 using System.Text.RegularExpressions;