More perf tuning (#1161)

* change type of ICommand.Arguments and .Options from IEnumerable to IReadOnlyList

* replace a bunch of foreach loops with for loops

* a few fewer allocations, here and there

Author: jonsequitur

src/System.CommandLine.DragonFruit.Tests/ConfigureFromMethodTests.cs

@@ -138,8 +138,7 @@ public void Options_are_not_generated_for_command_argument_parameters(string met
                                              "args"
                                          };
 
-            rootCommand.Children
-                       .OfType<IOption>()
+            rootCommand.Options
                        .Should()
                        .NotContain(o => argumentParameterNames.Contains(o.Name));
         }

src/System.CommandLine.DragonFruit/CommandLine.cs

@@ -223,12 +223,13 @@ public static CommandLineBuilder ConfigureHelpFromXmlComments(
                         }
                         else
                         {
-                            foreach (var argument in builder.Command.Arguments)
+                            for (var i = 0; i < builder.Command.Arguments.Count; i++)
                             {
+                                var argument = builder.Command.Arguments[i];
                                 if (string.Equals(
-                                        argument.Name,
-                                        kebabCasedParameterName, 
-                                        StringComparison.OrdinalIgnoreCase))
+                                    argument.Name,
+                                    kebabCasedParameterName,
+                                    StringComparison.OrdinalIgnoreCase))
                                 {
                                     argument.Description = parameterDescription.Value;
                                 }

src/System.CommandLine.Rendering/StringExtensions.cs

@@ -7,11 +7,11 @@ internal static class StringExtensions
     {
         public static bool EndsWithWhitespace(this string value) =>
             value.Length > 0
-            && Char.IsWhiteSpace(value[value.Length - 1]);
+            && char.IsWhiteSpace(value[value.Length - 1]);
 
         public static bool StartsWithWhitespace(this string value) =>
             value.Length > 0
-            && Char.IsWhiteSpace(value[0]);
+            && char.IsWhiteSpace(value[0]);
 
         public static bool IsNewLine(this string value) => value == "\n" || value == "\r\n";
     }

src/System.CommandLine.Suggest/GlobalToolsSuggestionRegistration.cs

