dependabot-nuget 0.239.0 → 0.241.0

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

@@ -0,0 +1,316 @@
+extern alias CoreV2;
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Xml.Linq;
+
+using Microsoft.Language.Xml;
+
+using NuGet.ProjectManagement;
+
+using AssemblyBinding = CoreV2::NuGet.Runtime.AssemblyBinding;
+
+namespace NuGetUpdater.Core;
+
+internal static class BindingRedirectManager
+{
+    private static readonly XName AssemblyBindingName = AssemblyBinding.GetQualifiedName("assemblyBinding");
+    private static readonly XName DependentAssemblyName = AssemblyBinding.GetQualifiedName("dependentAssembly");
+    private static readonly XName BindingRedirectName = AssemblyBinding.GetQualifiedName("bindingRedirect");
+
+    public static async ValueTask UpdateBindingRedirectsAsync(ProjectBuildFile projectBuildFile)
+    {
+        var configFile = await TryGetRuntimeConfigurationFile(projectBuildFile);
+        if (configFile is null)
+        {
+            // no runtime config file so no need to add binding redirects
+            return;
+        }
+
+        var references = ExtractReferenceElements(projectBuildFile);
+        references = ToAbsolutePaths(references, projectBuildFile.Path);
+
+        var bindings = BindingRedirectResolver.GetBindingRedirects(projectBuildFile.Path, references.Select(static x => x.Include));
+        if (!bindings.Any())
+        {
+            // no bindings to update
+            return;
+        }
+
+        var fileContent = AddBindingRedirects(configFile, bindings);
+        configFile = configFile with { Content = fileContent };
+
+        await File.WriteAllTextAsync(configFile.Path, configFile.Content);
+
+        if (configFile.ShouldAddToProject)
+        {
+            AddConfigFileToProject(projectBuildFile, configFile);
+        }
+
+        return;
+
+        static List<(string Include, string HintPath)> ExtractReferenceElements(ProjectBuildFile projectBuildFile)
+        {
+            var document = projectBuildFile.Contents;
+            var hintPaths = new List<(string Include, string HintPath)>();
+
+            foreach (var element in document.Descendants().Where(static x => x.Name == "Reference"))
+            {
+                // Extract Include attribute
+                var includeAttribute = element.GetAttribute("Include");
+                if (includeAttribute == null) continue;
+
+                // Check for HintPath as a child element
+                var hintPathElement = element.Elements.FirstOrDefault(static x => x.Name == "HintPath");
+                if (hintPathElement != null)
+                {
+                    hintPaths.Add((includeAttribute.Value, hintPathElement.GetContentValue()));
+                }
+
+                // Check for HintPath as an attribute
+                var hintPathAttribute = element.GetAttribute("HintPath");
+                if (hintPathAttribute != null)
+                {
+                    hintPaths.Add((includeAttribute.Value, hintPathAttribute.Value));
+                }
+            }
+
+            return hintPaths;
+        }
+
+        static void AddConfigFileToProject(ProjectBuildFile projectBuildFile, ConfigurationFile configFile)
+        {
+            var projectNode = projectBuildFile.Contents.RootSyntax;
+            var itemGroup = XmlExtensions.CreateOpenCloseXmlElementSyntax("ItemGroup")
+                .AddChild(
+                    XmlExtensions.CreateSingleLineXmlElementSyntax("None")
+                        .WithAttribute("Include", Path.GetRelativePath(Path.GetDirectoryName(projectBuildFile.Path)!, configFile.Path)));
+
+            var updatedProjectNode = projectNode.AddChild(itemGroup);
+            var updatedXml = projectBuildFile.Contents.ReplaceNode(projectNode.AsNode, updatedProjectNode.AsNode);
+            projectBuildFile.Update(updatedXml);
+        }
+
+        static List<(string Include, string HintPath)> ToAbsolutePaths(List<(string Include, string HintPath)> references, string projectPath)
+        {
+            var directoryPath = Path.GetDirectoryName(projectPath);
+            ArgumentNullException.ThrowIfNull(directoryPath, nameof(directoryPath));
+            return references.Select(t => (t.Include, Path.GetFullPath(Path.Combine(directoryPath, t.HintPath)))).ToList();
+        }
+    }
+
+    private static async ValueTask<ConfigurationFile?> TryGetRuntimeConfigurationFile(ProjectBuildFile projectBuildFile)
+    {
+        var directoryPath = Path.GetDirectoryName(projectBuildFile.Path);
+        if (directoryPath is null)
+        {
+            return null;
+        }
+
+        var configFile = projectBuildFile.ItemNodes
+            .Where(IsConfigFile)
+            .FirstOrDefault();
+
+        if (configFile is null)
+        {
+            return null;
+        }
+
+        var configFilePath = Path.GetFullPath(Path.Combine(directoryPath, GetContent(configFile)));
+        var configFileContents = await File.ReadAllTextAsync(configFilePath);
+        return new ConfigurationFile(configFilePath, configFileContents, false);
+
+        static string GetContent(IXmlElementSyntax element)
+        {
+            var content = element.GetContentValue();
+            if (!string.IsNullOrEmpty(content))
+            {
+                return content;
+            }
+
+            content = element.GetAttributeValue("Include");
+            if (!string.IsNullOrEmpty(content))
+            {
+                return content;
+            }
+
+            return string.Empty;
+        }
+
+        static bool IsConfigFile(IXmlElementSyntax element)
+        {
+            var content = GetContent(element);
+            if (content is null)
+            {
+                return false;
+            }
+
+            var path = Path.GetFileName(content);
+            return (element.Name == "None" && string.Equals(path, "app.config", StringComparison.OrdinalIgnoreCase))
+                || (element.Name == "Content" && string.Equals(path, "web.config", StringComparison.OrdinalIgnoreCase));
+        }
+
+        static string GetConfigFileName(XmlDocumentSyntax document)
+        {
+            var guidValue = document.Descendants()
+                .Where(static x => x.Name == "PropertyGroup")
+                .SelectMany(static x => x.Elements.Where(static x => x.Name == "ProjectGuid"))
+                .FirstOrDefault()
+                ?.GetContentValue();
+            return guidValue switch
+            {
+                "{E24C65DC-7377-472B-9ABA-BC803B73C61A}" or "{349C5851-65DF-11DA-9384-00065B846F21}" => "Web.config",
+                _ => "App.config"
+            };
+        }
+
+        static string GenerateDefaultAppConfig(XmlDocumentSyntax document)
+        {
+            var frameworkVersion = GetFrameworkVersion(document);
+            return $"""
+            <?xml version="1.0" encoding="utf-8" ?>
+            <configuration>
+                <startup>
+                    <supportedRuntime version="v4.0" sku=".NETFramework,Version={frameworkVersion}" />
+                </startup>
+            </configuration>
+            """;
+        }
+
+        static string? GetFrameworkVersion(XmlDocumentSyntax document)
+        {
+            return document.Descendants()
+                .Where(static x => x.Name == "PropertyGroup")
+                .SelectMany(static x => x.Elements.Where(static x => x.Name == "TargetFrameworkVersion"))
+                .FirstOrDefault()
+                ?.GetContentValue();
+        }
+    }
+
+    private static string AddBindingRedirects(ConfigurationFile configFile, IEnumerable<AssemblyBinding> bindingRedirects)
+    {
+        // Do nothing if there are no binding redirects to add, bail out
+        if (!bindingRedirects.Any())
+        {
+            return configFile.Content;
+        }
+
+        // Get the configuration file
+        var document = GetConfiguration(configFile.Content);
+
+        // Get the runtime element
+        var runtime = document.Root?.Element("runtime");
+
+        if (runtime == null)
+        {
+            // Add the runtime element to the configuration document
+            runtime = new XElement("runtime");
+            document.Root.AddIndented(runtime);
+        }
+
+        // Get all of the current bindings in config
+        var currentBindings = GetAssemblyBindings(runtime);
+
+        foreach (var bindingRedirect in bindingRedirects)
+        {
+            // Look to see if we already have this in the list of bindings already in config.
+            if (currentBindings.TryGetValue((bindingRedirect.Name, bindingRedirect.PublicKeyToken), out var existingBinding))
+            {
+                UpdateBindingRedirectElement(existingBinding, bindingRedirect);
+            }
+            else
+            {
+                // Get an assembly binding element to use
+                var assemblyBindingElement = GetAssemblyBindingElement(runtime);
+
+                // Add the binding to that element
+                assemblyBindingElement.AddIndented(bindingRedirect.ToXElement());
+            }
+        }
+
+        return document.ToString();
+
+        static XDocument GetConfiguration(string configFileContent)
+        {
+            try
+            {
+                return XDocument.Parse(configFileContent, LoadOptions.PreserveWhitespace);
+            }
+            catch (Exception ex)
+            {
+                throw new InvalidOperationException("Error loading binging redirect configuration", ex);
+            }
+        }
+
+        static void RemoveElement(XElement element)
+        {
+            // Hold onto the parent element before removing the element
+            var parentElement = element.Parent;
+
+            // Remove the element from the document if we find a match
+            element.RemoveIndented();
+
+            if (parentElement?.HasElements != true)
+            {
+                parentElement.RemoveIndented();
+            }
+        }
+
+        static void UpdateBindingRedirectElement(
+            XElement existingDependentAssemblyElement,
+            AssemblyBinding newBindingRedirect)
+        {
+            var existingBindingRedirectElement = existingDependentAssemblyElement.Element(BindingRedirectName);
+            // Since we've successfully parsed this node, it has to be valid and this child must exist.
+            if (existingBindingRedirectElement != null)
+            {
+                existingBindingRedirectElement.SetAttributeValue(XName.Get("oldVersion"), newBindingRedirect.OldVersion);
+                existingBindingRedirectElement.SetAttributeValue(XName.Get("newVersion"), newBindingRedirect.NewVersion);
+            }
+            else
+            {
+                // At this point, <dependentAssemblyElement> already exists, but <bindingRedirectElement> does not.
+                // So, extract the <bindingRedirectElement> from the newDependencyAssemblyElement, and add it
+                // to the existingDependentAssemblyElement
+                var newDependentAssemblyElement = newBindingRedirect.ToXElement();
+                var newBindingRedirectElement = newDependentAssemblyElement.Element(BindingRedirectName);
+                existingDependentAssemblyElement.AddIndented(newBindingRedirectElement);
+            }
+        }
+
+        static Dictionary<(string Name, string PublicKeyToken), XElement> GetAssemblyBindings(XElement runtime)
+        {
+            var dependencyAssemblyElements = runtime.Elements(AssemblyBindingName)
+                .Elements(DependentAssemblyName);
+
+            // We're going to need to know which element is associated with what binding for removal
+            var assemblyElementPairs = from dependentAssemblyElement in dependencyAssemblyElements
+                                       select new
+                                       {
+                                           Binding = AssemblyBinding.Parse(dependentAssemblyElement),
+                                           Element = dependentAssemblyElement
+                                       };
+
+            // Return a mapping from binding to element
+            return assemblyElementPairs.ToDictionary(p => (p.Binding.Name, p.Binding.PublicKeyToken), p => p.Element);
+        }
+
+        static XElement GetAssemblyBindingElement(XElement runtime)
+        {
+            // Pick the first assembly binding element or create one if there aren't any
+            var assemblyBinding = runtime.Elements(AssemblyBindingName).FirstOrDefault();
+            if (assemblyBinding is not null)
+            {
+                return assemblyBinding;
+            }
+
+            assemblyBinding = new XElement(AssemblyBindingName);
+            runtime.AddIndented(assemblyBinding);
+
+            return assemblyBinding;
+        }
+    }
+}

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

