WIP: rip and tear

Author: baronfel

src/Cli/dotnet/Commands/Hidden/InternalReportInstallSuccess/InternalReportInstallSuccessCommand.cs

@@ -49,7 +49,7 @@ internal ThreadBlockingTelemetry()
         {
             var sessionId =
             Environment.GetEnvironmentVariable(TelemetrySessionIdEnvironmentVariableName);
-            telemetry = new Telemetry.Telemetry(new NoOpFirstTimeUseNoticeSentinel(), sessionId, blockThreadInitialization: true);
+            telemetry = new Telemetry.Telemetry(sessionId, blockThreadInitialization: true);
         }
         public bool Enabled => telemetry.Enabled;
 

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

@@ -13,8 +13,6 @@ namespace Microsoft.DotNet.Cli.Commands.MSBuild;
 
 public sealed class MSBuildLogger : INodeLogger
 {
-    private readonly IFirstTimeUseNoticeSentinel _sentinel =
-        new FirstTimeUseNoticeSentinel();
     private readonly ITelemetry _telemetry;
 
     internal const string TargetFrameworkTelemetryEventName = "targetframeworkeval";
@@ -64,7 +62,6 @@ public MSBuildLogger()
                 // time they will read from the same global queue and cause
                 // sending duplicated events. Disable sender to reduce it.
                 _telemetry = new Telemetry.Telemetry(
-                    _sentinel,
                     sessionId,
                     senderCount: 0);
             }
@@ -215,14 +212,6 @@ private void OnTelemetryLogged(object sender, TelemetryEventArgs args)
 
     public void Shutdown()
     {
-        try
-        {
-            _sentinel?.Dispose();
-        }
-        catch (Exception)
-        {
-            // Exceptions during telemetry shouldn't cause anything else to fail
-        }
     }
 
     public LoggerVerbosity Verbosity { get; set; }

src/Cli/dotnet/CommonOptionsFactory.cs

@@ -4,6 +4,9 @@
 #nullable disable
 
 using System.CommandLine;
+using System.CommandLine.Parsing;
+using Microsoft.DotNet.Cli.Extensions;
+using Microsoft.DotNet.Cli.Utils;
 
 namespace Microsoft.DotNet.Cli;
 
@@ -21,4 +24,25 @@ internal static class CommonOptionsFactory
         Recursive = recursive,
         Arity = ArgumentArity.Zero
     };
+
+    internal class SetDiagnosticModeAction(Option<bool> diagnosticOption) : System.CommandLine.Invocation.SynchronousCommandLineAction
+    {
+        public override int Invoke(ParseResult parseResult)
+        {
+            if (parseResult.IsDotnetBuiltInCommand())
+            {
+                var diagIsChildOfRoot = parseResult.RootCommandResult.Children.FirstOrDefault((s) => s is OptionResult opt && opt.Option == diagnosticOption) is not null;
+
+                // We found --diagnostic or -d, but we still need to determine whether the option should
+                // be attached to the dotnet command or the subcommand.
+                if (diagIsChildOfRoot)
+                {
+                    Environment.SetEnvironmentVariable(CommandLoggingContext.Variables.Verbose, bool.TrueString);
+                    CommandLoggingContext.SetVerbose(true);
+                    Reporter.Reset();
+                }
+            }
+            return 0;
+        }
+    }
 }

src/Cli/dotnet/Extensions/ParseResultExtensions.cs

@@ -86,9 +86,12 @@ static bool ErrorContainsAllParts(ReadOnlySpan<char> error, string[] parts)
 
     public static string RootSubCommandResult(this ParseResult parseResult)
     {
-        return parseResult.RootCommandResult.Children?
-            .Select(child => GetSymbolResultValue(parseResult, child))
-            .FirstOrDefault(subcommand => !string.IsNullOrEmpty(subcommand)) ?? string.Empty;
+        CommandResult commandResult = parseResult.CommandResult;
+        while (commandResult != parseResult.RootCommandResult && commandResult.Parent is CommandResult parentCommand)
+        {
+            commandResult = parentCommand;
+        }
+        return commandResult.Command.Name;
     }
 
     public static bool IsDotnetBuiltInCommand(this ParseResult parseResult)
@@ -102,12 +105,7 @@ public static bool IsTopLevelDotnetCommand(this ParseResult parseResult)
         return parseResult.CommandResult.Command.Equals(Parser.RootCommand) && string.IsNullOrEmpty(parseResult.RootSubCommandResult());
     }
 
-    public static bool CanBeInvoked(this ParseResult parseResult)
-    {
-        return GetBuiltInCommand(parseResult.RootSubCommandResult()) != null ||
-            parseResult.Tokens.Any(token => token.Type == TokenType.Directive) ||
-            (parseResult.IsTopLevelDotnetCommand() && string.IsNullOrEmpty(parseResult.GetValue(DotnetSubCommand)));
-    }
+    public static bool CanBeInvoked(this ParseResult parseResult) => parseResult.Action is not null;
 
     public static int HandleMissingCommand(this ParseResult parseResult)
     {

src/Cli/dotnet/Parser.cs

@@ -99,14 +99,43 @@ public static class Parser
 
     public static readonly Option<bool> VersionOption = new("--version")
     {
-        Arity = ArgumentArity.Zero
+        Arity = ArgumentArity.Zero,
+        Action = new PrintVersionAction()
     };
 
+    internal class PrintVersionAction : System.CommandLine.Invocation.SynchronousCommandLineAction
+    {
+        public PrintVersionAction()
+        {
+            Terminating = true;
+        }
+        public override int Invoke(ParseResult parseResult)
+        {
+            CommandLineInfo.PrintVersion();
+            return 0;
+        }
+    }
+
     public static readonly Option<bool> InfoOption = new("--info")
     {
-        Arity = ArgumentArity.Zero
+        Arity = ArgumentArity.Zero,
+        Action = new PrintInfoAction()
     };
 
+    internal class PrintInfoAction : System.CommandLine.Invocation.SynchronousCommandLineAction
+    {
+        public PrintInfoAction()
+        {
+            Terminating = true;
+        }
+
+        public override int Invoke(ParseResult parseResult)
+        {
+            CommandLineInfo.PrintInfo();
+            return 0;
+        }
+    }
+
     public static readonly Option<bool> ListSdksOption = new("--list-sdks")
     {
         Arity = ArgumentArity.Zero