Unify the managed and NativeAOT CLI parsers into one shared implementation

[baronfel]

Goal

Unify the two dotnet CLI parser entrypoints — the managed CLI (dotnet.dll) and the NativeAOT bridge (dotnet-aot.dll) — into a single shared Parser implementation, and push as much parsing work as possible into the native ("AOT bubble") path.

Previously src/Cli/dotnet/Parser.cs was split by one giant top-level #if CLI_AOT … #else … #endif that produced two almost-entirely-different Parser classes: the AOT side hand-rolled a minimal command tree (only --version/--info/sln), while the managed side built the full tree. That duplicated all the shared plumbing and meant the AOT entrypoint could not parse or serve help for the real command surface.

Now both binaries build the same full DotNetCommandDefinition tree and share the same parsing, help, version/info, cli-schema, and exception-handling code. The only differences are small, inline #if CLI_AOT regions where a code path genuinely cannot run under AOT yet — and in those cases the command transparently falls back to the managed CLI.

How the AOT fast-path works

When DOTNET_CLI_ENABLEAOT=true, NativeEntryPoint parses with the shared parser and:

• Commands that can run entirely in AOT (e.g. --version, --info, --cli-schema, --help for every command, and the AOT-capable sln subcommands) execute natively and return.
• Every other command is wired with a fallback action that throws CommandNotAvailableInAotException; the bridge catches it (and any unexpected parse-time failure) and hosts the managed dotnet.dll to run the command — so behavior is identical, just slower on first use.

Highlights

One shared Parser.cs

• Collapsed the top-level #if into a single Parser class. Shared members (response-file handling, parser/invocation config, Parse/Invoke/InvokeAsync, GetBuiltInCommand, ExceptionHandler, DotnetHelpBuilder) are written once.
• Mode-specific wiring lives in small inline #if CLI_AOT blocks (ConfigureManagedActions vs ConfigureAotActions), matching the patterns already used elsewhere in the repo (SolutionCommandParser, Program.cs).

Full command surface parses + helps from AOT

• The AOT build now constructs the complete DotNetCommandDefinition, so parsing and --help match the managed CLI exactly.
• --help is served entirely from the native path for every command — including the external-tool commands (msbuild/nuget/vstest/format/fsi). Rather than special-casing help, the forwarding apps themselves were made AOT-friendly so the help writer (DotnetHelpBuilder) has zero conditional compilation.

Forwarding apps made AOT-safe (out-of-process)

• MSBuildForwardingApp forces out-of-process forwarding under AOT (added forceOutOfProc to MSBuildForwardingAppWithoutLogging) and skips the in-proc engine; the LLM-environment terminal-logger adjustment from CommonRunHelpers.AdjustMSBuildForLLMs now applies in AOT too (only the in-proc GetConsoleLogger is excluded).
• NuGetCommand always uses the shelling-out NuGetForwardingApp runner under AOT (never the in-proc NuGet.CommandLine.XPlat runner).
• fsi/format/vstest forwarders (already process-spawn) plus their dependencies were added to the AOT compile set.

Shared option actions

• --version and --info use the same PrintVersionAction/PrintInfoAction as the managed CLI; --info only #if !CLI_AOT-omits the workload/MSBuild version lines that aren't AOT-compatible yet.
• --cli-schema runs in AOT via the source-generated JsonSerializerContext. As part of this, CliSchema.HumanizeValue now renders all enum option/argument defaults as their name (previously only VerbosityOptions), which both reads better and is required for source-gen serialization; GetJsonSchema was switched to the AOT-safe JsonTypeInfo overload of GetJsonSchemaAsNode. CliSchema.cs now has no AOT conditional compilation.
• ExceptionHandler is now shared and invoked from the AOT path for non-fallback exceptions, keeping error reporting at parity with the managed CLI.

Cleanup

• Removed CommandLineInfo.cs — it was an AOT-only duplicate of the version/info output that became dead once the real PrintVersionAction/PrintInfoAction were made AOT-able.

Validation

• Managed dotnet.csproj builds clean; behavior is unchanged (logic reorganized, not altered).
• dotnet-aot.csproj AOT-publishes for win-x64 with 0 ILC/trim warnings (the full command tree + all included forwarders + cli-schema serialization are trim/AOT-clean).
• All dotnet-aot.Tests pass, including new coverage for dotnet --help, build --help, external-tool help rendering from AOT, --cli-schema JSON output, and the managed-fallback contract.