@@ -46,7 +46,10 @@ public IEnumerable<Registration> FindAllRegistrations()
 
         public Registration FindRegistration(FileInfo soughtExecutable)
         {
-            if (soughtExecutable == null) throw new ArgumentNullException(nameof(soughtExecutable));
+            if (soughtExecutable == null)
+            {
+                throw new ArgumentNullException(nameof(soughtExecutable));
+            }
 
             if (_nullableToolsShimPath == null)
             {

src/System.CommandLine.Suggest/SuggestionDispatcher.cs

@@ -179,7 +179,7 @@ IEnumerable<string> Prefixes()
 
                     yield return fileNameWithoutExtension;
 
-                    if (fileNameWithoutExtension.StartsWith("dotnet-", StringComparison.Ordinal))
+                    if (fileNameWithoutExtension?.StartsWith("dotnet-", StringComparison.Ordinal) == true)
                     {
                         yield return "dotnet " + fileNameWithoutExtension.Substring("dotnet-".Length);
                     }

src/System.CommandLine.Tests/Binding/TypeConversionTests.cs

@@ -493,16 +493,18 @@ public void A_default_value_with_a_custom_constructor_can_be_specified_for_a_com
         {
             var directoryInfo = new DirectoryInfo(Directory.GetCurrentDirectory());
 
+            var argument = new Argument<DirectoryInfo>("the-arg", () => directoryInfo);
+
             var command = new Command("something")
             {
-                new Argument<DirectoryInfo>("the-arg", () => directoryInfo)
+                argument
             };
 
             var result = command.Parse("something");
 
             result.Errors.Should().BeEmpty();
 
-            var value = result.CommandResult.GetArgumentValueOrDefault("the-arg");
+            var value = result.ValueForArgument("the-arg");
 
             value.Should().Be(directoryInfo);
         }

src/System.CommandLine.Tests/CommandTests.cs

@@ -134,37 +134,6 @@ public void Commands_at_multiple_levels_can_have_their_own_arguments()
                   .BeEquivalentTo("arg2", "arg3");
         }
 
-        [Theory]
-        [InlineData("aa:", ":")]
-        [InlineData("aa=", "=")]
-        [InlineData(":aa", ":")]
-        [InlineData("=aa", "=")]
-        [InlineData("aa:aa", ":")]
-        [InlineData("aa=aa", "=")]
-        public void When_a_command_name_contains_a_delimiter_then_an_error_is_returned(
-            string commandWithDelimiter,
-            string delimiter)
-        {
-            Action create = () =>
-            {
-                new Parser(
-                    new Command(commandWithDelimiter)
-                    {
-                        new Argument
-                        {
-                            Arity = ArgumentArity.ExactlyOne
-                        }
-                    });
-            };
-
-            create.Should()
-                  .Throw<ArgumentException>()
-                  .Which
-                  .Message
-                  .Should()
-                  .Be($"Command \"{commandWithDelimiter}\" is not allowed to contain a delimiter but it contains \"{delimiter}\"");
-        }
-
         [Fact]
         public void Aliases_is_aware_of_added_alias()
         {

src/System.CommandLine.Tests/GlobalOptionTests.cs

@@ -75,22 +75,6 @@ public void Global_options_appear_in_options_list()
             root.Options.Should().Contain(option);
         }
 
-        [Fact]
-        public void Global_options_appear_in_child_command_options_list()
-        {
-            var root = new Command("parent");
-
-            var option = new Option<int>("--global");
-
-            root.AddGlobalOption(option);
-
-            var child = new Command("child");
-
-            root.AddCommand(child);
-
-            child.Options.Should().Contain(option);
-        }
-
         [Fact]
         public void Subcommands_added_after_a_global_option_is_added_to_parent_will_recognize_the_global_option()
         {

src/System.CommandLine.Tests/OptionTests.cs

@@ -165,32 +165,6 @@ public void Raw_aliases_are_exposed_by_an_option()
                   .BeEquivalentTo("-h", "--help", "/?");
         }
 
-        [Theory]
-        [InlineData(":", "-x{0}")]
-        [InlineData("=", "-x{0}")]
-        [InlineData(":", "{0}-x")]
-        [InlineData("=", "{0}-x")]
-        [InlineData(":", "--aa{0}aa")]
-        [InlineData("=", "--aa{0}aa")]
-        public void When_an_option_alias_contains_a_delimiter_then_an_informative_error_is_returned(
-            string delimiter,
-            string template)
-        {
-            var alias = string.Format(template, delimiter);
-
-            Action create = () =>
-            {
-                new Parser(new Option(alias));
-            };
-
-            create.Should()
-                  .Throw<ArgumentException>()
-                  .Which
-                  .Message
-                  .Should()
-                  .Be($"Option \"{alias}\" is not allowed to contain a delimiter but it contains \"{delimiter}\"");
-        }
-
         [Theory]
         [InlineData("-x ")]
         [InlineData(" -x")]

src/System.CommandLine.Tests/ParserTests.MultipleArguments.cs

@@ -33,11 +33,9 @@ public void Multiple_arguments_can_differ_by_arity()
 
                 var result = command.Parse("1 2 3 4");
 
-                var several = result.CommandResult
-                                    .GetArgumentValueOrDefault<IEnumerable<string>>("several");
+                var several = result.ValueForArgument<IEnumerable<string>>("several");
 
-                var one = result.CommandResult
-                                .GetArgumentValueOrDefault<IEnumerable<string>>("one");
+                var one = result.ValueForArgument<IEnumerable<string>>("one");
 
                 several.Should()
                        .BeEquivalentSequenceTo("1", "2", "3");
@@ -62,11 +60,9 @@ public void Multiple_arguments_can_differ_by_type()
 
                 var result = command.Parse("1 2");
 
-                var theString = result.CommandResult
-                                    .GetArgumentValueOrDefault<string>("the-string");
+                var theString = result.ValueForArgument<string>("the-string");
 
-                var theInt = result.CommandResult
-                                .GetArgumentValueOrDefault<int>("the-int");
+                var theInt = result.ValueForArgument<int>("the-int");
 
                 theString.Should().Be("1");
                 theInt.Should().Be(2);
@@ -124,27 +120,29 @@ public void When_multiple_arguments_are_present_then_their_order_relative_to_sib
             [Fact]
             public void Multiple_arguments_of_unspecified_type_are_parsed_correctly()
             {
+                var sourceArg = new Argument("source")
+                {
+                    Arity = ArgumentArity.ExactlyOne
+                };
+                var destinationArg = new Argument("destination")
+                {
+                    Arity = ArgumentArity.ExactlyOne
+                };
                 var root = new RootCommand
                 {
-                    new Argument("source")
-                    {
-                        Arity = ArgumentArity.ExactlyOne
-                    },
-                    new Argument("destination")
-                    {
-                        Arity = ArgumentArity.ExactlyOne
-                    }
+                    sourceArg,
+                    destinationArg
                 };
 
                 var result = root.Parse("src.txt dest.txt");
 
-                result.RootCommandResult
-                      .GetArgumentValueOrDefault("source")
+                result.FindResultFor(sourceArg)
+                      .GetValueOrDefault()
                       .Should()
                       .Be("src.txt");
 
-                result.RootCommandResult
-                      .GetArgumentValueOrDefault("destination")
+                result.FindResultFor(destinationArg)
+                      .GetValueOrDefault()
                       .Should()
                       .Be("dest.txt");
             }