Reducing memory allocations (#2001)

* delay error list allocation until it's needed

* add nullable annotation for Parser.Parse(arguments), avoid allocation when it's actually null

* don't allocate a new list to normalize RootCommand

* don't call EndsWith just to check one character

* avoid allocations for parsing directives:

* don't allocate new string to remove brackets
* don't allocate an array of characters (string.Split argument)
* don't allocate an array of strings (result of string.Split)

* delay List<SyntaxNode> allocation

* token type checks can be performed only for debug builds (these are internal methods that we control)

* remove unused property that was allocating a list

* delay List<OptionResult> allocation

* delay List<ArgumentResult allocation

* delay Dictionary<string, IReadOnlyList<string>> allocation

* store the results of ParseResult.UnmatchedTokens and re-use it since it's creating a copy every time it's called!

* avoid allocations when there are no unmatched tokens

* 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.

* remove TokenizeResult to reduce JIT time and allocations

* delay List<ParseError> allocation

* don't access Command.Options if there are no options defined (it allocates a list)

* don't access Command.Arguments if there are no arguments defined (it allocates a list)

* don't access Command.Subcommands if there are no commands defined (it allocates a list)

* delay List<SymbolResult> allocation

* delay List<Token> allocation

* not every SymbolResult needs to contain a Dictionary<Argument, ArgumentResult>

duplicate the code rather than introducing new public type like IdentifierSymbolResult

* Aliases are internally backed by a HashSet, there is no point in creating a Union of the same hash set

* avoid list allocation

* address code review feedback

Author: adamsitnik

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;
                 }
             }
 

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));
+                                    }
                                 }
                             }
 

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)
                 {

src/System.CommandLine/Invocation/TypoCorrection.cs

@@ -23,31 +23,39 @@ 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>()
                 .Where(x => !x.IsHidden)
                 .Where(x => x.Aliases.Count > 0)
                 .Select(symbol => 
                     symbol.Aliases
-                        .Union(symbol.Aliases)
                         .OrderBy(x => GetDistance(token, x))
                         .ThenByDescending(x => GetStartsWithDistance(token, x))
                         .First()

src/System.CommandLine/ParseResult.cs

@@ -14,44 +14,41 @@ 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)
         {
             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
             {
                 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.

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/>

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;

src/System.CommandLine/Parsing/CommandResult.cs

@@ -1,13 +1,17 @@
 // 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>
     /// A result produced when parsing a <see cref="Command" />.
     /// </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));
     }
 }

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;