Note: the managed CliSchemaTests require the full redist muxer layout, which isn't built in a worktree-only checkout, so they were validated indirectly via the AOT full-tree serialization test. They should be re-run in CI.

[Copilot]

Pull request overview

This PR unifies the managed dotnet.dll and NativeAOT bridge dotnet-aot.dll CLI parsing so both entrypoints build the same full DotNetCommandDefinition command tree, enabling consistent parsing/help output and allowing the AOT path to execute a limited set of commands while falling back to the managed CLI for everything else.

Changes:

• Collapses the previous split managed/AOT parser into one shared Parser with small #if CLI_AOT action-wiring differences.
• Enables AOT to render --help across the full command surface (including external-tool forwarders) and to emit --cli-schema.
• Updates AOT tests and AOT build inputs to cover full-tree parsing/help/schema plus managed-fallback behavior; removes the now-dead CommandLineInfo duplicate.

Reviewed changes

Copilot reviewed 18 out of 18 changed files in this pull request and generated 6 comments.

Show a summary per file

File	Description
test/dotnet-aot.Tests/dotnet-aot.Tests.csproj	Updates import comment for shared AOT sources.
test/dotnet-aot.Tests/AotParserTests.cs	Expands test coverage to full-tree parsing, help rendering, cli-schema, and fallback behavior.
src/Common/EnvironmentVariableNames.cs	Adds XML doc for DOTNET_CLI_TELEMETRY_OPTOUT.
src/Cli/Microsoft.DotNet.Cli.Utils/MSBuildForwardingAppWithoutLogging.cs	Adds forceOutOfProc support and extensive XML docs around MSBuild forwarding behavior.
src/Cli/Microsoft.DotNet.Cli.Definitions/Commands/DotNetCommandDefinition.cs	Moves to a shared root Command definition, adds recursive --help, and adjusts directive handling.
src/Cli/dotnet/ParserOptionActions.cs	Shares option actions across managed/AOT, adds AOT-friendly option-presence checks, and AOT-safe --info/--cli-schema behavior.
src/Cli/dotnet/Parser.cs	Centralizes parser creation and adds AOT fallback wiring, shared help builder, and shared exception handling.
src/Cli/dotnet/NuGetSignatureVerificationEnabler.cs	Excludes MSBuild-specific overload from AOT compilation.
src/Cli/dotnet/Extensions/ParseResultExtensions.cs	Moves parsing helpers needed by AOT out of #if !CLI_AOT and refactors shared helpers.
src/Cli/dotnet/Commands/Run/CommonRunHelpers.cs	Excludes in-proc MSBuild logger creation from AOT while keeping LLM adjustments shared.
src/Cli/dotnet/Commands/NuGet/NuGetCommand.cs	Forces out-of-proc NuGet forwarding under AOT.
src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs	Forces out-of-proc MSBuild forwarding under AOT and adjusts distributed logger wiring for AOT constraints.
src/Cli/dotnet/CommandLineInfo.cs	Removes obsolete AOT-only version/info implementation.
src/Cli/dotnet/CliSchema.cs	Switches to AOT-safe schema export overload and improves enum default rendering.
src/Cli/dotnet-aot/NativeEntryPoint.cs	Uses shared parser + shared exception handling; adds parse-time fallback safety and structured activities.
src/Cli/dotnet-aot/DESIGN.md	Updates design doc to reflect full-tree AOT parsing + fallback model and shared option actions.
src/Cli/dotnet-aot/AotSourceFiles.props	Updates linked shared sources and adds forwarding-app sources needed for AOT help.
src/Cli/dn/dn-native-debug.vcxproj	Removes now-deleted CommandLineInfo.cs from native debug project items.

[baronfel]

I used sizoscope-cli to diff the impact of this PR on the generated NAOT library:

> dnx sizoscope-cli \
    E:\code\dotnet-sdk\artifacts\obj\dotnet-aot\Release\net11.0\win-x64\native\dotnet-aot.mstat \
    E:\code\copilot-worktrees\sdk\baronfel-studious-eureka\artifacts\obj\dotnet-aot\Release\net11.0\win-x64\native\dotnet-aot.mstat \
  --output dotnet-aot-sizoscope-diff.md

dotnet-aot-sizoscope-diff.md

Net result is +781kB, mostly from the Microsoft.DotNet.Cli.Definitions library and embedded resource strings for the many languages we support.

[baronfel]

/ba-g test failures aren't related to this change, known flaky tests