@@ -0,0 +1,87 @@
+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;
+
+using AssemblyBinding = CoreV2::NuGet.Runtime.AssemblyBinding;
+using IAssembly = CoreV2::NuGet.Runtime.IAssembly;
+
+namespace NuGetUpdater.Core;
+
+public static partial class BindingRedirectResolver
+{
+    public static IEnumerable<AssemblyBinding> GetBindingRedirects(string projectPath, IEnumerable<string> includes)
+    {
+        var directoryPath = Path.GetDirectoryName(projectPath);
+        if (directoryPath is null)
+        {
+            yield break;
+        }
+
+        foreach (var include in includes)
+        {
+            if (TryParseIncludesString(include, out var assemblyInfo))
+            {
+                yield return new AssemblyBinding(assemblyInfo);
+            }
+        }
+
+        yield break;
+
+        static bool TryParseIncludesString(string include, [NotNullWhen(true)] out AssemblyWrapper? assemblyInfo)
+        {
+            assemblyInfo = null;
+            var name = include.Split(',').FirstOrDefault();
+            if (name is null)
+            {
+                return false;
+            }
+
+            var dict = IncludesRegex
+                .Matches(include)
+                .ToDictionary(static x => x.Groups["key"].Value, static x => x.Groups["value"].Value);
+
+            if (!dict.TryGetValue("Version", out var versionString) ||
+                !Version.TryParse(versionString, out var version))
+            {
+                return false;
+            }
+
+            dict.TryGetValue("PublicKeyToken", out var publicKeyToken);
+            dict.TryGetValue("Culture", out var culture);
+
+            assemblyInfo = new AssemblyWrapper(name, version, publicKeyToken, culture);
+            return true;
+        }
+    }
+
+    private static readonly Regex IncludesRegex = IncludesPattern();
+
+    /// <summary>
+    /// Wraps systme<see cref="Assembly"/> type in the nuget interface <see cref="IAssembly"/> to interop with nuget apis
+    /// </summary>
+    private class AssemblyWrapper : IAssembly
+    {
+        public AssemblyWrapper(string name, Version version, string? publicKeyToken = null, string? culture = null)
+        {
+            Name = name;
+            Version = version;
+            PublicKeyToken = publicKeyToken;
+            Culture = culture;
+        }
+
+        public string Name { get; }
+        public Version Version { get; }
+        public string? PublicKeyToken { get; }
+        public string? Culture { get; }
+        public IEnumerable<IAssembly> ReferencedAssemblies { get; } = Enumerable.Empty<AssemblyWrapper>();
+    }
+
+    [GeneratedRegex("(?<key>\\w+)=(?<value>[^,]+)")]
+    private static partial Regex IncludesPattern();
+}

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

