Cleaned up the remaining changed src files. Avoided ToolPackageDownloader and ToolPackageDownloaderBase since those will be updated in main. Not interested in cleaning up test files.

Author: MiYanni

src/Cli/Microsoft.DotNet.InternalAbstractions/FilePath.cs

@@ -1,34 +1,33 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-namespace Microsoft.Extensions.EnvironmentAbstractions
+namespace Microsoft.Extensions.EnvironmentAbstractions;
+
+public readonly struct FilePath
 {
-    public struct FilePath
-    {
-        public string Value { get; }
+    public string Value { get; }
 
-        /// <summary>
-        /// Create FilePath to represent an absolute file path. Note it may not exist.
-        /// </summary>
-        /// <param name="value">If the value is not rooted. Path.GetFullPath will be called during the constructor.</param>
-        public FilePath(string value)
+    /// <summary>
+    /// Create FilePath to represent an absolute file path. Note: It may not exist.
+    /// </summary>
+    /// <param name="value">If the value is not rooted. Path.GetFullPath will be called during the constructor.</param>
+    public FilePath(string value)
+    {
+        if (!Path.IsPathRooted(value))
         {
-            if (!Path.IsPathRooted(value))
-            {
-                value = Path.GetFullPath(value);
-            }
-
-            Value = value;
+            value = Path.GetFullPath(value);
         }
 
-        public override string ToString()
-        {
-            return Value;
-        }
+        Value = value;
+    }
 
-        public DirectoryPath GetDirectoryPath()
-        {
-            return new DirectoryPath(Path.GetDirectoryName(Value)!);
-        }
+    public override string ToString()
+    {
+        return Value;
+    }
+
+    public DirectoryPath GetDirectoryPath()
+    {
+        return new DirectoryPath(Path.GetDirectoryName(Value)!);
     }
 }

src/Cli/dotnet/CommandDirectoryContext.cs

@@ -35,7 +35,7 @@ public static void PerformActionWithBasePath(string basePath, Action action)
                 $"Calls to {nameof(CommandDirectoryContext)}.{nameof(PerformActionWithBasePath)} cannot be nested.");
         }
         _basePath = basePath;
