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.

MiYanni · MiYanni · commit 8e1af86c4025 · 2025-06-27T17:20:04.000-07:00
diff --git a/src/Cli/Microsoft.DotNet.InternalAbstractions/FilePath.cs b/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)!);
     }
 }
diff --git a/src/Cli/dotnet/CommandDirectoryContext.cs b/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();
diff --git a/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs b/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs
@@ -18,7 +18,7 @@ public class MSBuildForwardingApp : CommandBase
 
     private static IEnumerable<string> ConcatTelemetryLogger(IEnumerable<string> argsToForward)
     {
-        if (Telemetry.Telemetry.CurrentSessionId != null)
+        if (Telemetry.Telemetry.s_currentSessionId != null)
         {
             try
             {
@@ -66,7 +66,7 @@ public ProcessStartInfo GetProcessStartInfo()
 
     private void InitializeRequiredEnvironmentVariables()
     {
-        EnvironmentVariable(TelemetrySessionIdEnvironmentVariableName, Telemetry.Telemetry.CurrentSessionId);
+        EnvironmentVariable(TelemetrySessionIdEnvironmentVariableName, Telemetry.Telemetry.s_currentSessionId);
     }
 
     /// <summary>
diff --git a/src/Cli/dotnet/CommonOptionsFactory.cs b/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;
         }
     }
diff --git a/src/Cli/dotnet/Extensions/ParseResultExtensions.cs b/src/Cli/dotnet/Extensions/ParseResultExtensions.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.Parsing;
 using System.Diagnostics;
@@ -17,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();
@@ -57,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)
@@ -162,19 +163,12 @@ 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 ?? string.Empty,
-        _ => parseResult.GetResult(DotnetSubCommand)?.GetValueOrDefault<string>()
-    };
-
     public static bool BothArchAndOsOptionsSpecified(this ParseResult parseResult) =>
         (parseResult.HasOption(CommonOptions.ArchitectureOption) ||
         parseResult.HasOption(CommonOptions.LongFormArchitectureOption)) &&
         parseResult.HasOption(CommonOptions.OperatingSystemOption);
 
