Fixed a missing nullable value that only happens in tests.

Author: MiYanni

src/Cli/dotnet/CommandFactory/CommandResolution/LocalToolsCommandResolver.cs

@@ -1,30 +1,27 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using Microsoft.DotNet.Cli.Commands.Tool;
 using Microsoft.DotNet.Cli.ToolManifest;
 using Microsoft.DotNet.Cli.ToolPackage;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.Extensions.EnvironmentAbstractions;
-using NuGet.DependencyResolver;
 using NuGet.Frameworks;
 
 namespace Microsoft.DotNet.Cli.CommandFactory.CommandResolution;
 
 internal class LocalToolsCommandResolver(
-    ToolManifestFinder toolManifest = null,
-    ILocalToolsResolverCache localToolsResolverCache = null,
-    IFileSystem fileSystem = null,
-    string currentWorkingDirectory = null) : ICommandResolver
+    ToolManifestFinder? toolManifest = null,
+    ILocalToolsResolverCache? localToolsResolverCache = null,
+    IFileSystem? fileSystem = null,
+    string? currentWorkingDirectory = null) : ICommandResolver
 {
     private readonly ToolManifestFinder _toolManifest = toolManifest ?? new ToolManifestFinder(new DirectoryPath(currentWorkingDirectory ?? Directory.GetCurrentDirectory()));
     private readonly ILocalToolsResolverCache _localToolsResolverCache = localToolsResolverCache ?? new LocalToolsResolverCache();
     private readonly IFileSystem _fileSystem = fileSystem ?? new FileSystemWrapper();
     private const string LeadingDotnetPrefix = "dotnet-";
 
-    public CommandSpec ResolveStrict(CommandResolverArguments arguments, bool allowRollForward = false)
+    public CommandSpec? ResolveStrict(CommandResolverArguments arguments, bool allowRollForward = false)
     {
         if (arguments == null || string.IsNullOrWhiteSpace(arguments.CommandName))
         {
@@ -42,7 +39,7 @@ public CommandSpec ResolveStrict(CommandResolverArguments arguments, bool allowR
         return resolveResult;
     }
 
-    public CommandSpec Resolve(CommandResolverArguments arguments)
+    public CommandSpec? Resolve(CommandResolverArguments arguments)
     {
         if (arguments == null || string.IsNullOrWhiteSpace(arguments.CommandName))
         {
@@ -69,7 +66,7 @@ public CommandSpec Resolve(CommandResolverArguments arguments)
         return GetPackageCommandSpecUsingMuxer(arguments, new ToolCommandName(arguments.CommandName));
     }
 
-    private CommandSpec GetPackageCommandSpecUsingMuxer(CommandResolverArguments arguments,
+    private CommandSpec? GetPackageCommandSpecUsingMuxer(CommandResolverArguments arguments,
         ToolCommandName toolCommandName, bool allowRollForward = false)
     {
         if (!_toolManifest.TryFind(toolCommandName, out var toolManifestPackage))
@@ -93,7 +90,7 @@ private CommandSpec GetPackageCommandSpecUsingMuxer(CommandResolverArguments arg
             }
 
             return ToolCommandSpecCreator.CreateToolCommandSpec(toolCommand.Name.Value, toolCommand.Executable.Value, toolCommand.Runner,
-                toolManifestPackage.RollForward || allowRollForward, arguments.CommandArguments);
+                toolManifestPackage.RollForward || allowRollForward, arguments.CommandArguments ?? []);
         }
         else
         {

src/Cli/dotnet/Commands/Tool/Execute/ToolExecuteCommand.cs

@@ -38,7 +38,7 @@ public ToolExecuteCommand(ParseResult result, ToolManifestFinder? toolManifestFi
         : base(result)
     {
         _packageToolIdentityArgument = result.GetValue(Definition.PackageIdentityArgument);
-        _forwardArguments = result.GetValue(Definition.CommandArgument) ?? Enumerable.Empty<string>();
+        _forwardArguments = result.GetValue(Definition.CommandArgument) ?? [];
         _allowRollForward = result.GetValue(Definition.RollForwardOption);
         _configFile = result.GetValue(Definition.ConfigOption);
         _sources = result.GetValue(Definition.SourceOption) ?? [];

src/Cli/dotnet/Commands/Tool/Run/ToolRunCommand.cs

@@ -34,7 +34,7 @@ public override int Execute()
     public static int ExecuteCommand(LocalToolsCommandResolver commandResolver, string? toolCommandName, IEnumerable<string>? argumentsToForward, bool allowRollForward)
     {
         using var _ = Activities.Source.StartActivity("execute-local-tool");
-        CommandSpec commandSpec = commandResolver.ResolveStrict(new CommandResolverArguments()
+        CommandSpec? commandSpec = commandResolver.ResolveStrict(new CommandResolverArguments()
         {
             // since LocalToolsCommandResolver is a resolver, and all resolver input have dotnet-
             CommandName = $"dotnet-{toolCommandName}",
@@ -49,4 +49,4 @@ public static int ExecuteCommand(LocalToolsCommandResolver commandResolver, stri
         var result = CommandFactoryUsingResolver.Create(commandSpec).Execute();
         return result.ExitCode;
     }
-}
+}

test/dotnet.Tests/CommandFactoryTests/GivenALocalToolsCommandResolver.cs

@@ -214,15 +214,23 @@ [new RestoredCommandIdentifier(
                _localToolsResolverCache,
                _fileSystem);
 
-            localToolsCommandResolver.Resolve(new CommandResolverArguments()
+            var commandSpecA = localToolsCommandResolver.Resolve(new CommandResolverArguments()
             {
                 CommandName = "dotnet-a",
-            }).Args!.Trim('"').Should().Be(fakeExecutableA.Value);
+            });
+            commandSpecA.Should().NotBeNull();
+            var argsA = commandSpecA.Args;
+            argsA.Should().NotBeNull();
+            argsA.Trim('"').Should().Be(fakeExecutableA.Value);
 
-            localToolsCommandResolver.Resolve(new CommandResolverArguments()
+            var commandSpecDotnetA = localToolsCommandResolver.Resolve(new CommandResolverArguments()
             {
                 CommandName = "dotnet-dotnet-a",
-            }).Args!.Trim('"').Should().Be(fakeExecutableDotnetA.Value);
+            });
+            commandSpecDotnetA.Should().NotBeNull();
+            var argsDotnetA = commandSpecDotnetA.Args;
+            argsDotnetA.Should().NotBeNull();
+            argsDotnetA.Trim('"').Should().Be(fakeExecutableDotnetA.Value);
         }
 
         private string _jsonContent =