@@ -0,0 +1,3 @@
+namespace NuGetUpdater.Core;
+
+public record ConfigurationFile(string Path, string Content, bool ShouldAddToProject);

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

@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace NuGetUpdater.Core;
+
+internal static partial class DotNetToolsJsonUpdater
+{
+    public static async Task UpdateDependencyAsync(string repoRootPath, string dependencyName, string previousDependencyVersion, string newDependencyVersion, Logger logger)
+    {
+        var buildFiles = LoadBuildFiles(repoRootPath);
+        if (buildFiles.Length == 0)
+        {
+            logger.Log($"  No dotnet-tools.json files found.");
+            return;
+        }
+
+        logger.Log($"  Updating dotnet-tools.json files.");
+
+
+        var filesToUpdate = buildFiles.Where(f =>
+            f.GetDependencies().Any(d => d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase)))
+            .ToImmutableArray();
+        if (filesToUpdate.Length == 0)
+        {
+            logger.Log($"    Dependency [{dependencyName}] not found in any dotnet-tools.json files.");
+            return;
+        }
+
+        foreach (var buildFile in filesToUpdate)
+        {
+            var tool = buildFile.Tools
+                .Single(kvp => kvp.Key.Equals(dependencyName, StringComparison.OrdinalIgnoreCase));
+
+            var toolObject = tool.Value?.AsObject();
+
+            if (toolObject is not null &&
+                toolObject["version"]?.GetValue<string>() == previousDependencyVersion)
+            {
+                buildFile.UpdateProperty(new[] { "tools", dependencyName, "version" }, newDependencyVersion);
+
+                if (await buildFile.SaveAsync())
+                {
+                    logger.Log($"    Saved [{buildFile.RepoRelativePath}].");
+                }
+            }
+        }
+    }
+
+    private static ImmutableArray<DotNetToolsJsonBuildFile> LoadBuildFiles(string repoRootPath)
+    {
+        var options = new EnumerationOptions()
+        {
+            RecurseSubdirectories = true,
+            MatchType = MatchType.Win32,
+            AttributesToSkip = 0,
+            IgnoreInaccessible = false,
+            MatchCasing = MatchCasing.CaseInsensitive,
+        };
+        return Directory.EnumerateFiles(repoRootPath, "dotnet-tools.json", options)
+            .Select(path => DotNetToolsJsonBuildFile.Open(repoRootPath, path))
+            .ToImmutableArray();
+    }
+}

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

