dependabot-nuget 0.370.0 → 0.371.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a443457e2e8e24c70f4cb8a9e11a2fff6c3f9d15255b7e023c29a1ccdf4bd548
-  data.tar.gz: 272f36da3e3a53a28cd748d21da99bf8b5c94ca94c854e549db6dc1ee8b2f40a
+  metadata.gz: 1d7916c7661919bee90276b975fe46847c6289fa45de9cc7ebe2d1dc12799685
+  data.tar.gz: c05e7678dab3e9baa32a75a38f535dca02fd692c5562e7898756c2ffc2acbfee
 SHA512:
-  metadata.gz: 7e5806e6b08c76324c6ba174c1f0a4e085ab62ef8f6694b365932beefa770ea5cdcdf578574f73e61f3b08b1ff7fd2523fa7f23a9598a34f69ccf1f236397b44
-  data.tar.gz: 7786d4b33b44eb4fe14cc7ba98d77c5ad45c9213ae80320d895de61db18e19592b72243c3a25b4bcdc182dbdb0f6e2787812b14dd8cf49c606503053c3612a3b
+  metadata.gz: fc5b580e70c49c5a2b0c13887cac6140be5e4bf642e4d6c4e3f43455b57cc0599c76cb6170f75ef949f76aab23fdefa66488f16cb948aa15fa7871c593ebe935
+  data.tar.gz: 9301c2888824bac12674380195add8516a43b247205329d2fb8524c9e2bfa5e03734c0ddd30afe91acf0f7fb3851181563b5c70b81a3e72ff4dbc70d17eb5292

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

