diff --git a/src/System.CommandLine/Command.cs b/src/System.CommandLine/Command.cs
index c24d041660..2c0a1adbfc 100644
--- a/src/System.CommandLine/Command.cs
+++ b/src/System.CommandLine/Command.cs
@@ -57,18 +57,22 @@ public IEnumerable<Symbol> Children
         /// </summary>
         public IList<Argument> Arguments => _arguments ??= new(this);
 
-        internal bool HasArguments => _arguments is not null;
+        internal bool HasArguments => _arguments is not null && _arguments.Count > 0 ;
 
         /// <summary>
         /// Represents all of the options for the command, including global options that have been applied to any of the command's ancestors.
         /// </summary>
         public IList<Option> Options => _options ??= new (this);
 
+        internal bool HasOptions => _options is not null && _options.Count > 0;
+
         /// <summary>
         /// Represents all of the subcommands for the command.
         /// </summary>
         public IList<Command> Subcommands => _subcommands ??= new(this);
 
+        internal bool HasSubcommands => _subcommands is not null && _subcommands.Count > 0;
+
         /// <summary>
         /// Validators to the command. Validators can be used
         /// to create custom validation logic.
@@ -151,34 +155,44 @@ public override IEnumerable<CompletionItem> GetCompletions(CompletionContext con
 
             if (context.WordToComplete is { } textToMatch)
             {
-                var commands = Subcommands;
-                for (int i = 0; i < commands.Count; i++)
+                if (HasSubcommands)
                 {
-                    AddCompletionsFor(commands[i]);
+                    var commands = Subcommands;
+                    for (int i = 0; i < commands.Count; i++)
+                    {
+                        AddCompletionsFor(commands[i]);
+                    }
                 }
 
-                var options = Options;
-                for (int i = 0; i < options.Count; i++)
+                if (HasOptions)
                 {
-                    AddCompletionsFor(options[i]);
+                    var options = Options;
+                    for (int i = 0; i < options.Count; i++)
+                    {
+                        AddCompletionsFor(options[i]);
+                    }
                 }
 
-                var arguments = Arguments;
-                for (int i = 0; i < arguments.Count; i++)
+                if (HasArguments)
                 {
-                    var argument = arguments[i];
-                    foreach (var completion in argument.GetCompletions(context))
+                    var arguments = Arguments;
+                    for (int i = 0; i < arguments.Count; i++)
                     {
-                        if (completion.Label.ContainsCaseInsensitive(textToMatch))
+                        var argument = arguments[i];
+                        foreach (var completion in argument.GetCompletions(context))
                         {
-                            completions.Add(completion);
+                            if (completion.Label.ContainsCaseInsensitive(textToMatch))
+                            {
+                                completions.Add(completion);
+                            }
                         }
                     }
                 }
 
-                foreach (var parent in Parents.FlattenBreadthFirst(p => p.Parents))
+                ParentNode? parent = FirstParent;
+                while (parent is not null)
                 {
-                    if (parent is Command parentCommand)
+                    if (parent.Symbol is Command parentCommand && parentCommand.HasOptions)
                     {
                         for (var i = 0; i < parentCommand.Options.Count; i++)
                         {
@@ -190,6 +204,8 @@ public override IEnumerable<CompletionItem> GetCompletions(CompletionContext con
                             }
                         }
                     }
+
+                    parent = parent.Next;
                 }
             }
 
diff --git a/src/System.CommandLine/Help/HelpBuilder.Default.cs b/src/System.CommandLine/Help/HelpBuilder.Default.cs
index caf184506b..1681fb2583 100644
--- a/src/System.CommandLine/Help/HelpBuilder.Default.cs
+++ b/src/System.CommandLine/Help/HelpBuilder.Default.cs
@@ -201,11 +201,14 @@ public static Action<HelpContext> OptionsSection() =>
                 // by making this logic more complex, we were able to get some nice perf wins elsewhere
                 List<TwoColumnHelpRow> options = new();
                 HashSet<Option> uniqueOptions = new();
-                foreach (Option option in ctx.Command.Options)
+                if (ctx.Command.HasOptions)
                 {
-                    if (!option.IsHidden && uniqueOptions.Add(option))
+                    foreach (Option option in ctx.Command.Options)
                     {
-                        options.Add(ctx.HelpBuilder.GetTwoColumnRow(option, ctx));
+                        if (!option.IsHidden && uniqueOptions.Add(option))
+                        {
+                            options.Add(ctx.HelpBuilder.GetTwoColumnRow(option, ctx));
+                        }
                     }
                 }
 
@@ -218,12 +221,15 @@ public static Action<HelpContext> OptionsSection() =>
                     {
                         if ((parentCommand = parent.Symbol as Command) is not null)
                         {
-                            foreach (var option in parentCommand.Options)
+                            if (parentCommand.HasOptions)
                             {
-                                // global help aliases may be duplicated, we just ignore them
-                                if (option.IsGlobal && !option.IsHidden && uniqueOptions.Add(option))
+                                foreach (var option in parentCommand.Options)
                                 {
-                                    options.Add(ctx.HelpBuilder.GetTwoColumnRow(option, ctx));
+                                    // global help aliases may be duplicated, we just ignore them
+                                    if (option.IsGlobal && !option.IsHidden && uniqueOptions.Add(option))
+                                    {
+                                        options.Add(ctx.HelpBuilder.GetTwoColumnRow(option, ctx));
+                                    }
                                 }
                             }
 
diff --git a/src/System.CommandLine/Help/HelpBuilder.cs b/src/System.CommandLine/Help/HelpBuilder.cs
index 55765e71f2..0519020d4a 100644
--- a/src/System.CommandLine/Help/HelpBuilder.cs
+++ b/src/System.CommandLine/Help/HelpBuilder.cs
@@ -125,22 +125,25 @@ IEnumerable<string> GetUsageParts()
                 {
                     if (!displayOptionTitle)
                     {
-                        displayOptionTitle = parentCommand.Options.Any(x => x.IsGlobal && !x.IsHidden);
+                        displayOptionTitle = parentCommand.HasOptions && parentCommand.Options.Any(x => x.IsGlobal && !x.IsHidden);
                     }
 
                     yield return parentCommand.Name;
 
-                    yield return FormatArgumentUsage(parentCommand.Arguments);
+                    if (parentCommand.HasArguments)
+                    {
+                        yield return FormatArgumentUsage(parentCommand.Arguments);
+                    }
                 }
 
-                var hasCommandWithHelp = command.Subcommands.Any(x => !x.IsHidden);
+                var hasCommandWithHelp = command.HasSubcommands && command.Subcommands.Any(x => !x.IsHidden);
 
                 if (hasCommandWithHelp)
                 {
                     yield return LocalizationResources.HelpUsageCommand();
                 }
 
-                displayOptionTitle = displayOptionTitle || command.Options.Any(x => !x.IsHidden);
+                displayOptionTitle = displayOptionTitle || (command.HasOptions && command.Options.Any(x => !x.IsHidden));
                 
                 if (displayOptionTitle)
                 {
diff --git a/src/System.CommandLine/Invocation/TypoCorrection.cs b/src/System.CommandLine/Invocation/TypoCorrection.cs
index 5ded31a9eb..3dead941da 100644
--- a/src/System.CommandLine/Invocation/TypoCorrection.cs
+++ b/src/System.CommandLine/Invocation/TypoCorrection.cs
@@ -23,23 +23,32 @@ public TypoCorrection(int maxLevenshteinDistance)
 
         public void ProvideSuggestions(ParseResult result, IConsole console)
         {
-            for (var i = 0; i < result.UnmatchedTokens.Count; i++)
+            var unmatchedTokens = result.UnmatchedTokens;
+            for (var i = 0; i < unmatchedTokens.Count; i++)
             {
-                var token = result.UnmatchedTokens[i];
-                var suggestions = GetPossibleTokens(result.CommandResult.Command, token).ToList();
-                if (suggestions.Count > 0)
+                var token = unmatchedTokens[i];
+
+                bool first = true;
+                foreach (string suggestion in GetPossibleTokens(result.CommandResult.Command, token))
                 {
-                    console.Out.WriteLine(result.CommandResult.LocalizationResources.SuggestionsTokenNotMatched(token));
-                    foreach(string suggestion in suggestions)
+                    if (first)
                     {
-                        console.Out.WriteLine(suggestion);
+                        console.Out.WriteLine(result.CommandResult.LocalizationResources.SuggestionsTokenNotMatched(token));
+                        first = false;
                     }
+
+                    console.Out.WriteLine(suggestion);
                 }
             }
         }
 
         private IEnumerable<string> GetPossibleTokens(Command targetSymbol, string token)
         {
+            if (!targetSymbol.HasOptions && !targetSymbol.HasSubcommands)
+            {
+                return Array.Empty<string>();
+            }
+
             IEnumerable<string> possibleMatches = targetSymbol
                 .Children
                 .OfType<IdentifierSymbol>()
@@ -47,7 +56,6 @@ private IEnumerable<string> GetPossibleTokens(Command targetSymbol, string token
                 .Where(x => x.Aliases.Count > 0)
                 .Select(symbol => 
                     symbol.Aliases
-                        .Union(symbol.Aliases)
                         .OrderBy(x => GetDistance(token, x))
                         .ThenByDescending(x => GetStartsWithDistance(token, x))
                         .First()
diff --git a/src/System.CommandLine/ParseResult.cs b/src/System.CommandLine/ParseResult.cs
index 8c0b61b167..b4573b78b0 100644
--- a/src/System.CommandLine/ParseResult.cs
+++ b/src/System.CommandLine/ParseResult.cs
@@ -14,17 +14,18 @@ namespace System.CommandLine
     /// </summary>
     public class ParseResult
     {
-        private readonly List<ParseError> _errors;
+        private readonly IReadOnlyList<ParseError> _errors;
         private readonly RootCommandResult _rootCommandResult;
         private readonly IReadOnlyList<Token> _unmatchedTokens;
+        private Dictionary<string, IReadOnlyList<string>>? _directives;
         private CompletionContext? _completionContext;
 
         internal ParseResult(
             Parser parser,
             RootCommandResult rootCommandResult,
             CommandResult commandResult,
-            IReadOnlyDictionary<string, IReadOnlyList<string>> directives,
-            TokenizeResult tokenizeResult,
+            Dictionary<string, IReadOnlyList<string>>? directives,
+            List<Token> tokens,
             IReadOnlyList<Token>? unmatchedTokens,
             List<ParseError>? errors,
             string? commandLineText = null)
@@ -32,18 +33,15 @@ internal ParseResult(
             Parser = parser;
             _rootCommandResult = rootCommandResult;
             CommandResult = commandResult;
-            Directives = directives;
+            _directives = directives;
 
             // skip the root command when populating Tokens property
-            if (tokenizeResult.Tokens.Count > 1)
+            if (tokens.Count > 1)
             {
-                var tokens = new Token[tokenizeResult.Tokens.Count - 1];
-                for (var i = 0; i < tokenizeResult.Tokens.Count - 1; i++)
-                {
-                    var token = tokenizeResult.Tokens[i + 1];
-                    tokens[i] = token;
-                }
-
+                // Since TokenizeResult.Tokens is not public and not used anywhere after the parsing,
+                // we take advantage of its mutability and remove the root command token
+                // instead of creating a copy of the whole list.
+                tokens.RemoveAt(0);
                 Tokens = tokens;
             }
             else
@@ -51,7 +49,6 @@ internal ParseResult(
                 Tokens = Array.Empty<Token>();
             }
 
-            _errors = errors ?? new List<ParseError>();
             CommandLineText = commandLineText;
 
             if (unmatchedTokens is null)
@@ -67,10 +64,12 @@ internal ParseResult(
                     for (var i = 0; i < _unmatchedTokens.Count; i++)
                     {
                         var token = _unmatchedTokens[i];
-                        _errors.Add(new ParseError(parser.Configuration.LocalizationResources.UnrecognizedCommandOrArgument(token.Value), rootCommandResult));
+                        (errors ??= new()).Add(new ParseError(parser.Configuration.LocalizationResources.UnrecognizedCommandOrArgument(token.Value), rootCommandResult));
                     }
                 }
             }
+
+            _errors = errors is not null ? errors : Array.Empty<ParseError>();
         }
 
         internal static ParseResult Empty() => new RootCommand().Parse(Array.Empty<string>());
@@ -99,7 +98,7 @@ internal ParseResult(
         /// Gets the directives found while parsing command line input.
         /// </summary>
         /// <remarks>If <see cref="CommandLineConfiguration.EnableDirectives"/> is set to <see langword="false"/>, then this collection will be empty.</remarks>
-        public IReadOnlyDictionary<string, IReadOnlyList<string>> Directives { get; }
+        public IReadOnlyDictionary<string, IReadOnlyList<string>> Directives => _directives ??= new ();
 
         /// <summary>
         /// Gets the tokens identified while parsing command line input.
@@ -115,7 +114,8 @@ internal ParseResult(
         /// <summary>
         /// Gets the list of tokens used on the command line that were not matched by the parser.
         /// </summary>
-        public IReadOnlyList<string> UnmatchedTokens => _unmatchedTokens.Select(t => t.Value).ToArray();
+        public IReadOnlyList<string> UnmatchedTokens
+            => _unmatchedTokens.Count == 0 ? Array.Empty<string>() : _unmatchedTokens.Select(t => t.Value).ToArray();
 
         /// <summary>
         /// Gets the completion context for the parse result.
diff --git a/src/System.CommandLine/Parsing/ArgumentResult.cs b/src/System.CommandLine/Parsing/ArgumentResult.cs
index de1c16baf1..50b975acc1 100644
--- a/src/System.CommandLine/Parsing/ArgumentResult.cs
+++ b/src/System.CommandLine/Parsing/ArgumentResult.cs
@@ -64,11 +64,14 @@ public void OnlyTake(int numberOfTokens)
                 throw new InvalidOperationException($"{nameof(OnlyTake)} can only be called once.");
             }
 
-            var passedOnTokensCount = _tokens.Count - numberOfTokens;
+            if (_tokens is not null)
+            {
+                var passedOnTokensCount = _tokens.Count - numberOfTokens;
+
+                PassedOnTokens = new List<Token>(_tokens.GetRange(numberOfTokens, passedOnTokensCount));
 
-            PassedOnTokens = new List<Token>(_tokens.GetRange(numberOfTokens, passedOnTokensCount));
-            
-            _tokens.RemoveRange(numberOfTokens, passedOnTokensCount);
+                _tokens.RemoveRange(numberOfTokens, passedOnTokensCount);
+            }
         }
 
         /// <inheritdoc/>
diff --git a/src/System.CommandLine/Parsing/CommandArgumentNode.cs b/src/System.CommandLine/Parsing/CommandArgumentNode.cs
index 7072ccdfdc..d9d776a1fe 100644
--- a/src/System.CommandLine/Parsing/CommandArgumentNode.cs
+++ b/src/System.CommandLine/Parsing/CommandArgumentNode.cs
@@ -1,6 +1,8 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Diagnostics;
+
 namespace System.CommandLine.Parsing
 {
     internal class CommandArgumentNode : SyntaxNode
@@ -10,10 +12,7 @@ public CommandArgumentNode(
             Argument argument,
             CommandNode parent) : base(token, parent)
         {
-            if (token.Type != TokenType.Argument)
-            {
-                throw new ArgumentException($"Incorrect token type: {token}");
-            }
+            Debug.Assert(token.Type == TokenType.Argument, $"Incorrect token type: {token}");
 
             Argument = argument;
             ParentCommandNode = parent;
diff --git a/src/System.CommandLine/Parsing/CommandResult.cs b/src/System.CommandLine/Parsing/CommandResult.cs
index b6a9140685..0c341b9fb9 100644
--- a/src/System.CommandLine/Parsing/CommandResult.cs
+++ b/src/System.CommandLine/Parsing/CommandResult.cs
@@ -1,6 +1,8 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Collections.Generic;
+
 namespace System.CommandLine.Parsing
 {
     /// <summary>
@@ -8,6 +10,8 @@ namespace System.CommandLine.Parsing
     /// </summary>
     public class CommandResult : SymbolResult
     {
+        private Dictionary<Argument, ArgumentResult>? _defaultArgumentValues;
+
         internal CommandResult(
             Command command,
             Token token,
@@ -36,5 +40,10 @@ internal override bool UseDefaultValueFor(Argument argument) =>
                                       arg.Tokens.Count == 0,
                 _ => false
             };
+
+        internal ArgumentResult GetOrCreateDefaultArgumentResult(Argument argument) =>
+            (_defaultArgumentValues ??= new()).GetOrAdd(
+                argument,
+                arg => new ArgumentResult(arg, this));
     }
 }
diff --git a/src/System.CommandLine/Parsing/DirectiveNode.cs b/src/System.CommandLine/Parsing/DirectiveNode.cs
index 4b50b0e176..e4bebe1897 100644
--- a/src/System.CommandLine/Parsing/DirectiveNode.cs
+++ b/src/System.CommandLine/Parsing/DirectiveNode.cs
@@ -1,6 +1,8 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Diagnostics;
+
 namespace System.CommandLine.Parsing
 {
     internal class DirectiveNode : SyntaxNode
@@ -11,10 +13,7 @@ public DirectiveNode(
             string name,
             string? value) : base(token, parent)
         {
-            if (token.Type != TokenType.Directive)
-            {
-                throw new ArgumentException($"Incorrect token type: {token}");
-            }
+            Debug.Assert(token.Type == TokenType.Directive, $"Incorrect token type: {token}");
 
             Name = name;
             Value = value;
diff --git a/src/System.CommandLine/Parsing/NonterminalSyntaxNode.cs b/src/System.CommandLine/Parsing/NonterminalSyntaxNode.cs
index 6726d9625e..175f892232 100644
--- a/src/System.CommandLine/Parsing/NonterminalSyntaxNode.cs
+++ b/src/System.CommandLine/Parsing/NonterminalSyntaxNode.cs
@@ -7,14 +7,14 @@ namespace System.CommandLine.Parsing
 {
     internal abstract class NonterminalSyntaxNode : SyntaxNode
     {
-        private readonly List<SyntaxNode> _children = new();
+        private List<SyntaxNode>? _children;
 
         protected NonterminalSyntaxNode(Token token, SyntaxNode? parent) : base(token, parent)
         {
         }
 
-        public IReadOnlyList<SyntaxNode> Children => _children;
+        public IReadOnlyList<SyntaxNode> Children => _children is not null ? _children : Array.Empty<SyntaxNode>();
 
-        internal void AddChildNode(SyntaxNode node) => _children.Add(node);
+        internal void AddChildNode(SyntaxNode node) => (_children ??= new()).Add(node);
     }
 }
diff --git a/src/System.CommandLine/Parsing/OptionArgumentNode.cs b/src/System.CommandLine/Parsing/OptionArgumentNode.cs
index 7980c9f190..36cd51006d 100644
--- a/src/System.CommandLine/Parsing/OptionArgumentNode.cs
+++ b/src/System.CommandLine/Parsing/OptionArgumentNode.cs
@@ -1,6 +1,8 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Diagnostics;
+
 namespace System.CommandLine.Parsing
 {
     internal class OptionArgumentNode : SyntaxNode
@@ -10,10 +12,7 @@ public OptionArgumentNode(
             Argument argument,
             OptionNode parent) : base(token, parent)
         {
-            if (token.Type != TokenType.Argument)
-            {
-                throw new ArgumentException($"Incorrect token type: {token}");
-            }
+            Debug.Assert(token.Type == TokenType.Argument, $"Incorrect token type: {token}");
 
             Argument = argument;
             ParentOptionNode = parent;
diff --git a/src/System.CommandLine/Parsing/OptionResult.cs b/src/System.CommandLine/Parsing/OptionResult.cs
index e1c2b957d0..934f77dcfb 100644
--- a/src/System.CommandLine/Parsing/OptionResult.cs
+++ b/src/System.CommandLine/Parsing/OptionResult.cs
@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Collections.Generic;
 using System.CommandLine.Binding;
 using System.Diagnostics.CodeAnalysis;
 
@@ -12,6 +13,7 @@ namespace System.CommandLine.Parsing
     public class OptionResult : SymbolResult
     {
         private ArgumentConversionResult? _argumentConversionResult;
+        private Dictionary<Argument, ArgumentResult>? _defaultArgumentValues;
 
         internal OptionResult(
             Option option,
@@ -94,5 +96,10 @@ internal ArgumentConversionResult ArgumentConversionResult
         }
         
         internal override bool UseDefaultValueFor(Argument argument) => IsImplicit;
+
+        internal ArgumentResult GetOrCreateDefaultArgumentResult(Argument argument) =>
+            (_defaultArgumentValues ??= new()).GetOrAdd(
+                argument,
+                arg => new ArgumentResult(arg, this));
     }
 }
diff --git a/src/System.CommandLine/Parsing/ParseOperation.cs b/src/System.CommandLine/Parsing/ParseOperation.cs
index 1b6849c40e..aa36d10f9c 100644
--- a/src/System.CommandLine/Parsing/ParseOperation.cs
+++ b/src/System.CommandLine/Parsing/ParseOperation.cs
@@ -7,21 +7,19 @@ namespace System.CommandLine.Parsing
 {
     internal class ParseOperation
     {
-        private readonly TokenizeResult _tokenizeResult;
+        private readonly List<Token> _tokens;
         private readonly CommandLineConfiguration _configuration;
         private int _index;
 
         public ParseOperation(
-            TokenizeResult tokenizeResult,
+            List<Token> tokens,
             CommandLineConfiguration configuration)
         {
-            _tokenizeResult = tokenizeResult;
+            _tokens = tokens;
             _configuration = configuration;
         }
 
-        private Token CurrentToken => _tokenizeResult.Tokens[_index];
-
-        public List<ParseError> Errors { get; } = new();
+        private Token CurrentToken => _tokens[_index];
 
         public CommandNode? RootCommandNode { get; private set; }
 
@@ -31,8 +29,8 @@ public ParseOperation(
 
         private bool More(out TokenType currentTokenType)
         {
-            bool result = _index < _tokenizeResult.Tokens.Count;
-            currentTokenType = result ? _tokenizeResult.Tokens[_index].Type : (TokenType)(-1);
+            bool result = _index < _tokens.Count;
+            currentTokenType = result ? _tokens[_index].Type : (TokenType)(-1);
             return result;
         }
 
@@ -99,7 +97,7 @@ private void ParseCommandArguments(CommandNode commandNode, ref int currentArgum
         {
             while (More(out TokenType currentTokenType) && currentTokenType == TokenType.Argument)
             {
-                while (currentArgumentIndex < commandNode.Command.Arguments.Count)
+                while (commandNode.Command.HasArguments && currentArgumentIndex < commandNode.Command.Arguments.Count)
                 {
                     Argument argument = commandNode.Command.Arguments[currentArgumentIndex];
 
@@ -202,16 +200,14 @@ private void ParseDirectives(CommandNode rootCommandNode)
             void ParseDirective(CommandNode parent)
             {
                 var token = CurrentToken;
-                var withoutBrackets = token.Value.Substring(1, token.Value.Length - 2);
-                var keyAndValue = withoutBrackets.Split(new[]
-                {
-                    ':'
-                }, 2);
-
-                var key = keyAndValue[0];
-                var value = keyAndValue.Length == 2
-                                ? keyAndValue[1]
-                                : null;
+                ReadOnlySpan<char> withoutBrackets = token.Value.AsSpan(1, token.Value.Length - 2);
+                int indexOfColon = withoutBrackets.IndexOf(':');
+                string key = indexOfColon >= 0 
+                    ? withoutBrackets.Slice(0, indexOfColon).ToString()
+                    : withoutBrackets.ToString();
+                string? value = indexOfColon > 0
+                    ? withoutBrackets.Slice(indexOfColon + 1).ToString()
+                    : null;
 
                 var directiveNode = new DirectiveNode(token, parent, key, value);
 
diff --git a/src/System.CommandLine/Parsing/ParseResultExtensions.cs b/src/System.CommandLine/Parsing/ParseResultExtensions.cs
index 7cd3ebb8d6..f58592d802 100644
--- a/src/System.CommandLine/Parsing/ParseResultExtensions.cs
+++ b/src/System.CommandLine/Parsing/ParseResultExtensions.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.Collections;
+using System.Collections.Generic;
 using System.CommandLine.Binding;
 using System.CommandLine.Invocation;
 using System.Linq;
@@ -53,13 +54,14 @@ public static string Diagram(this ParseResult parseResult)
             {
                 builder.Diagram(parseResult.RootCommandResult, parseResult);
 
-                if (parseResult.UnmatchedTokens.Count > 0)
+                var unmatchedTokens = parseResult.UnmatchedTokens;
+                if (unmatchedTokens.Count > 0)
                 {
                     builder.Append("   ???-->");
 
-                    for (var i = 0; i < parseResult.UnmatchedTokens.Count; i++)
+                    for (var i = 0; i < unmatchedTokens.Count; i++)
                     {
-                        var error = parseResult.UnmatchedTokens[i];
+                        var error = unmatchedTokens[i];
                         builder.Append(" ");
                         builder.Append(error);
                     }
@@ -90,7 +92,7 @@ private static void Diagram(
                 {
                     var includeArgumentName =
                         argumentResult.Argument.FirstParent!.Symbol is Command command &&
-                        command.Arguments.Count > 1;
+                        command.HasArguments && command.Arguments.Count > 1;
 
                     if (includeArgumentName)
                     {
diff --git a/src/System.CommandLine/Parsing/ParseResultVisitor.cs b/src/System.CommandLine/Parsing/ParseResultVisitor.cs
index 3e3c0fa47e..cdc04ac739 100644
--- a/src/System.CommandLine/Parsing/ParseResultVisitor.cs
+++ b/src/System.CommandLine/Parsing/ParseResultVisitor.cs
@@ -12,38 +12,43 @@ namespace System.CommandLine.Parsing
     internal sealed class ParseResultVisitor
     {
         private readonly Parser _parser;
-        private readonly TokenizeResult _tokenizeResult;
+        private readonly List<Token> _tokens;
         private readonly string? _rawInput;
 
-        private readonly Dictionary<string, IReadOnlyList<string>> _directives = new();
+        private Dictionary<string, IReadOnlyList<string>>? _directives;
         private List<Token>? _unmatchedTokens;
-        private readonly List<ParseError> _errors;
+        private List<ParseError>? _errors;
 
         private readonly Dictionary<Symbol, SymbolResult> _symbolResults = new();
 
-        private readonly List<OptionResult> _optionResults = new();
-        private readonly List<ArgumentResult> _argumentResults = new();
+        private List<OptionResult>? _optionResults;
+        private List<ArgumentResult>? _argumentResults;
 
         private RootCommandResult? _rootCommandResult;
         private CommandResult? _innermostCommandResult;
         private bool _isHelpRequested;
 
-        public ParseResultVisitor(
+        internal ParseResultVisitor(
             Parser parser,
-            TokenizeResult tokenizeResult,
+            List<Token> tokens,
+            List<string>? tokenizeErrors,
             List<Token>? unmatchedTokens,
             string? rawInput)
         {
             _parser = parser;
-            _tokenizeResult = tokenizeResult;
+            _tokens = tokens;
             _unmatchedTokens = unmatchedTokens;
             _rawInput = rawInput;
-            _errors = new List<ParseError>(_tokenizeResult.Errors.Count);
 
-            for (var i = 0; i < _tokenizeResult.Errors.Count; i++)
+            if (tokenizeErrors is not null)
             {
-                var error = _tokenizeResult.Errors[i];
-                _errors.Add(new ParseError(error));
+                _errors = new List<ParseError>(tokenizeErrors.Count);
+
+                for (var i = 0; i < tokenizeErrors.Count; i++)
+                {
+                    var error = tokenizeErrors[i];
+                    _errors.Add(new ParseError(error));
+                }
             }
         }
 
@@ -113,7 +118,7 @@ private void AddToResult(OptionResult result)
             _innermostCommandResult?.AddChild(result);
             if (_symbolResults.TryAdd(result.Option, result))
             {
-                _optionResults.Add(result);
+                (_optionResults ??= new()).Add(result);
             }
         }
 
@@ -122,7 +127,7 @@ private void AddToResult(ArgumentResult result)
             _innermostCommandResult?.AddChild(result);
             if (_symbolResults.TryAdd(result.Argument, result))
             {
-                _argumentResults.Add(result);
+                (_argumentResults ??= new()).Add(result);
             }
         }
 
@@ -223,11 +228,11 @@ private void VisitOptionArgumentNode(
 
         private void VisitDirectiveNode(DirectiveNode directiveNode)
         {
-            if (!_directives.TryGetValue(directiveNode.Name, out var values))
+            if (_directives is null || !_directives.TryGetValue(directiveNode.Name, out var values))
             {
                 values = new List<string>();
 
-                _directives.Add(directiveNode.Name, values);
+                (_directives ??= new()).Add(directiveNode.Name, values);
             }
 
             if (directiveNode.Value is not null)
@@ -249,30 +254,35 @@ private void Stop()
 
             ValidateCommandResult();
 
-            foreach (var optionResult in _optionResults)
+            if (_optionResults is not null)
             {
-                ValidateAndConvertOptionResult(optionResult);
+                foreach (var optionResult in _optionResults)
+                {
+                    ValidateAndConvertOptionResult(optionResult);
+                }
             }
 
-            if (_argumentResults.Count > 0)
+            if (_argumentResults is not null)
             {
-                ValidateAndConvertArgumentResults(_innermostCommandResult!.Command.Arguments, _argumentResults.Count);
+                ValidateAndConvertArgumentResults(_innermostCommandResult!.Command.Arguments, _argumentResults);
             }
         }
 
-        private void ValidateAndConvertArgumentResults(IList<Argument> arguments, int commandArgumentResultCount)
+        private void ValidateAndConvertArgumentResults(IList<Argument> arguments, List<ArgumentResult> argumentResults)
         {
+            int commandArgumentResultCount = argumentResults.Count;
+
             for (var i = 0; i < arguments.Count; i++)
             {
-                if (i > 0 && _argumentResults.Count > i)
+                if (i > 0 && argumentResults.Count > i)
                 {
-                    var previousArgumentResult = _argumentResults[i - 1];
+                    var previousArgumentResult = argumentResults[i - 1];
 
                     var passedOnTokensCount = previousArgumentResult.PassedOnTokens?.Count;
 
                     if (passedOnTokensCount > 0)
                     {
-                        ShiftPassedOnTokensToNextResult(previousArgumentResult, _argumentResults[i], passedOnTokensCount);
+                        ShiftPassedOnTokensToNextResult(previousArgumentResult, argumentResults[i], passedOnTokensCount);
                     }
                 }
 
@@ -284,13 +294,13 @@ private void ValidateAndConvertArgumentResults(IList<Argument> arguments, int co
                         nextArgument,
                         _innermostCommandResult);
 
-                    var previousArgumentResult = _argumentResults[i - 1];
+                    var previousArgumentResult = argumentResults[i - 1];
 
                     var passedOnTokensCount = _innermostCommandResult?.Tokens.Count;
 
                     ShiftPassedOnTokensToNextResult(previousArgumentResult, nextArgumentResult, passedOnTokensCount);
 
-                    _argumentResults.Add(nextArgumentResult);
+                    argumentResults.Add(nextArgumentResult);
 
                     if (previousArgumentResult.Parent is CommandResult)
                     {
@@ -300,9 +310,9 @@ private void ValidateAndConvertArgumentResults(IList<Argument> arguments, int co
                     _symbolResults.TryAdd(nextArgumentResult.Symbol, nextArgumentResult);
                 }
 
-                if (commandArgumentResultCount >= _argumentResults.Count)
+                if (commandArgumentResultCount >= argumentResults.Count)
                 {
-                    var argumentResult = _argumentResults[i];
+                    var argumentResult = argumentResults[i];
 
                     ValidateAndConvertArgumentResult(argumentResult);
 
@@ -315,11 +325,11 @@ private void ValidateAndConvertArgumentResults(IList<Argument> arguments, int co
                 }
             }
 
-            if (_argumentResults.Count > arguments.Count)
+            if (argumentResults.Count > arguments.Count)
             {
-                for (var i = arguments.Count; i < _argumentResults.Count - 1; i++)
+                for (var i = arguments.Count; i < argumentResults.Count - 1; i++)
                 {
-                    var result = _argumentResults[i];
+                    var result = argumentResults[i];
 
                     if (result.Parent is CommandResult)
                     {
@@ -361,19 +371,22 @@ private void ValidateCommandResult()
             Command? currentCommand = command;
             while (currentCommand is not null)
             {
-                var options = currentCommand.Options;
-                for (var i = 0; i < options.Count; i++)
+                if (currentCommand.HasOptions)
                 {
-                    var option = options[i];
-                    if (option.IsRequired && (!checkOnlyGlobalOptions || (checkOnlyGlobalOptions && option.IsGlobal)))
+                    var options = currentCommand.Options;
+                    for (var i = 0; i < options.Count; i++)
                     {
-                        if (_rootCommandResult!.FindResultFor(option) is null)
+                        var option = options[i];
+                        if (option.IsRequired && (!checkOnlyGlobalOptions || (checkOnlyGlobalOptions && option.IsGlobal)))
                         {
-                            AddErrorToResult(
-                                _innermostCommandResult,
-                                new ParseError(
-                                    _rootCommandResult.LocalizationResources.RequiredOptionWasNotProvided(option),
-                                    _innermostCommandResult));
+                            if (_rootCommandResult!.FindResultFor(option) is null)
+                            {
+                                AddErrorToResult(
+                                    _innermostCommandResult,
+                                    new ParseError(
+                                        _rootCommandResult.LocalizationResources.RequiredOptionWasNotProvided(option),
+                                        _innermostCommandResult));
+                            }
                         }
                     }
                 }
@@ -433,12 +446,12 @@ private void ValidateCommandHandler()
                 return;
             }
 
-            if (cmd.Subcommands.Count == 0)
+            if (!cmd.HasSubcommands)
             {
                 return;
             }
 
-            _errors.Insert(
+            (_errors ??= new()).Insert(
                 0,
                 new ParseError(
                     _innermostCommandResult.LocalizationResources.RequiredCommandWasNotProvided(),
@@ -540,20 +553,26 @@ private void PopulateDefaultValues()
         {
             var commandResult = _innermostCommandResult;
             
-            while (commandResult is { })
+            while (commandResult is not null)
             {
-                var options = commandResult.Command.Options;
-                for (var i = 0; i < options.Count; i++)
+                if (commandResult.Command.HasOptions)
                 {
-                    Symbol symbol = options[i];
-                    Handle(_rootCommandResult!.FindResultForSymbol(symbol), symbol);
+                    var options = commandResult.Command.Options;
+                    for (var i = 0; i < options.Count; i++)
+                    {
+                        Symbol symbol = options[i];
+                        Handle(_rootCommandResult!.FindResultForSymbol(symbol), symbol);
+                    }
                 }
 
-                var arguments = commandResult.Command.Arguments;
-                for (var i = 0; i < arguments.Count; i++)
+                if (commandResult.Command.HasArguments)
                 {
-                    Symbol symbol = arguments[i];
-                    Handle(_rootCommandResult!.FindResultForSymbol(symbol), symbol);
+                    var arguments = commandResult.Command.Arguments;
+                    for (var i = 0; i < arguments.Count; i++)
+                    {
+                        Symbol symbol = arguments[i];
+                        Handle(_rootCommandResult!.FindResultForSymbol(symbol), symbol);
+                    }
                 }
 
                 commandResult = commandResult.Parent as CommandResult;
@@ -591,7 +610,7 @@ void Handle(SymbolResult? symbolResult, Symbol symbol)
                                 commandResult.AddChild(optionResult);
                                 if (_symbolResults.TryAdd(optionResult.Symbol, optionResult))
                                 {
-                                    _optionResults.Add(optionResult);
+                                    (_optionResults ??= new()).Add(optionResult);
                                 }
 
                                 break;
@@ -618,7 +637,7 @@ private void AddErrorToResult(SymbolResult symbolResult, ParseError parseError)
                 optionResult.ErrorMessage ??= symbolResult.ErrorMessage;
             }
 
-            _errors.Add(parseError);
+            (_errors ??= new()).Add(parseError);
         }
 
         public ParseResult GetResult() =>
@@ -626,7 +645,7 @@ public ParseResult GetResult() =>
                 _rootCommandResult ?? throw new InvalidOperationException("No root command was found"),
                 _innermostCommandResult ?? throw new InvalidOperationException("No command was found"),
                 _directives,
-                _tokenizeResult,
+                _tokens,
                 _unmatchedTokens,
                 _errors,
                 _rawInput);
diff --git a/src/System.CommandLine/Parsing/Parser.cs b/src/System.CommandLine/Parsing/Parser.cs
index 3271e062fb..6ea53be755 100644
--- a/src/System.CommandLine/Parsing/Parser.cs
+++ b/src/System.CommandLine/Parsing/Parser.cs
@@ -41,22 +41,27 @@ public Parser() : this(new RootCommand())
         /// <param name="rawInput">The complete command line input prior to splitting and tokenization. This input is not typically available when the parser is called from <c>Program.Main</c>. It is primarily used when calculating completions via the <c>dotnet-suggest</c> tool.</param>
         /// <returns>A <see cref="ParseResult"/> providing details about the parse operation.</returns>
         public ParseResult Parse(
-            IReadOnlyList<string> arguments,
+            IReadOnlyList<string>? arguments,
             string? rawInput = null)
         {
-            var tokenizeResult = arguments.Tokenize(
+            arguments ??= Array.Empty<string>();
+
+            arguments.Tokenize(
                 Configuration,
-                inferRootCommand: rawInput is not null);
+                inferRootCommand: rawInput is not null,
+                out List<Token> tokens,
+                out List<string>? tokenizationErrors);
 
             var operation = new ParseOperation(
-                tokenizeResult,
+                tokens,
                 Configuration);
 
             operation.Parse();
 
             var visitor = new ParseResultVisitor(
                 this,
-                tokenizeResult,
+                tokens,
+                tokenizationErrors,
                 operation.UnmatchedTokens,
                 rawInput);
 
diff --git a/src/System.CommandLine/Parsing/StringExtensions.cs b/src/System.CommandLine/Parsing/StringExtensions.cs
index 6fcf60328a..ee7010b933 100644
--- a/src/System.CommandLine/Parsing/StringExtensions.cs
+++ b/src/System.CommandLine/Parsing/StringExtensions.cs
@@ -68,26 +68,35 @@ internal static (string? Prefix, string Alias) SplitPrefix(this string rawAlias)
             return (null, rawAlias);
         }
 
-        internal static TokenizeResult Tokenize(
+        // this method is not returning a Value Tuple or a dedicated type to avoid JITting
+        internal static void Tokenize(
             this IReadOnlyList<string> args,
             CommandLineConfiguration configuration,
-            bool inferRootCommand = true)
+            bool inferRootCommand,
+            out List<Token> tokens,
+            out List<string>? errors)
         {
-            var errorList = new List<string>();
+            const int FirstArgIsNotRootCommand = -1;
+
+            List<string>? errorList = null;
 
             var currentCommand = configuration.RootCommand;
             var foundDoubleDash = false;
             var foundEndOfDirectives = !configuration.EnableDirectives;
 
-            var argList = NormalizeRootCommand(args, configuration.RootCommand, inferRootCommand);
-
-            var tokenList = new List<Token>(argList.Count);
+            var tokenList = new List<Token>(args.Count);
 
             var knownTokens = configuration.RootCommand.ValidTokens();
 
-            for (var i = 0; i < argList.Count; i++)
+            int i = FirstArgumentIsRootCommand(args, configuration.RootCommand, inferRootCommand)
+                ? 0
+                : FirstArgIsNotRootCommand;
+
+            for (; i < args.Count; i++)
             {
-                var arg = argList[i];
+                var arg = i == FirstArgIsNotRootCommand
+                    ? configuration.RootCommand.Name
+                    : args[i];
 
                 if (foundDoubleDash)
                 {
@@ -110,7 +119,7 @@ internal static TokenizeResult Tokenize(
                         arg[0] == '[' &&
                         arg[1] != ']' &&
                         arg[1] != ':' &&
-                        arg.EndsWith("]", StringComparison.Ordinal))
+                        arg[arg.Length - 1] == ']')
                     {
                         tokenList.Add(Directive(arg));
                         continue;
@@ -131,12 +140,17 @@ configuration.TokenReplacer is { } replacer &&
                             out var newTokens,
                             out var error))
                     {
-                        argList.InsertRange(i + 1, newTokens ?? Array.Empty<string>());
+                        if (newTokens is not null && newTokens.Count > 0)
+                        {
+                            List<string> listWithReplacedTokens = args.ToList();
+                            listWithReplacedTokens.InsertRange(i + 1, newTokens);
+                            args = listWithReplacedTokens;
+                        }
                         continue;
                     }
                     else if (!string.IsNullOrWhiteSpace(error))
                     {
-                        errorList.Add(error!);
+                        (errorList ??= new()).Add(error!);
                         continue;
                     }
                 }
@@ -208,7 +222,8 @@ configuration.TokenReplacer is { } replacer &&
                 Token Directive(string value) => new(value, TokenType.Directive, default, i);
             }
 
-            return new TokenizeResult(tokenList, errorList);
+            tokens = tokenList;
+            errors = errorList;
 
             bool CanBeUnbundled(string arg)
                 => arg.Length > 2
@@ -286,53 +301,31 @@ bool PreviousTokenIsAnOptionExpectingAnArgument(out Option? option)
             }
         }
 
-        private static List<string> NormalizeRootCommand(
-            IReadOnlyList<string>? args,
-            Command rootCommand,
-            bool inferRootCommand = true)
+        private static bool FirstArgumentIsRootCommand(IReadOnlyList<string> args, Command rootCommand, bool inferRootCommand)
         {
-            if (args is null)
-            {
-                args = new List<string>();
-            }
-
-            var list = new List<string>();
-
             if (args.Count > 0)
             {
-                if (inferRootCommand &&
-                    args[0] == RootCommand.ExecutablePath)
+                if (inferRootCommand && args[0] == RootCommand.ExecutablePath)
                 {
-                    list.AddRange(args);
-                    return list;
+                    return true;
                 }
-                else
+
+                try
                 {
-                    try
-                    {
-                        var potentialRootCommand = Path.GetFileName(args[0]);
+                    var potentialRootCommand = Path.GetFileName(args[0]);
 
-                        if (rootCommand.HasAlias(potentialRootCommand))
-                        {
-                            list.AddRange(args);
-                            return list;
-                        }
-                    }
-                    catch (ArgumentException)
+                    if (rootCommand.HasAlias(potentialRootCommand))
                     {
-                        // possible exception for illegal characters in path on .NET Framework
+                        return true;
                     }
                 }
+                catch (ArgumentException)
+                {
+                    // possible exception for illegal characters in path on .NET Framework
+                }
             }
 
-            list.Add(rootCommand.Name);
-
-            for (var i = 0; i < args.Count; i++)
-            {
-                list.Add(args[i]);
-            }
-
-            return list;
+            return false;
         }
 
         private static string? GetReplaceableTokenValue(this string arg) =>
@@ -440,25 +433,31 @@ private static Dictionary<string, Token> ValidTokens(this Command command)
                     new Token(commandAlias, TokenType.Command, command, Token.ImplicitPosition));
             }
 
-            var subCommands = command.Subcommands;
-            for (int childIndex = 0; childIndex < subCommands.Count; childIndex++)
+            if (command.HasSubcommands)
             {
-                Command cmd = subCommands[childIndex];
-                foreach (string childAlias in cmd.Aliases)
+                var subCommands = command.Subcommands;
+                for (int childIndex = 0; childIndex < subCommands.Count; childIndex++)
                 {
-                    tokens.Add(childAlias, new Token(childAlias, TokenType.Command, cmd, Token.ImplicitPosition));
+                    Command cmd = subCommands[childIndex];
+                    foreach (string childAlias in cmd.Aliases)
+                    {
+                        tokens.Add(childAlias, new Token(childAlias, TokenType.Command, cmd, Token.ImplicitPosition));
+                    }
                 }
             }
 
-            var options = command.Options;
-            for (int childIndex = 0; childIndex < options.Count; childIndex++)
+            if (command.HasOptions)
             {
-                Option option = options[childIndex];
-                foreach (string childAlias in option.Aliases)
+                var options = command.Options;
+                for (int childIndex = 0; childIndex < options.Count; childIndex++)
                 {
-                    if (!option.IsGlobal || !tokens.ContainsKey(childAlias))
+                    Option option = options[childIndex];
+                    foreach (string childAlias in option.Aliases)
                     {
-                        tokens.Add(childAlias, new Token(childAlias, TokenType.Option, option, Token.ImplicitPosition));
+                        if (!option.IsGlobal || !tokens.ContainsKey(childAlias))
+                        {
+                            tokens.Add(childAlias, new Token(childAlias, TokenType.Option, option, Token.ImplicitPosition));
+                        }
                     }
                 }
             }
@@ -472,16 +471,19 @@ private static Dictionary<string, Token> ValidTokens(this Command command)
                 {
                     if ((parentCommand = parent.Symbol as Command) is not null)
                     {
-                        for (var i = 0; i < parentCommand.Options.Count; i++)
+                        if (parentCommand.HasOptions)
                         {
-                            Option option = parentCommand.Options[i];
-                            if (option.IsGlobal)
+                            for (var i = 0; i < parentCommand.Options.Count; i++)
                             {
-                                foreach (var childAlias in option.Aliases)
+                                Option option = parentCommand.Options[i];
+                                if (option.IsGlobal)
                                 {
-                                    if (!tokens.ContainsKey(childAlias))
+                                    foreach (var childAlias in option.Aliases)
                                     {
-                                        tokens.Add(childAlias, new Token(childAlias, TokenType.Option, option, Token.ImplicitPosition));
+                                        if (!tokens.ContainsKey(childAlias))
+                                        {
+                                            tokens.Add(childAlias, new Token(childAlias, TokenType.Option, option, Token.ImplicitPosition));
+                                        }
                                     }
                                 }
                             }
diff --git a/src/System.CommandLine/Parsing/SymbolResult.cs b/src/System.CommandLine/Parsing/SymbolResult.cs
index 0f495cd7cf..5415ef2458 100644
--- a/src/System.CommandLine/Parsing/SymbolResult.cs
+++ b/src/System.CommandLine/Parsing/SymbolResult.cs
@@ -12,10 +12,9 @@ namespace System.CommandLine.Parsing
     /// </summary>
     public abstract class SymbolResult
     {
-        private readonly List<SymbolResult> _children = new();
-        private protected readonly List<Token> _tokens = new();
+        private List<SymbolResult>? _children;
+        private protected List<Token>? _tokens;
         private LocalizationResources? _resources;
-        private readonly Dictionary<Argument, ArgumentResult> _defaultArgumentValues = new();
 
         private protected SymbolResult(
             Symbol symbol, 
@@ -37,9 +36,9 @@ private protected SymbolResult(
         /// <summary>
         /// Child symbol results in the parse tree.
         /// </summary>
-        public IReadOnlyList<SymbolResult> Children => _children;
+        public IReadOnlyList<SymbolResult> Children => _children is not null ? _children : Array.Empty<SymbolResult>();
 
-        internal void AddChild(SymbolResult symbolResult) => _children.Add(symbolResult);
+        internal void AddChild(SymbolResult symbolResult) => (_children ??= new()).Add(symbolResult);
 
         /// <summary>
         /// The parent symbol result in the parse tree.
@@ -56,7 +55,7 @@ private protected SymbolResult(
         /// <summary>
         /// The list of tokens associated with this symbol result during parsing.
         /// </summary>
-        public IReadOnlyList<Token> Tokens => _tokens;
+        public IReadOnlyList<Token> Tokens => _tokens is not null ? _tokens : Array.Empty<Token>();
 
         internal bool IsArgumentLimitReached => RemainingArgumentCapacity == 0;
 
@@ -78,11 +77,14 @@ internal int MaximumArgumentCapacity
                     case Command command:
                         var value = 0;
 
-                        var arguments = command.Arguments;
-
-                        for (var i = 0; i < arguments.Count; i++)
+                        if (command.HasArguments)
                         {
-                            value += arguments[i].Arity.MaximumNumberOfValues;
+                            var arguments = command.Arguments;
+
+                            for (var i = 0; i < arguments.Count; i++)
+                            {
+                                value += arguments[i].Arity.MaximumNumberOfValues;
+                            }
                         }
 
                         return value;
@@ -102,7 +104,7 @@ public LocalizationResources LocalizationResources
             set => _resources = value;
         }
 
-        internal void AddToken(Token token) => _tokens.Add(token);
+        internal void AddToken(Token token) => (_tokens ??= new()).Add(token);
 
         /// <summary>
         /// Finds a result for the specific argument anywhere in the parse tree, including parent and child symbol results.
@@ -176,11 +178,6 @@ public T GetValue<T>(Argument<T> argument)
             return ArgumentConverter.GetDefaultValue(option.Argument.ValueType);
         }
 
-        internal ArgumentResult GetOrCreateDefaultArgumentResult(Argument argument) =>
-            _defaultArgumentValues.GetOrAdd(
-                argument,
-                arg => new ArgumentResult(arg, this));
-
         internal virtual bool UseDefaultValueFor(Argument argument) => false;
 
         /// <inheritdoc/>
diff --git a/src/System.CommandLine/Parsing/Token.cs b/src/System.CommandLine/Parsing/Token.cs
index 6798c0f694..74dc55a63d 100644
--- a/src/System.CommandLine/Parsing/Token.cs
+++ b/src/System.CommandLine/Parsing/Token.cs
@@ -49,7 +49,7 @@ internal Token(string? value, TokenType type, Symbol? symbol, int position)
         internal Symbol? Symbol { get; }
 
         /// <inheritdoc />
-        public override bool Equals(object? obj) => obj is Token other && Equals(other);
+        public override bool Equals(object? obj) => Equals(obj as Token);
 
         /// <inheritdoc />
         public bool Equals(Token? other) => other is not null && Value == other.Value && Type == other.Type && ReferenceEquals(Symbol, other.Symbol);
@@ -75,6 +75,5 @@ internal Token(string? value, TokenType type, Symbol? symbol, int position)
         /// <param name="right">The second <see cref="Token"/>.</param>
         /// <returns><see langword="true" /> if the objects are not equal.</returns>
         public static bool operator !=(Token? left, Token? right) => left is null ? right is not null : !left.Equals(right);
-
     }
 }
diff --git a/src/System.CommandLine/Parsing/TokenizeResult.cs b/src/System.CommandLine/Parsing/TokenizeResult.cs
deleted file mode 100644
index 565a0cb8e7..0000000000
--- a/src/System.CommandLine/Parsing/TokenizeResult.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright (c) .NET Foundation and contributors. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-using System.Collections.Generic;
-
-namespace System.CommandLine.Parsing;
-
-internal class TokenizeResult
-{
-    internal TokenizeResult(
-        List<Token> tokens,
-        List<string> errors)
-    {
-        Tokens = tokens;
-        Errors = errors;
-    }
-
-    public List<Token> Tokens { get; }
-
-    public List<string> Errors { get; }
-}
\ No newline at end of file