@@ -0,0 +1,48 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace NuGetUpdater.Core;
+
+internal static partial class GlobalJsonUpdater
+{
+    public static async Task UpdateDependencyAsync(string repoRootPath, string globalJsonPath, string dependencyName, string previousDependencyVersion, string newDependencyVersion, Logger logger)
+    {
+        if (!File.Exists(globalJsonPath))
+        {
+            logger.Log($"  No global.json file found at [{globalJsonPath}].");
+            return;
+        }
+
+        var globalJsonFile = GlobalJsonBuildFile.Open(repoRootPath, globalJsonPath);
+
+        logger.Log($"  Updating [{globalJsonFile.RepoRelativePath}] file.");
+
+        var containsDependency = globalJsonFile.GetDependencies().Any(d => d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase));
+        if (!containsDependency)
+        {
+            logger.Log($"    Dependency [{dependencyName}] not found.");
+            return;
+        }
+
+        if (globalJsonFile.MSBuildSdks?.TryGetPropertyValue(dependencyName, out var version) != true
+            || version?.GetValue<string>() is not string versionString)
+        {
+            logger.Log($"    Unable to determine dependency version.");
+            return;
+        }
+
+        if (versionString != previousDependencyVersion)
+        {
+            return;
+        }
+
+        globalJsonFile.UpdateProperty(["msbuild-sdks", dependencyName], newDependencyVersion);
+
+        if (await globalJsonFile.SaveAsync())
+        {
+            logger.Log($"    Saved [{globalJsonFile.RepoRelativePath}].");
+        }
+    }
+}

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