-    internal static string GetCommandLineRuntimeIdentifier(this ParseResult parseResult)
+    internal static string? GetCommandLineRuntimeIdentifier(this ParseResult parseResult)
     {
         return parseResult.HasOption(CommonOptions.RuntimeOptionName) ?
             parseResult.GetValue<string>(CommonOptions.RuntimeOptionName) :
@@ -189,7 +183,7 @@ internal static string GetCommandLineRuntimeIdentifier(this ParseResult parseRes
 
     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())
@@ -225,7 +219,7 @@ private static IEnumerable<string> GetRunPropertyOptions(ParseResult parseResult
         var propertyValues = propertyOptions.SelectMany(o => o.Tokens.Select(t => t.Value)).ToArray();
         return propertyValues;
 
-        static Token GetOptionTokenOrDefault(SymbolResult symbolResult)
+        static Token? GetOptionTokenOrDefault(SymbolResult symbolResult)
         {
             if (symbolResult is not OptionResult optionResult)
             {
@@ -251,7 +245,7 @@ public static void HandleDebugSwitch(this ParseResult parseResult)
     /// If you are inside a command handler or 'normal' System.CommandLine code then you don't need this - the parse error handling
     /// will have covered these cases.
     /// </summary>
-    public static T SafelyGetValueForOption<T>(this ParseResult parseResult, Option<T> optionToGet)
+    public static T? SafelyGetValueForOption<T>(this ParseResult parseResult, Option<T> optionToGet)
     {
         if (parseResult.GetResult(optionToGet) is OptionResult optionResult &&
             !parseResult.Errors.Any(e => e.SymbolResult == optionResult))
diff --git a/src/Cli/dotnet/Parser.cs b/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);
diff --git a/src/Cli/dotnet/Program.cs b/src/Cli/dotnet/Program.cs
diff --git a/src/Cli/dotnet/Telemetry/Telemetry.cs b/src/Cli/dotnet/Telemetry/Telemetry.cs
diff --git a/src/Cli/dotnet/Telemetry/TelemetryCommonProperties.cs b/src/Cli/dotnet/Telemetry/TelemetryCommonProperties.cs

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public static void PerformActionWithBasePath(string basePath, Action action)`
`35`	`35`	`$"Calls to {nameof(CommandDirectoryContext)}.{nameof(PerformActionWithBasePath)} cannot be nested.");`
`36`	`36`	`}`
`37`	`37`	`_basePath = basePath;`
`38`		`- Telemetry.Telemetry.CurrentSessionId = null;`
	`38`	`+ Telemetry.Telemetry.s_currentSessionId = null;`
`39`	`39`	`try`
`40`	`40`	`{`
`41`	`41`	`action();`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public class MSBuildForwardingApp : CommandBase`
`18`	`18`
`19`	`19`	`private static IEnumerable<string> ConcatTelemetryLogger(IEnumerable<string> argsToForward)`
`20`	`20`	`{`
`21`		`- if (Telemetry.Telemetry.CurrentSessionId != null)`
	`21`	`+ if (Telemetry.Telemetry.s_currentSessionId != null)`
`22`	`22`	`{`
`23`	`23`	`try`
`24`	`24`	`{`
`@@ -66,7 +66,7 @@ public ProcessStartInfo GetProcessStartInfo()`
`66`	`66`
`67`	`67`	`private void InitializeRequiredEnvironmentVariables()`
`68`	`68`	`{`
`69`		`- EnvironmentVariable(TelemetrySessionIdEnvironmentVariableName, Telemetry.Telemetry.CurrentSessionId);`
	`69`	`+ EnvironmentVariable(TelemetrySessionIdEnvironmentVariableName, Telemetry.Telemetry.s_currentSessionId);`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,8 @@`
`1`	`1`	`// Licensed to the .NET Foundation under one or more agreements.`
`2`	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
`3`	`3`
`4`		`-#nullable disable`
`5`		`-`
`6`	`4`	`using System.CommandLine;`
	`5`	`+using System.CommandLine.Invocation;`
`7`	`6`	`using System.CommandLine.Parsing;`
`8`	`7`	`using Microsoft.DotNet.Cli.Extensions;`
`9`	`8`	`using Microsoft.DotNet.Cli.Utils;`
`@@ -25,7 +24,7 @@ internal static class CommonOptionsFactory`
`25`	`24`	`Arity = ArgumentArity.Zero`
`26`	`25`	`};`
`27`	`26`
`28`		`- internal class SetDiagnosticModeAction(Option<bool> diagnosticOption) : System.CommandLine.Invocation.SynchronousCommandLineAction`
	`27`	`+ internal class SetDiagnosticModeAction(Option<bool> diagnosticOption) : SynchronousCommandLineAction`
`29`	`28`	`{`
`30`	`29`	`public override int Invoke(ParseResult parseResult)`
`31`	`30`	`{`
`@@ -42,6 +41,7 @@ public override int Invoke(ParseResult parseResult)`
`42`	`41`	`Reporter.Reset();`
`43`	`42`	`}`
`44`	`43`	`}`
	`44`	`+`
`45`	`45`	`return 0;`
`46`	`46`	`}`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,6 @@`
`1`	`1`	`// Licensed to the .NET Foundation under one or more agreements.`
`2`	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
`3`	`3`
`4`		`-#nullable disable`
`5`		`-`
`6`	`4`	`using System.CommandLine;`
`7`	`5`	`using System.CommandLine.Completions;`
`8`	`6`	`using System.CommandLine.Invocation;`
`@@ -105,12 +103,13 @@ public static class Parser`
`105`	`103`	`Action = new PrintVersionAction()`
`106`	`104`	`};`
`107`	`105`
`108`		`- internal class PrintVersionAction : System.CommandLine.Invocation.SynchronousCommandLineAction`
	`106`	`+ internal class PrintVersionAction : SynchronousCommandLineAction`
`109`	`107`	`{`
`110`	`108`	`public PrintVersionAction()`
`111`	`109`	`{`
`112`	`110`	`Terminating = true;`
`113`	`111`	`}`
	`112`	`+`
`114`	`113`	`public override int Invoke(ParseResult parseResult)`
`115`	`114`	`{`
`116`	`115`	`CommandLineInfo.PrintVersion();`
`@@ -124,7 +123,7 @@ public override int Invoke(ParseResult parseResult)`
`124`	`123`	`Action = new PrintInfoAction()`
`125`	`124`	`};`
`126`	`125`
`127`		`- internal class PrintInfoAction : System.CommandLine.Invocation.SynchronousCommandLineAction`
	`126`	`+ internal class PrintInfoAction : SynchronousCommandLineAction`
`128`	`127`	`{`
`129`	`128`	`public PrintInfoAction()`
`130`	`129`	`{`
`@@ -220,14 +219,14 @@ private static Command ConfigureCommandLine(RootCommand rootCommand)`
`220`	`219`	`return rootCommand;`
`221`	`220`	`}`
`222`	`221`
`223`		`- public static Command GetBuiltInCommand(string commandName) =>`
	`222`	`+ public static Command? GetBuiltInCommand(string commandName) =>`
`224`	`223`	`Subcommands.FirstOrDefault(c => c.Name.Equals(commandName, StringComparison.OrdinalIgnoreCase));`
`225`	`224`
`226`	`225`	`/// <summary>`
`227`	`226`	`/// Implements token-per-line response file handling for the CLI. We use this instead of the built-in S.CL handling`
`228`	`227`	`/// to ensure backwards-compatibility with MSBuild.`
`229`	`228`	`/// </summary>`
`230`		`- public static bool TokenPerLine(string tokenToReplace, out IReadOnlyList<string> replacementTokens, out string errorMessage)`
	`229`	`+ public static bool TokenPerLine(string tokenToReplace, out IReadOnlyList<string>? replacementTokens, out string? errorMessage)`
`231`	`230`	`{`
`232`	`231`	`var filePath = Path.GetFullPath(tokenToReplace);`
`233`	`232`	`if (File.Exists(filePath))`
`@@ -260,7 +259,7 @@ public static bool TokenPerLine(string tokenToReplace, out IReadOnlyList<string>`
`260`	`259`	`ResponseFileTokenReplacer = TokenPerLine`
`261`	`260`	`};`
`262`	`261`
`263`		`- internal static int ExceptionHandler(Exception exception, ParseResult parseResult)`
	`262`	`+ internal static int ExceptionHandler(Exception? exception, ParseResult parseResult)`
`264`	`263`	`{`
`265`	`264`	`if (exception is TargetInvocationException)`
`266`	`265`	`{`
`@@ -280,13 +279,13 @@ internal static int ExceptionHandler(Exception exception, ParseResult parseResul`
`280`	`279`	`exception.Message.Red().Bold());`
`281`	`280`	`parseResult.ShowHelp();`
`282`	`281`	`}`
`283`		`- else if (exception.GetType().Name.Equals("WorkloadManifestCompositionException"))`
	`282`	`+ else if (exception is not null && exception.GetType().Name.Equals("WorkloadManifestCompositionException"))`
`284`	`283`	`{`
`285`	`284`	`Reporter.Error.WriteLine(CommandLoggingContext.IsVerbose ?`
`286`	`285`	`exception.ToString().Red().Bold() :`
`287`	`286`	`exception.Message.Red().Bold());`
`288`	`287`	`}`
`289`		`- else`
	`288`	`+ else if (exception is not null)`
`290`	`289`	`{`
`291`	`290`	`Reporter.Error.Write("Unhandled exception: ".Red().Bold());`
`292`	`291`	`Reporter.Error.WriteLine(CommandLoggingContext.IsVerbose ?`
`@@ -374,7 +373,7 @@ public override void Write(HelpContext context)`
`374`	`373`	`}`
`375`	`374`	`else if (command.Name.Equals(FormatCommandParser.GetCommand().Name))`
`376`	`375`	`{`
`377`		`- var arguments = context.ParseResult.GetValue(FormatCommandParser.Arguments);`
	`376`	`+ var arguments = context.ParseResult.GetValue(FormatCommandParser.Arguments) ?? [];`
`378`	`377`	`new FormatForwardingApp([.. arguments, .. helpArgs]).Execute();`
`379`	`378`	`}`
`380`	`379`	`else if (command.Name.Equals(FsiCommandParser.GetCommand().Name))`
`@@ -401,9 +400,9 @@ public override void Write(HelpContext context)`
`401`	`400`	`{`
`402`	`401`	`if (command.Name.Equals(ListReferenceCommandParser.GetCommand().Name))`
`403`	`402`	`{`
`404`		`- Command listCommand = command.Parents.Single() as Command;`
	`403`	`+ Command? listCommand = command.Parents.Single() as Command;`
`405`	`404`
`406`		`- for (int i = 0; i < listCommand.Arguments.Count; i++)`
	`405`	`+ for (int i = 0; i < listCommand?.Arguments.Count; i++)`
`407`	`406`	`{`
`408`	`407`	`if (listCommand.Arguments[i].Name == CliStrings.SolutionOrProjectArgumentName)`
`409`	`408`	`{`
`@@ -434,6 +433,7 @@ internal PrintCliSchemaAction()`
`434`	`433`	`{`
`435`	`434`	`Terminating = true;`
`436`	`435`	`}`
	`436`	`+`
`437`	`437`	`public override int Invoke(ParseResult parseResult)`
`438`	`438`	`{`
`439`	`439`	`CliSchema.PrintCliSchema(parseResult.CommandResult, parseResult.Configuration.Output, Program.TelemetryClient);`