-        Telemetry.Telemetry.CurrentSessionId = null;
+        Telemetry.Telemetry.s_currentSessionId = null;
         try
         {
             action();

src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs

@@ -16,7 +16,7 @@ public class MSBuildForwardingApp : CommandBase
 
     private static MSBuildArgs ConcatTelemetryLogger(MSBuildArgs msbuildArgs)
     {
-        if (Telemetry.Telemetry.CurrentSessionId != null)
+        if (Telemetry.Telemetry.s_currentSessionId != null)
         {
             try
             {
@@ -73,7 +73,7 @@ public ProcessStartInfo GetProcessStartInfo()
 
     private void InitializeRequiredEnvironmentVariables()
     {
-        EnvironmentVariable(TelemetrySessionIdEnvironmentVariableName, Telemetry.Telemetry.CurrentSessionId);
+        EnvironmentVariable(TelemetrySessionIdEnvironmentVariableName, Telemetry.Telemetry.s_currentSessionId);
     }
 
     /// <summary>

src/Cli/dotnet/CommonOptionsFactory.cs

@@ -1,9 +1,8 @@
 // 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 System.CommandLine;
+using System.CommandLine.Invocation;
 using System.CommandLine.Parsing;
 using Microsoft.DotNet.Cli.Extensions;
 using Microsoft.DotNet.Cli.Utils;
@@ -25,7 +24,7 @@ internal static class CommonOptionsFactory
         Arity = ArgumentArity.Zero
     };
 
-    internal class SetDiagnosticModeAction(Option<bool> diagnosticOption) : System.CommandLine.Invocation.SynchronousCommandLineAction
+    internal class SetDiagnosticModeAction(Option<bool> diagnosticOption) : SynchronousCommandLineAction
     {
         public override int Invoke(ParseResult parseResult)
         {
@@ -42,6 +41,7 @@ public override int Invoke(ParseResult parseResult)
                     Reporter.Reset();
                 }
             }
+
             return 0;
         }
     }

src/Cli/dotnet/Extensions/ParseResultExtensions.cs

@@ -15,21 +15,21 @@ namespace Microsoft.DotNet.Cli.Extensions;
 
 public static class ParseResultExtensions
 {
-    ///<summary>
+    /// <summary>
     /// Finds the command of the parse result and invokes help for that command.
     /// If no command is specified, invokes help for the application.
-    ///<summary>
-    ///<remarks>
+    /// <summary>
+    /// <remarks>
     /// This is accomplished by finding a set of tokens that should be valid and appending a help token
     /// to that list, then re-parsing the list of tokens. This is not ideal - either we should have a direct way
     /// of invoking help for a ParseResult, or we should eliminate this custom, ad-hoc help invocation by moving
     /// more situations that want to show help into Parsing Errors (which trigger help in the default System.CommandLine pipeline)
     /// or custom Invocation Middleware, so we can more easily create our version of a HelpResult type.
-    ///</remarks>
+    /// </remarks>
     public static void ShowHelp(this ParseResult parseResult)
     {
-        // take from the start of the list until we hit an option/--/unparsed token
-        // since commands can have arguments, we must take those as well in order to get accurate help
+        // Take from the start of the list until we hit an option/--/unparsed token.
+        // Since commands can have arguments, we must take those as well in order to get accurate help.
         var tokenList = parseResult.Tokens.TakeWhile(token => token.Type == TokenType.Argument || token.Type == TokenType.Command || token.Type == TokenType.Directive).Select(t => t.Value).ToList();
         tokenList.Add("-h");
         Instance.Parse(tokenList).Invoke();
@@ -55,14 +55,17 @@ public static void ShowHelpOrErrorIfAppropriate(this ParseResult parseResult)
             }
         }
 
-        ///<summary>Splits a .NET format string by the format placeholders (the {N} parts) to get an array of the literal parts, to be used in message-checking</summary>
+        /// <summary>
+        /// Splits a .NET format string by the format placeholders (the {N} parts) to get an array of the literal parts, to be used in message-checking.
+        /// </summary>
         static string[] DistinctFormatStringParts(string formatString)
         {
             return Regex.Split(formatString, @"{[0-9]+}"); // match the literal '{', followed by any of 0-9 one or more times, followed by the literal '}'
         }
 
-
-        /// <summary>given a string and a series of parts, ensures that all parts are present in the string in sequential order</summary>
+        /// <summary>
+        /// Given a string and a series of parts, ensures that all parts are present in the string in sequential order.
+        /// </summary>
         static bool ErrorContainsAllParts(ReadOnlySpan<char> error, string[] parts)
         {
             foreach (var part in parts)
@@ -160,13 +163,6 @@ public static bool DiagOptionPrecedesSubcommand(this string[] args, string subCo
         return false;
     }
 
-    private static string? GetSymbolResultValue(ParseResult parseResult, SymbolResult symbolResult) => symbolResult switch
-    {
-        CommandResult commandResult => commandResult.Command.Name,
-        ArgumentResult argResult => argResult.Tokens.FirstOrDefault()?.Value,
-        _ => parseResult.GetResult(DotnetSubCommand)?.GetValueOrDefault<string>()
-    };
-
     public static bool BothArchAndOsOptionsSpecified(this ParseResult parseResult) =>
         (parseResult.HasOption(CommonOptions.ArchitectureOption) ||
         parseResult.HasOption(CommonOptions.LongFormArchitectureOption)) &&
@@ -187,7 +183,7 @@ public static bool BothArchAndOsOptionsSpecified(this ParseResult parseResult) =
 
     public static bool UsingRunCommandShorthandProjectOption(this ParseResult parseResult)
     {
-        if (parseResult.HasOption(RunCommandParser.PropertyOption) && parseResult.GetValue(RunCommandParser.PropertyOption)!.Any())
+        if (parseResult.HasOption(RunCommandParser.PropertyOption) && (parseResult.GetValue(RunCommandParser.PropertyOption)?.Any() ?? false))
         {
             var projVals = parseResult.GetRunCommandShorthandProjectValues();
             if (projVals?.Any() is true)

src/Cli/dotnet/Parser.cs

@@ -1,8 +1,6 @@
 // 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 System.CommandLine;
 using System.CommandLine.Completions;
 using System.CommandLine.Invocation;
@@ -105,12 +103,13 @@ public static class Parser
         Action = new PrintVersionAction()
     };
 
-    internal class PrintVersionAction : System.CommandLine.Invocation.SynchronousCommandLineAction
+    internal class PrintVersionAction : SynchronousCommandLineAction
     {
         public PrintVersionAction()
         {
             Terminating = true;
         }
+
         public override int Invoke(ParseResult parseResult)
         {
             CommandLineInfo.PrintVersion();
@@ -124,7 +123,7 @@ public override int Invoke(ParseResult parseResult)
         Action = new PrintInfoAction()
     };
 
-    internal class PrintInfoAction : System.CommandLine.Invocation.SynchronousCommandLineAction
+    internal class PrintInfoAction : SynchronousCommandLineAction
     {
         public PrintInfoAction()
         {
@@ -220,14 +219,14 @@ private static Command ConfigureCommandLine(RootCommand rootCommand)
         return rootCommand;
     }
 
-    public static Command GetBuiltInCommand(string commandName) =>
+    public static Command? GetBuiltInCommand(string commandName) =>
         Subcommands.FirstOrDefault(c => c.Name.Equals(commandName, StringComparison.OrdinalIgnoreCase));
 
     /// <summary>
     /// Implements token-per-line response file handling for the CLI. We use this instead of the built-in S.CL handling
     /// to ensure backwards-compatibility with MSBuild.
     /// </summary>
-    public static bool TokenPerLine(string tokenToReplace, out IReadOnlyList<string> replacementTokens, out string errorMessage)
+    public static bool TokenPerLine(string tokenToReplace, out IReadOnlyList<string>? replacementTokens, out string? errorMessage)
     {
         var filePath = Path.GetFullPath(tokenToReplace);
         if (File.Exists(filePath))
@@ -260,7 +259,7 @@ public static bool TokenPerLine(string tokenToReplace, out IReadOnlyList<string>
         ResponseFileTokenReplacer = TokenPerLine
     };
 
-    internal static int ExceptionHandler(Exception exception, ParseResult parseResult)
+    internal static int ExceptionHandler(Exception? exception, ParseResult parseResult)
     {
         if (exception is TargetInvocationException)
         {
@@ -280,13 +279,13 @@ internal static int ExceptionHandler(Exception exception, ParseResult parseResul
                 exception.Message.Red().Bold());
             parseResult.ShowHelp();
         }
-        else if (exception.GetType().Name.Equals("WorkloadManifestCompositionException"))
+        else if (exception is not null && exception.GetType().Name.Equals("WorkloadManifestCompositionException"))
         {
             Reporter.Error.WriteLine(CommandLoggingContext.IsVerbose ?
                 exception.ToString().Red().Bold() :
                 exception.Message.Red().Bold());
         }
-        else
+        else if (exception is not null)
         {
             Reporter.Error.Write("Unhandled exception: ".Red().Bold());
             Reporter.Error.WriteLine(CommandLoggingContext.IsVerbose ?
@@ -374,7 +373,7 @@ public override void Write(HelpContext context)
             }
             else if (command.Name.Equals(FormatCommandParser.GetCommand().Name))
             {
-                var arguments = context.ParseResult.GetValue(FormatCommandParser.Arguments);
+                var arguments = context.ParseResult.GetValue(FormatCommandParser.Arguments) ?? [];
                 new FormatForwardingApp([.. arguments, .. helpArgs]).Execute();
             }
             else if (command.Name.Equals(FsiCommandParser.GetCommand().Name))
@@ -401,9 +400,9 @@ public override void Write(HelpContext context)
             {
                 if (command.Name.Equals(ListReferenceCommandParser.GetCommand().Name))
                 {
-                    Command listCommand = command.Parents.Single() as Command;
+                    Command? listCommand = command.Parents.Single() as Command;
 
-                    for (int i = 0; i < listCommand.Arguments.Count; i++)
+                    for (int i = 0; i < listCommand?.Arguments.Count; i++)
                     {
                         if (listCommand.Arguments[i].Name == CliStrings.SolutionOrProjectArgumentName)
                         {
@@ -434,6 +433,7 @@ internal PrintCliSchemaAction()
         {
             Terminating = true;
         }
+
         public override int Invoke(ParseResult parseResult)
         {
             CliSchema.PrintCliSchema(parseResult.CommandResult, parseResult.Configuration.Output, Program.TelemetryClient);