@@ -0,0 +1,172 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml.Linq;
+
+using Microsoft.Language.Xml;
+
+namespace NuGetUpdater.Core;
+
+internal static class PackagesConfigUpdater
+{
+    public static async Task UpdateDependencyAsync(string repoRootPath, string projectPath, string dependencyName, string previousDependencyVersion, string newDependencyVersion, bool isTransitive, Logger logger)
+    {
+        logger.Log($"  Found {NuGetHelper.PackagesConfigFileName}; running with NuGet.exe");
+
+        // use NuGet.exe to perform update
+
+        // ensure local packages directory exists
+        var projectBuildFile = ProjectBuildFile.Open(repoRootPath, projectPath);
+        var packagesSubDirectory = GetPathToPackagesDirectory(projectBuildFile, dependencyName, previousDependencyVersion);
+        if (packagesSubDirectory is null)
+        {
+            logger.Log($"    Project [{projectPath}] does not reference this dependency.");
+            return;
+        }
+
+        logger.Log($"    Using packages directory [{packagesSubDirectory}] for project [{projectPath}].");
+
+        var projectDirectory = Path.GetDirectoryName(projectPath);
+        var packagesConfigPath = PathHelper.JoinPath(projectDirectory, NuGetHelper.PackagesConfigFileName);
+
+        var packagesDirectory = PathHelper.JoinPath(projectDirectory, packagesSubDirectory);
+        Directory.CreateDirectory(packagesDirectory);
+
+        var args = new List<string>()
+            {
+                "update",
+                packagesConfigPath,
+                "-Id",
+                dependencyName,
+                "-Version",
+                newDependencyVersion,
+                "-RepositoryPath",
+                packagesDirectory,
+                "-NonInteractive",
+            };
+
+        logger.Log("    Finding MSBuild...");
+        var msbuildDirectory = MSBuildHelper.MSBuildPath;
+        if (msbuildDirectory is not null)
+        {
+            args.Add("-MSBuildPath");
+            args.Add(msbuildDirectory); // e.g., /usr/share/dotnet/sdk/7.0.203
+        }
+
+        RunNuget(args, packagesDirectory, logger);
+
+        projectBuildFile = ProjectBuildFile.Open(repoRootPath, projectPath);
+        projectBuildFile.NormalizeDirectorySeparatorsInProject();
+
+        // Update binding redirects
+        await BindingRedirectManager.UpdateBindingRedirectsAsync(projectBuildFile);
+
+        logger.Log("    Writing project file back to disk");
+        await projectBuildFile.SaveAsync();
+    }
+
+    private static void RunNuget(List<string> args, string packagesDirectory, Logger logger)
+    {
+        var outputBuilder = new StringBuilder();
+        var writer = new StringWriter(outputBuilder);
+
+        var originalOut = Console.Out;
+        var originalError = Console.Error;
+        Console.SetOut(writer);
+        Console.SetError(writer);
+
+        var currentDir = Environment.CurrentDirectory;
+        try
+        {
+            logger.Log($"    Running NuGet.exe with args: {string.Join(" ", args)}");
+
+            Environment.CurrentDirectory = packagesDirectory;
+            var result = NuGet.CommandLine.Program.Main(args.ToArray());
+            var fullOutput = outputBuilder.ToString();
+            logger.Log($"    Result: {result}");
+            logger.Log($"    Output:\n{fullOutput}");
+            if (result != 0)
+            {
+                throw new Exception(fullOutput);
+            }
+        }
+        catch (Exception e)
+        {
+            logger.Log($"Error: {e}");
+            throw;
+        }
+        finally
+        {
+            Environment.CurrentDirectory = currentDir;
+            Console.SetOut(originalOut);
+            Console.SetError(originalError);
+        }
+    }
+
+    internal static string? GetPathToPackagesDirectory(ProjectBuildFile projectBuildFile, string dependencyName, string dependencyVersion)
+    {
+        // the packages directory can be found from the hint path of the matching dependency, e.g., when given "Newtonsoft.Json", "7.0.1", and a project like this:
+        // <Project>
+        //   <ItemGroup>
+        //     <Reference Include="Newtonsoft.Json, Version=7.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed">
+        //       <HintPath>..\packages\Newtonsoft.Json.7.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+        //     </Reference>
+        //   <ItemGroup>
+        // </Project>
+        //
+        // the result should be "..\packages"
+        //
+        // first try to do an exact match with the provided version number, but optionally fall back to just matching the package name and _any_ version
+        var hintPathSubString = $"{dependencyName}.{dependencyVersion}";
+
+        string? partialPathMatch = null;
+        var hintPathNodes = projectBuildFile.Contents.Descendants()
+            .Where(e =>
+                e.Name.Equals("HintPath", StringComparison.OrdinalIgnoreCase) &&
+                e.Parent.Name.Equals("Reference", StringComparison.OrdinalIgnoreCase) &&
+                e.Parent.GetAttributeValue("Include", StringComparison.OrdinalIgnoreCase)?.StartsWith($"{dependencyName},", StringComparison.OrdinalIgnoreCase) == true);
+        foreach (var hintPathNode in hintPathNodes)
+        {
+            var hintPath = hintPathNode.GetContentValue();
+            var hintPathSubStringLocation = hintPath.IndexOf(hintPathSubString, StringComparison.OrdinalIgnoreCase);
+            if (hintPathSubStringLocation >= 0)
+            {
+                // exact match was found, use it
+                var subpath = GetUpToIndexWithoutTrailingDirectorySeparator(hintPath, hintPathSubStringLocation);
+                return subpath;
+            }
+
+            if (partialPathMatch is null)
+            {
+                var partialHintPathSubStringLocation = hintPath.IndexOf($"{dependencyName}.", StringComparison.OrdinalIgnoreCase);
+                if (partialHintPathSubStringLocation >= 0)
+                {
+                    // look instead for, e.g., "Newtonsoft.Json.<digit>"
+                    var candidateVersionLocation = partialHintPathSubStringLocation + dependencyName.Length + 1; // 1 is the dot
+                    if (hintPath.Length > candidateVersionLocation && char.IsDigit(hintPath[candidateVersionLocation]))
+                    {
+                        // partial match was found, save it in case we don't find anything better
+                        var subpath = GetUpToIndexWithoutTrailingDirectorySeparator(hintPath, partialHintPathSubStringLocation);
+                        partialPathMatch = subpath;
+                    }
+                }
+            }
+        }
+
+        return partialPathMatch;
+    }
+
+    private static string GetUpToIndexWithoutTrailingDirectorySeparator(string path, int index)
+    {
+        var subpath = path[..index];
+        if (subpath.EndsWith('/') || subpath.EndsWith('\\'))
+        {
+            subpath = subpath[..^1];
+        }
+
+        return subpath;
+    }
+}