@@ -318,7 +318,20 @@ public partial class DiscoveryWorker : IDiscoveryWorker
     private async Task<ImmutableArray<ProjectDiscoveryResult>> RunForProjectPathsAsync(string repoRootPath, string workspacePath, IEnumerable<string> projectPaths)
     {
         var normalizedProjectPaths = projectPaths.SelectMany(p => PathHelper.ResolveCaseInsensitivePathsInsideRepoRoot(p, repoRootPath) ?? []).Distinct().ToImmutableArray();
-        var disposables = normalizedProjectPaths.Select(p => new SpecialImportsConditionPatcher(p)).ToImmutableArray();
+
+        // Find all MSBuild files that may contain special imports
+        var enumerationOptions = new EnumerationOptions()
+        {
+            RecurseSubdirectories = true,
+            IgnoreInaccessible = true,
+            AttributesToSkip = FileAttributes.ReparsePoint,
+        };
+        var msbuildExtensions = new[] { ".props", ".targets", ".proj", ".csproj", ".vbproj", ".fsproj" };
+        var filesToPatch = Directory.GetFiles(repoRootPath, "*.*", enumerationOptions)
+            .Where(f => msbuildExtensions.Contains(Path.GetExtension(f), StringComparer.OrdinalIgnoreCase))
+            .ToImmutableArray();
+
+        var disposables = filesToPatch.Select(p => new SpecialImportsConditionPatcher(p)).ToImmutableArray();
         var results = new Dictionary<string, ProjectDiscoveryResult>(StringComparer.Ordinal);
 
         try
@@ -411,10 +424,6 @@ public partial class DiscoveryWorker : IDiscoveryWorker
         var mergedDependencies = mergedDependenciesSet.Values
             .OrderBy(d => d.Name, StringComparer.OrdinalIgnoreCase)
             .ToImmutableArray();
-        var mergedProperties = result1.Properties.Concat(result2.Properties)
-            .DistinctBy(p => p.Name, StringComparer.OrdinalIgnoreCase)
-            .OrderBy(p => p.Name)
-            .ToImmutableArray();
         var mergedTargetFrameworks = result1.TargetFrameworks.Concat(result2.TargetFrameworks)
             .Select(t =>
             {
@@ -450,7 +459,6 @@ public partial class DiscoveryWorker : IDiscoveryWorker
             Dependencies = mergedDependencies,
             IsSuccess = result1.IsSuccess && result2.IsSuccess,
             Error = result1.Error ?? result2.Error,
-            Properties = mergedProperties,
             TargetFrameworks = mergedTargetFrameworks,
             ReferencedProjectPaths = mergedReferencedProjects,
             ImportedFiles = mergedImportedFiles,

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

@@ -10,7 +10,6 @@ public record ProjectDiscoveryResult : IDiscoveryResultWithDependencies
     public required ImmutableArray<Dependency> Dependencies { get; init; }
     public bool IsSuccess { get; init; } = true;
     public JobErrorBase? Error { get; init; } = null;
-    public ImmutableArray<Property> Properties { get; init; } = [];
     public ImmutableArray<string> TargetFrameworks { get; init; } = [];
     public ImmutableArray<string> ReferencedProjectPaths { get; init; } = [];
     public required ImmutableArray<string> ImportedFiles { get; init; }

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

@@ -1,7 +1,6 @@
 using System.Collections.Immutable;
 using System.Text.Json;
 using System.Xml.Linq;
-using System.Xml.XPath;
 
 using Microsoft.Build.Logging.StructuredLogger;
 
@@ -63,6 +62,12 @@ internal static class SdkProjectDiscovery
         "GenerateBuildDependencyFile"
     ];
 
+    // these targets are required to evaluate a legacy project with a single operation
+    private static readonly ImmutableArray<string> LegacyProjectSingleRestoreTargetNames = ["ResolveProjectReferences"];
+
+    // this property evaluates to a version number in an SDK-style project and is unset or empty otherwise
+    private const string NETCoreSdkVersionPropertyName = "NETCoreSdkVersion";
+
     // this seems to be the maximum number of TFMs that can be restored in parallel without running into race conditions
     private const int MaximumParallelTargetFrameworkRestores = 2;
 
@@ -138,20 +143,39 @@ internal static class SdkProjectDiscovery
             var binLogPath = Path.Combine(Path.GetTempPath(), $"msbuild_{Guid.NewGuid():d}.binlog");
             try
             {
-                // when using single restore, we can directly invoke the relevant targets
+                // when using single restore, we can directly invoke the relevant targets...
                 var args = new List<string>() { "msbuild", startingProjectPath };
-                var targets = await MSBuildHelper.GetProjectTargetsAsync(startingProjectPath, logger);
-                var useDirectRestore = SingleRestoreTargetNames.All(targets.Contains);
+
+                // ...but determining what the relevant targets are can be complicated
+
+                // For SDK-style projects  the targets `Restore`, `ResolveProjectReferences`, and `GenerateBuildDependencyFile`
+                // are necessary.  If the project has a single target framework, those magic targets will all be present and can
+                // be directly invoked, but if the project has multiple target frameworks, those targets will _NOT_ be directly
+                // present and we instead have to invoke the `Build` target and specify the three magic values as `InnerTargets`.
+
+                // If the project is legacy then those three magic targets will not be present, but we shouldn't use the `Build`
+                // and `InnerTargets` trick because that's an SDK-only mechanism, so we instead only need to invoke
+                // `ResolveProjectReferences` to gather all `PackageReference` items and further down we re-build the transitive
+                // dependency set.  Without the legacy project check, we could incorrectly invoke `Build` which eventually tries
+                // to call `csc.exe` which is unnecessary and can be slow.
+                var netCoreSdkVersionValue = await MSBuildHelper.GetProjectPropertyAsync(startingProjectPath, NETCoreSdkVersionPropertyName, logger);
+                var isLegacyProject = string.IsNullOrEmpty(netCoreSdkVersionValue);
+                var requiredTargets = isLegacyProject
+                    ? LegacyProjectSingleRestoreTargetNames
+                    : SingleRestoreTargetNames;
+
+                var actualTargets = await MSBuildHelper.GetProjectTargetsAsync(startingProjectPath, logger);
+                var useDirectRestore = requiredTargets.All(actualTargets.Contains);
                 if (useDirectRestore || isIndividualTfmRestore)
                 {
                     // directly call the required targets
-                    args.Add($"/t:{string.Join(",", SingleRestoreTargetNames)}");
+                    args.Add($"/t:{string.Join(",", requiredTargets)}");
                 }
                 else
                 {
                     // delegate to the inner build and call those targets
                     args.Add("/t:Build");
-                    args.Add($"/p:InnerTargets=\"{string.Join(";", SingleRestoreTargetNames)}\"");
+                    args.Add($"/p:InnerTargets=\"{string.Join(";", requiredTargets)}\"");
                 }
 
                 // inject various props and targets to help with discovery
@@ -385,7 +409,7 @@ internal static class SdkProjectDiscovery
         foreach (var projectPath in resolvedProperties.Keys)
         {
             var projectProperties = resolvedProperties[projectPath];
-            var isProjectLegacy = !projectProperties.ContainsKey("NETCoreSdkVersion"); // legacy projects don't contain this property
+            var isProjectLegacy = !projectProperties.ContainsKey(NETCoreSdkVersionPropertyName); // legacy projects don't contain this property
             if (isProjectLegacy)
             {
                 logger.Info($"Project {projectPath} is legacy");
@@ -482,9 +506,6 @@ internal static class SdkProjectDiscovery
             }
 
             var projectFullDirectory = Path.GetDirectoryName(projectPath)!;
-            var doc = XDocument.Load(projectPath);
-            var localPropertyDefinitionElements = doc.Root!.XPathSelectElements("/Project/PropertyGroup/*");
-            var projectPropertyNames = localPropertyDefinitionElements.Select(e => e.Name.LocalName).ToHashSet(StringComparer.OrdinalIgnoreCase);
             var projectRelativePath = Path.GetRelativePath(workspacePath, projectPath);
 
             var propertiesForProject = resolvedProperties.GetOrAdd(projectPath, () => new(StringComparer.OrdinalIgnoreCase));
@@ -611,11 +632,6 @@ internal static class SdkProjectDiscovery
 
             // others
             var projectProperties = resolvedProperties[projectPath];
-            var properties = projectProperties
-                .Where(pkvp => projectPropertyNames.Contains(pkvp.Key))
-                .Select(pkvp => new Property(pkvp.Key, pkvp.Value, Path.GetRelativePath(repoRootPath, projectPath).NormalizePathToUnix()))
-                .OrderBy(p => p.Name)
-                .ToImmutableArray();
             var referenced = referencedProjects.GetOrAdd(projectPath, () => new(PathComparer.Instance))
                 .Select(p => Path.GetRelativePath(projectFullDirectory, p).NormalizePathToUnix())
                 .OrderBy(p => p)
@@ -640,7 +656,6 @@ internal static class SdkProjectDiscovery
                 FilePath = projectRelativePath,
                 Dependencies = dependencies,
                 TargetFrameworks = tfms,
-                Properties = properties,
                 ReferencedProjectPaths = referenced,
                 ImportedFiles = imported,
                 AdditionalFiles = additional,

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/GetProperty.targets

@@ -0,0 +1,9 @@
+<Project>
+  <Target Name="_Dependabot_GetProperty">
+    <PropertyGroup>
+      <!-- the following value will get copied and replaced at runtime -->
+      <_DependabotPropertyValue>%RequestedPropertyName%</_DependabotPropertyValue>
+    </PropertyGroup>
+    <Message Importance="High" Text="__PROPERTY_VALUE:$(_DependabotPropertyValue)" />
+  </Target>
+</Project>

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

@@ -11,6 +11,7 @@
     <None Include="DependencyDiscovery.props" CopyToOutputDirectory="PreserveNewest" />
     <None Include="DependencyDiscoveryTargetingPacks.props" CopyToOutputDirectory="PreserveNewest" />
     <None Include="DependencyDiscovery.targets" CopyToOutputDirectory="PreserveNewest" />
+    <None Include="GetProperty.targets" CopyToOutputDirectory="PreserveNewest" />
     <None Include="TargetFrameworkReporter.targets" CopyToOutputDirectory="PreserveNewest" />
   </ItemGroup>
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/FileWriters/XmlFileWriter.cs

@@ -150,29 +150,35 @@ public class XmlFileWriter : IFileWriter
                 // find last `<ItemGroup>` in the project...
                 Action addItemGroup = () => { }; // adding an ItemGroup to the project isn't always necessary, but it's much easier to prepare for it here
                 var projectDocument = filesAndContents[projectRelativePath];
-                var lastItemGroup = projectDocument.RootSyntax.Elements
-                    .LastOrDefault(e => e.Name.Equals(ItemGroupElementName, StringComparison.OrdinalIgnoreCase));
-                if (lastItemGroup is null)
+                var indentation = GetDocumentIndentationCharacters(projectDocument);
+                var itemGroups = projectDocument.RootSyntax.Elements
+                    .Where(e => e.Name.Equals(ItemGroupElementName, StringComparison.OrdinalIgnoreCase))
+                    .ToArray();
+                var itemGroupsWithPackageReferences = itemGroups
+                    .Where(e => e.Elements.Any(c => c.Name.Equals(PackageReferenceElementName, StringComparison.OrdinalIgnoreCase)))
+                    .ToArray();
+                var itemGroupForInsertion = itemGroupsWithPackageReferences.LastOrDefault() ?? itemGroups.LastOrDefault();
+                if (itemGroupForInsertion is null)
                 {
                     _logger.Info($"No `<{ItemGroupElementName}>` element found in project; adding one.");
-                    lastItemGroup = XmlExtensions.CreateOpenCloseXmlElementSyntax(ItemGroupElementName,
-                        new SyntaxList<SyntaxNode>([SyntaxFactory.EndOfLineTrivia("\n"), SyntaxFactory.WhitespaceTrivia("  ")]),
+                    itemGroupForInsertion = XmlExtensions.CreateOpenCloseXmlElementSyntax(ItemGroupElementName,
+                        new SyntaxList<SyntaxNode>([SyntaxFactory.EndOfLineTrivia("\n"), SyntaxFactory.WhitespaceTrivia(indentation)]),
                         insertIntermediateNewline: false);
                     addItemGroup = () =>
                     {
                         // add the new element
-                        var updatedRootSyntax = projectDocument.RootSyntax.AddChild(lastItemGroup);
+                        var updatedRootSyntax = projectDocument.RootSyntax.AddChild(itemGroupForInsertion);
                         var updatedProjectDocument = projectDocument.ReplaceNode(projectDocument.RootSyntax.AsNode, updatedRootSyntax.AsNode);
 
                         // reset well-known variables
                         projectDocument = updatedProjectDocument;
                         filesAndContents[projectRelativePath] = updatedProjectDocument;
-                        lastItemGroup = updatedProjectDocument.RootSyntax.Elements.Last(e => e.Name.Equals(ItemGroupElementName, StringComparison.OrdinalIgnoreCase));
+                        itemGroupForInsertion = updatedProjectDocument.RootSyntax.Elements.Last(e => e.Name.Equals(ItemGroupElementName, StringComparison.OrdinalIgnoreCase));
                     };
                 }
 
                 // ...find where the new item should go...
-                var elementsBeforeNew = GetOrderedElementsBeforeSpecified(lastItemGroup, PackageReferenceElementName, [IncludeAttributeName, UpdateAttributeName], requiredPackageVersion.Name);
+                var elementsBeforeNew = GetOrderedElementsBeforeSpecified(itemGroupForInsertion, PackageReferenceElementName, [IncludeAttributeName, UpdateAttributeName], requiredPackageVersion.Name);
 
                 // ...prepare a new `<PackageReference>` element...
                 var newElement = XmlExtensions.CreateSingleLineXmlElementSyntax(PackageReferenceElementName, leadingTrivia: new SyntaxList<SyntaxNode>())
@@ -221,18 +227,18 @@ public class XmlFileWriter : IFileWriter
                     else
                     {
                         // no prior package references; add to the front
-                        var itemGroupTrivia = lastItemGroup.AsNode.GetLeadingTrivia().ToList();
+                        var itemGroupTrivia = itemGroupForInsertion.AsNode.GetLeadingTrivia().ToList();
                         var priorEolIndex = itemGroupTrivia.FindLastIndex(t => t.Kind == SyntaxKind.EndOfLineTrivia);
                         var indentTrivia = itemGroupTrivia
                             .Skip(priorEolIndex + 1)
                             .Select(t => SyntaxFactory.WhitespaceTrivia(t.ToFullString()))
                             .ToArray();
-                        var newTrivia = new SyntaxTriviaList([SyntaxFactory.EndOfLineTrivia("\n"), SyntaxFactory.WhitespaceTrivia("  "), .. indentTrivia]);
+                        var newTrivia = new SyntaxTriviaList([SyntaxFactory.EndOfLineTrivia("\n"), SyntaxFactory.WhitespaceTrivia(indentation), .. indentTrivia]);
                         newElement = (IXmlElementSyntax)newElement.AsNode.WithLeadingTrivia(newTrivia);
                         var updatedItemGroup = (IXmlElementSyntax)ReplaceNode(
                             projectRelativePath,
-                            lastItemGroup.AsNode,
-                            lastItemGroup.InsertChild(newElement, 0).AsNode
+                            itemGroupForInsertion.AsNode,
+                            itemGroupForInsertion.InsertChild(newElement, 0).AsNode
                         );
                         newElement = (IXmlElementSyntax)updatedItemGroup.Content[0];
                     }
@@ -353,7 +359,9 @@ public class XmlFileWriter : IFileWriter
                                 .Skip(priorEolIndex + 1)
                                 .Select(t => SyntaxFactory.WhitespaceTrivia(t.ToFullString()))
                                 .ToArray();
-                            var newTrivia = new SyntaxTriviaList([SyntaxFactory.EndOfLineTrivia("\n"), SyntaxFactory.WhitespaceTrivia("  "), .. indentTrivia]);
+                            var packageVersionDocument = filesAndContents[filePath];
+                            var packageVersionIndentation = GetDocumentIndentationCharacters(packageVersionDocument);
+                            var newTrivia = new SyntaxTriviaList([SyntaxFactory.EndOfLineTrivia("\n"), SyntaxFactory.WhitespaceTrivia(packageVersionIndentation), .. indentTrivia]);
                             newVersionElement = (IXmlElementSyntax)newVersionElement.AsNode.WithLeadingTrivia(newTrivia).WithoutTrailingTrivia();
                             var insertionIndex = 0;
                             var replacementPackageVersionGroup = packageVersionGroup
@@ -581,7 +589,7 @@ public class XmlFileWriter : IFileWriter
         return elementsBeforeNew;
     }
 
-    private static async Task<XmlDocumentSyntax> ReadFileContentsAsync(DirectoryInfo repoContentsPath, string path)
+    internal static async Task<XmlDocumentSyntax> ReadFileContentsAsync(DirectoryInfo repoContentsPath, string path)
     {
         var fullPath = Path.Join(repoContentsPath.FullName, path);
         var contents = await File.ReadAllTextAsync(fullPath);
@@ -696,4 +704,23 @@ public class XmlFileWriter : IFileWriter
 
         return newRange.ToString();
     }
+
+    public static string GetDocumentIndentationCharacters(XmlDocumentSyntax document)
+    {
+        // find the first element with leading whitespace and assume that's the document indentation
+        var nodeLeadingLineTrivias = document.DescendantNodes()
+            .Select(n => n.GetLeadingTrivia().ToList())
+            .Select(l =>
+            {
+                var priorEolIndex = l.FindLastIndex(t => t.Kind == SyntaxKind.EndOfLineTrivia);
+                var leadingTriviaParts = l.Skip(priorEolIndex + 1)
+                    .Select(t => t.ToFullString());
+                var leadingTrivia = string.Concat(leadingTriviaParts);
+                return leadingTrivia;
+            })
+            .ToArray();
+        var nodeLeadingLineTrivia = nodeLeadingLineTrivias
+            .FirstOrDefault(t => !string.IsNullOrEmpty(t));
+        return nodeLeadingLineTrivia ?? "  ";
+    }
 }

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

@@ -19,12 +19,12 @@ namespace NuGetUpdater.Core;
 // Data type to store information of a given package
 public class PackageToUpdate
 {
-    public string PackageName { get; set; }
-    public string CurrentVersion { get; set; }
-    public string NewVersion { get; set; }
+    public required string PackageName { get; set; }
+    public string? CurrentVersion { get; set; }
+    public string? NewVersion { get; set; }
 
     // Second version in case there's a "bounds" on the package version
-    public string SecondVersion { get; set; }
+    public string? SecondVersion { get; set; }
 
     // Bool to determine if a package has to be a specific version
     public bool IsSpecific { get; set; }
@@ -122,7 +122,7 @@ public class PackageManager
     }
 
     // Method to find the best match framework of a given package's target framework availability
-    public static NuGetFramework FindBestMatchFramework(IEnumerable<NuGet.Packaging.PackageDependencyGroup> dependencySet, string targetFrameworkString)
+    public static NuGetFramework? FindBestMatchFramework(IEnumerable<NuGet.Packaging.PackageDependencyGroup> dependencySet, string targetFrameworkString)
     {
         // Parse the given target framework string into a NuGetFramework object
         var targetFramework = NuGetFramework.ParseFolder(targetFrameworkString);
@@ -136,7 +136,7 @@ public class PackageManager
     }
 
     // Method to get the dependencies of a package
-    public async Task<List<PackageToUpdate>> GetDependenciesAsync(PackageToUpdate package, string targetFramework, string projectDirectory, ILogger logger)
+    public async Task<List<PackageToUpdate>?> GetDependenciesAsync(PackageToUpdate package, string targetFramework, string projectDirectory, ILogger logger)
     {
         if (!NuGetVersion.TryParse(package.NewVersion, out var otherVersion))
         {
@@ -166,47 +166,46 @@ public class PackageManager
 
                 foreach (var packageDependency in bestMatchGroup.Packages)
                 {
-                    string version = packageDependency.VersionRange.OriginalString;
-                    string firstVersion = null;
-                    string SecondVersion = null;
+                    string? version = packageDependency.VersionRange.OriginalString;
+                    string? SecondVersion = null;
 
                     // Conditions to check if the version has bounds specified
-                    if (version.StartsWith("[") && version.EndsWith("]"))
+                    if (version is not null && version.StartsWith("[") && version.EndsWith("]"))
                     {
                         version = version.Trim('[', ']');
                         var versions = version.Split(',');
-                        version = versions.FirstOrDefault().Trim();
+                        version = versions[0].Trim();
                         if (versions.Length > 1)
                         {
                             SecondVersion = versions.LastOrDefault()?.Trim();
                         }
                         specific = true;
                     }
-                    else if (version.StartsWith("[") && version.EndsWith(")"))
+                    else if (version is not null && version.StartsWith("[") && version.EndsWith(")"))
                     {
                         version = version.Trim('[', ')');
                         var versions = version.Split(',');
-                        version = versions.FirstOrDefault().Trim();
+                        version = versions[0].Trim();
                         if (versions.Length > 1)
                         {
                             SecondVersion = versions.LastOrDefault()?.Trim();
                         }
                     }
-                    else if (version.StartsWith("(") && version.EndsWith("]"))
+                    else if (version is not null && version.StartsWith("(") && version.EndsWith("]"))
                     {
                         version = version.Trim('(', ']');
                         var versions = version.Split(',');
-                        version = versions.FirstOrDefault().Trim();
+                        version = versions[0].Trim();
                         if (versions.Length > 1)
                         {
                             SecondVersion = versions.LastOrDefault()?.Trim();
                         }
                     }
-                    else if (version.StartsWith("(") && version.EndsWith(")"))
+                    else if (version is not null && version.StartsWith("(") && version.EndsWith(")"))
                     {
                         version = version.Trim('(', ')');
                         var versions = version.Split(',');
-                        version = versions.FirstOrDefault().Trim();
+                        version = versions[0].Trim();
                         if (versions.Length > 1)
                         {
                             SecondVersion = versions.LastOrDefault()?.Trim();
@@ -292,7 +291,7 @@ public class PackageManager
         // Loop through each package and get their dependencies
         foreach (PackageToUpdate package in packages)
         {
-            List<PackageToUpdate> dependencies = await GetDependenciesAsync(package, targetFramework, projectDirectory, logger);
+            List<PackageToUpdate>? dependencies = await GetDependenciesAsync(package, targetFramework, projectDirectory, logger);
 
             if (dependencies == null)
             {
@@ -302,7 +301,7 @@ public class PackageManager
             // Add each dependency based off if it exists or not
             foreach (PackageToUpdate dependency in dependencies)
             {
-                PackageToUpdate checkInExisting = packages.FirstOrDefault(p => string.Compare(p.PackageName, dependency.PackageName, StringComparison.OrdinalIgnoreCase) == 0);
+                PackageToUpdate? checkInExisting = packages.FirstOrDefault(p => string.Compare(p.PackageName, dependency.PackageName, StringComparison.OrdinalIgnoreCase) == 0);
                 if (checkInExisting != null)
                 {
                     checkInExisting.IsSpecific = dependency.IsSpecific;
@@ -356,17 +355,17 @@ public class PackageManager
 
         try
         {
-            NuGetVersion CurrentVersion = new NuGetVersion(package.CurrentVersion);
-            NuGetVersion newerVersion = new NuGetVersion(package.NewVersion);
+            NuGetVersion CurrentVersion = new NuGetVersion(package.CurrentVersion!);
+            NuGetVersion newerVersion = new NuGetVersion(package.NewVersion!);
 
             // If the CurrentVersion is less than or equal to the newerVersion, proceed with the update
             if (CurrentVersion <= newerVersion)
             {
-                string currentVersiontemp = package.CurrentVersion;
+                string? currentVersiontemp = package.CurrentVersion;
                 package.CurrentVersion = package.NewVersion;
 
                 // Check if the current package has dependencies 
-                List<PackageToUpdate> dependencyList = await GetDependenciesAsync(package, targetFramework, projectDirectory, logger);
+                List<PackageToUpdate>? dependencyList = await GetDependenciesAsync(package, targetFramework, projectDirectory, logger);
 
                 // If there are dependencies
                 if (dependencyList != null)
@@ -379,14 +378,14 @@ public class PackageManager
                             // If you find the dependency
                             if (string.Equals(dependency.PackageName, existingPackage.PackageName, StringComparison.OrdinalIgnoreCase))
                             {
-                                NuGetVersion existingCurrentVersion = new NuGetVersion(existingPackage.CurrentVersion);
-                                NuGetVersion dependencyCurrentVersion = new NuGetVersion(dependency.CurrentVersion);
+                                NuGetVersion existingCurrentVersion = new NuGetVersion(existingPackage.CurrentVersion!);
+                                NuGetVersion dependencyCurrentVersion = new NuGetVersion(dependency.CurrentVersion!);
 
                                 // Check if the existing version is less than the dependency's existing version
                                 if (existingCurrentVersion < dependencyCurrentVersion)
                                 {
                                     // Create temporary copy of the current version and of the existing package
-                                    string dependencyOldVersion = existingPackage.CurrentVersion;
+                                    string? dependencyOldVersion = existingPackage.CurrentVersion;
 
                                     // Susbtitute the current version of the existingPackage with the dependency current version
                                     existingPackage.CurrentVersion = dependency.CurrentVersion;
@@ -411,7 +410,7 @@ public class PackageManager
                         }
 
                         // If the dependency has brackets or parenthesis, it's a specific version
-                        if (dependency.CurrentVersion.Contains('[') || dependency.CurrentVersion.Contains(']') || dependency.CurrentVersion.Contains('{') || dependency.CurrentVersion.Contains('}'))
+                        if (dependency.CurrentVersion is not null && (dependency.CurrentVersion.Contains('[') || dependency.CurrentVersion.Contains(']') || dependency.CurrentVersion.Contains('{') || dependency.CurrentVersion.Contains('}')))
                         {
                             dependency.IsSpecific = true;
                         }
@@ -433,7 +432,7 @@ public class PackageManager
                     if (!isCompatible)
                     {
                         // Attempt to find and update to a compatible version between the two
-                        NuGetVersion compatibleVersion = await FindCompatibleVersionAsync(existingPackages, parent, package, targetFramework, logger);
+                        NuGetVersion? compatibleVersion = await FindCompatibleVersionAsync(existingPackages, parent, package, targetFramework, logger);
                         if (compatibleVersion == null)
                         {
                             return "Failed to update";
@@ -447,32 +446,32 @@ public class PackageManager
                     // If it's compatible and the package you updated wasn't in the existing package, check if the parent's dependencies version is the same as the current version
                     else if (isCompatible == true && inExisting == false)
                     {
-                        List<PackageToUpdate> dependencyListParent = await GetDependenciesAsync(parent, targetFramework, projectDirectory, logger);
+                        List<PackageToUpdate>? dependencyListParent = await GetDependenciesAsync(parent, targetFramework, projectDirectory, logger);
 
-                        PackageToUpdate parentDependency = dependencyListParent.FirstOrDefault(p => string.Compare(p.PackageName, package.PackageName, StringComparison.OrdinalIgnoreCase) == 0);
+                        PackageToUpdate? parentDependency = dependencyListParent?.FirstOrDefault(p => string.Compare(p.PackageName, package.PackageName, StringComparison.OrdinalIgnoreCase) == 0);
 
                         // If the parent's dependency current version is not the same as the current version of the package
-                        if (parentDependency.CurrentVersion != package.CurrentVersion)
+                        if (parentDependency is not null && parentDependency.CurrentVersion != package.CurrentVersion)
                         {
                             // Create a NugetContext instance to get the latest versions of the parent
                             NuGetContext nugetContext = new NuGetContext(Path.GetDirectoryName(projectPath));
 
-                            string currentVersionString = parent.CurrentVersion;
-                            NuGetVersion currentVersionParent = NuGetVersion.Parse(currentVersionString);
+                            string? currentVersionString = parent.CurrentVersion;
+                            NuGetVersion currentVersionParent = NuGetVersion.Parse(currentVersionString!);
 
                             var result = await VersionFinder.GetVersionsByNameAsync([projectFramework], parent.PackageName, currentVersionParent, nugetContext, logger, CancellationToken.None);
                             var versions = result.GetVersions();
-                            NuGetVersion latestVersion = versions.Where(v => !v.IsPrerelease).Max();
+                            NuGetVersion? latestVersion = versions.Where(v => !v.IsPrerelease).Max();
 
                             // 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 = currentVersionParent; version is not null && version <= latestVersion; version = NextPatch(version, versions))
+                            for (NuGetVersion? version = currentVersionParent; version is not null && latestVersion is not null && version <= latestVersion; version = NextPatch(version, versions))
                             {
                                 // Check if the parent needs to be updated since the child isn't in the existing package list  and the parent can update to a newer version to remove the dependency
-                                List<PackageToUpdate> dependencyListParentTemp = await GetDependenciesAsync(parent, targetFramework, projectDirectory, logger);
-                                PackageToUpdate parentDependencyTemp = dependencyListParentTemp.FirstOrDefault(p => string.Compare(p.PackageName, package.PackageName, StringComparison.OrdinalIgnoreCase) == 0);
+                                List<PackageToUpdate>? dependencyListParentTemp = await GetDependenciesAsync(parent, targetFramework, projectDirectory, logger);
+                                PackageToUpdate? parentDependencyTemp = dependencyListParentTemp?.FirstOrDefault(p => string.Compare(p.PackageName, package.PackageName, StringComparison.OrdinalIgnoreCase) == 0);
 
                                 // If the newer package version of the parent has the same version as the parent's previous dependency, update
-                                if (parentDependencyTemp.CurrentVersion == package.CurrentVersion)
+                                if (parentDependencyTemp is not null && parentDependencyTemp.CurrentVersion == package.CurrentVersion)
                                 {
                                     parent.NewVersion = version.ToString();
                                     parent.CurrentVersion = null;
@@ -504,7 +503,12 @@ public class PackageManager
     public async Task<bool> IsCompatibleAsync(PackageToUpdate parent, PackageToUpdate child, string targetFramework, string projectDirectory, ILogger logger)
     {
         // Get the dependencies of the parent
-        List<PackageToUpdate> dependencies = await GetDependenciesAsync(parent, targetFramework, projectDirectory, logger);
+        List<PackageToUpdate>? dependencies = await GetDependenciesAsync(parent, targetFramework, projectDirectory, logger);
+
+        if (dependencies is null)
+        {
+            return false;
+        }
 
         foreach (PackageToUpdate dependency in dependencies)
         {
@@ -512,8 +516,8 @@ public class PackageManager
             // If the child is present
             if (string.Equals(dependency.PackageName, child.PackageName, StringComparison.OrdinalIgnoreCase))
             {
-                NuGetVersion dependencyVersion = new NuGetVersion(dependency.CurrentVersion);
-                NuGetVersion childVersion = new NuGetVersion(child.CurrentVersion);
+                NuGetVersion dependencyVersion = new NuGetVersion(dependency.CurrentVersion!);
+                NuGetVersion childVersion = new NuGetVersion(child.CurrentVersion!);
 
                 // If the dependency version of the parent and the childversion is the same, or if the child version can be >=
                 if (dependencyVersion == childVersion || (childVersion > dependencyVersion && dependency.IsSpecific != true))
@@ -538,13 +542,13 @@ public class PackageManager
     }
 
     // Method to find a compatible version with the child for the parent to update to
-    public async Task<NuGetVersion> FindCompatibleVersionAsync(List<PackageToUpdate> existingPackages, PackageToUpdate possibleParent, PackageToUpdate possibleDependency, string targetFramework, ILogger logger)
+    public async Task<NuGetVersion?> FindCompatibleVersionAsync(List<PackageToUpdate> existingPackages, PackageToUpdate possibleParent, PackageToUpdate possibleDependency, string targetFramework, ILogger logger)
     {
         string packageId = possibleParent.PackageName;
-        string currentVersionString = possibleParent.CurrentVersion;
-        NuGetVersion CurrentVersion = NuGetVersion.Parse(currentVersionString);
-        string currentVersionStringDependency = possibleDependency.CurrentVersion;
-        NuGetVersion currentVersionDependency = NuGetVersion.Parse(currentVersionStringDependency);
+        string? currentVersionString = possibleParent.CurrentVersion;
+        NuGetVersion CurrentVersion = NuGetVersion.Parse(currentVersionString!);
+        string? currentVersionStringDependency = possibleDependency.CurrentVersion;
+        NuGetVersion currentVersionDependency = NuGetVersion.Parse(currentVersionStringDependency!);
 
         // Create a NugetContext instance to get the latest versions of the parent
         NuGetContext nugetContext = new NuGetContext(Path.GetDirectoryName(projectPath));
@@ -559,7 +563,7 @@ public class PackageManager
             return null;
         }
 
-        NuGetVersion latestVersion = versions
+        NuGetVersion? latestVersion = versions
             .Where(v => !v.IsPrerelease)
            .Max();
 
@@ -577,7 +581,7 @@ public class PackageManager
         }
 
         // 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 is not null && version <= latestVersion; version = NextPatch(version, versions))
+        for (NuGetVersion? version = CurrentVersion; version is not null && latestVersion is not null && version <= latestVersion; version = NextPatch(version, versions))
         {
             possibleParent.NewVersion = version.ToString();
 
@@ -588,7 +592,7 @@ public class PackageManager
                 if (await AreAllParentsCompatibleAsync(existingPackages, possibleParent, targetFramework, nugetContext.CurrentDirectory, logger))
                 {
                     // If compatible, return the new version
-                    if (Regex.IsMatch(possibleParent.NewVersion, @"[a-zA-Z]"))
+                    if (Regex.IsMatch(possibleParent.NewVersion!, @"[a-zA-Z]"))
                     {
                         possibleParent.IsSpecific = true;
                     }
@@ -616,7 +620,7 @@ public class PackageManager
             if (!isCompatible)
             {
                 // Find a compatible version if possible
-                NuGetVersion compatibleVersion = await FindCompatibleVersionAsync(existingPackages, parent, possibleParent, targetFramework, logger);
+                NuGetVersion? compatibleVersion = await FindCompatibleVersionAsync(existingPackages, parent, possibleParent, targetFramework, logger);
                 if (compatibleVersion == null)
                 {
                     return false;
@@ -641,7 +645,7 @@ public class PackageManager
     {
         foreach (PackageToUpdate packageToUpdate in packagesToUpdate)
         {
-            PackageToUpdate existingPackage = existingPackages.FirstOrDefault(p => string.Compare(p.PackageName, packageToUpdate.PackageName, StringComparison.OrdinalIgnoreCase) == 0);
+            PackageToUpdate? existingPackage = existingPackages.FirstOrDefault(p => string.Compare(p.PackageName, packageToUpdate.PackageName, StringComparison.OrdinalIgnoreCase) == 0);
 
             if (existingPackage != null)
             {