Expose Command collection properties as mutable IList, remove AddCommand, AddOption and AddArugment methods

src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt

@@ -46,20 +46,15 @@ System.CommandLine
     public static Argument<T> AcceptExistingOnly<T>(this Argument<T> argument)
   public class Command : IdentifierSymbol, System.Collections.Generic.IEnumerable<Symbol>, System.Collections.IEnumerable
     .ctor(System.String name, System.String description = null)
-    public System.Collections.Generic.IReadOnlyList<Argument> Arguments { get; }
+    public System.Collections.Generic.IList<Argument> Arguments { get; }
     public System.Collections.Generic.IEnumerable<Symbol> Children { get; }
     public ICommandHandler Handler { get; set; }
-    public System.Collections.Generic.IReadOnlyList<Option> Options { get; }
-    public System.Collections.Generic.IReadOnlyList<Command> Subcommands { get; }
+    public System.Collections.Generic.IList<Option> Options { get; }
+    public System.Collections.Generic.IList<Command> Subcommands { get; }
     public System.Boolean TreatUnmatchedTokensAsErrors { get; set; }
     public System.Collections.Generic.List<System.Action<System.CommandLine.Parsing.CommandResult>> Validators { get; }
-    public System.Void Add(Option option)
-    public System.Void Add(Argument argument)
-    public System.Void Add(Command command)
-    public System.Void AddArgument(Argument argument)
-    public System.Void AddCommand(Command command)
+    public System.Void Add(Symbol symbol)
     public System.Void AddGlobalOption(Option option)
-    public System.Void AddOption(Option option)
     public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
     public System.Collections.Generic.IEnumerator<Symbol> GetEnumerator()
   public static class CommandExtensions

src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs

@@ -21,8 +21,8 @@ public void SetupOneOptWithNestedCommand()
             var rootCommand = new Command("root_command");
             var nestedCommand = new Command("nested_command");
             var option = new Option<int>("-opt1", () => 123);
-            nestedCommand.AddOption(option);
-            rootCommand.AddCommand(nestedCommand);
+            nestedCommand.Options.Add(option);
+            rootCommand.Subcommands.Add(nestedCommand);
 
             _testParser = new Parser(rootCommand);
             _testSymbolsAsString = "root_command nested_command -opt1 321";

src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs

@@ -40,7 +40,7 @@ private void GenerateTestNestedCommands(Command parent, int depth, int countPerL
             {
                 string cmdName = $"{parent.Name}_{depth}.{i}";
                 Command cmd = new(cmdName);
-                parent.AddCommand(cmd);
+                parent.Subcommands.Add(cmd);
                 GenerateTestNestedCommands(cmd, depth - 1, countPerLevel);
             }
         }

src/System.CommandLine.Benchmarks/CommandLine/Perf_Suggestions.cs

@@ -54,7 +54,7 @@ public void Setup_FromParseResult()
 
             foreach (var option in GenerateOptionsArray(TestSuggestionsCount))
             {
-                testCommand.AddOption(option);
+                testCommand.Options.Add(option);
             }
 
             _testParseResult = testCommand.Parse("--wrong");

src/System.CommandLine.DragonFruit/CommandLine.cs

@@ -160,12 +160,12 @@ public static void ConfigureFromMethod(
 
             foreach (var option in method.BuildOptions())
             {
-                command.AddOption(option);
+                command.Options.Add(option);
             }
 
             if (method.GetParameters().FirstOrDefault(p => _argumentParameterNames.Contains(p.Name)) is { } argsParam)
             {
-                command.AddArgument(ArgumentBuilder.CreateArgument(argsParam));
+                command.Arguments.Add(ArgumentBuilder.CreateArgument(argsParam));
             }
 
             command.Handler = CommandHandler.Create(method, target);

src/System.CommandLine.Generator.Tests/GeneratedCommandHandlerTests.cs

@@ -95,9 +95,9 @@ void Execute(Character character, IConsole console)
 
             var command = new Command("command");
             var nameOption = new Option<string>("--name");
-            command.AddOption(nameOption);
+            command.Options.Add(nameOption);
             var ageOption = new Option<int>("--age");
-            command.AddOption(ageOption);
+            command.Options.Add(ageOption);
 
             command.SetHandler<Action<Character, IConsole>>(Execute, nameOption, ageOption);
 
@@ -118,9 +118,9 @@ int Execute(int first, int second)
 
             var command = new Command("add");
             var firstArgument = new Argument<int>("first");
-            command.AddArgument(firstArgument);
+            command.Arguments.Add(firstArgument);
             var secondArgument = new Argument<int>("second");
-            command.AddArgument(secondArgument);
+            command.Arguments.Add(secondArgument);
 
             command.SetHandler<Func<int, int, int>>(Execute, firstArgument, secondArgument);
 
@@ -243,12 +243,12 @@ void Execute2(string value)
 
             var command1 = new Command("first");
             var argument1 = new Argument<string>("first-value");
-            command1.AddArgument(argument1);
+            command1.Arguments.Add(argument1);
             command1.SetHandler<Action<string>>(Execute1, argument1);
 
             var command2 = new Command("second");
             var argument2 = new Argument<string>("second-value");
-            command2.AddArgument(argument2);
+            command2.Arguments.Add(argument2);
             command2.SetHandler<Action<string>>(Execute2, argument2);
 
             await command1.InvokeAsync("first v1", _console);

src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs

@@ -59,8 +59,8 @@ public static async Task Can_have_diferent_handlers_based_on_command()
         {
             var root = new RootCommand();
 
-            root.AddCommand(new MyCommand());
-            root.AddCommand(new MyOtherCommand());
+            root.Subcommands.Add(new MyCommand());
+            root.Subcommands.Add(new MyOtherCommand());
             var parser = new CommandLineBuilder(root)
                 .UseHost(host =>
                 {
@@ -90,7 +90,7 @@ public static async Task Can_bind_to_arguments_via_injection()
         {
             var service = new MyService();
             var cmd = new RootCommand();
-            cmd.AddCommand(new MyOtherCommand());
+            cmd.Subcommands.Add(new MyOtherCommand());
             var parser = new CommandLineBuilder(cmd)
                 .UseHost(host =>
                 {
@@ -113,8 +113,8 @@ public static async Task Invokes_DerivedClass()
             var service = new MyService();
 
             var cmd = new RootCommand();
-            cmd.AddCommand(new MyCommand());
-            cmd.AddCommand(new MyOtherCommand());
+            cmd.Subcommands.Add(new MyCommand());
+            cmd.Subcommands.Add(new MyOtherCommand());
             var parser = new CommandLineBuilder(cmd)
                          .UseHost((builder) => {
                              builder.ConfigureServices(services =>
@@ -155,7 +155,7 @@ public class MyCommand : Command
         {
             public MyCommand() : base(name: "mycommand")
             {
-                AddOption(new Option<int>("--int-option")); // or nameof(Handler.IntOption).ToKebabCase() if you don't like the string literal
+                Options.Add(new Option<int>("--int-option")); // or nameof(Handler.IntOption).ToKebabCase() if you don't like the string literal
             }
 
             public class MyHandler : ICommandHandler
@@ -204,8 +204,8 @@ public class MyOtherCommand : Command
         {
             public MyOtherCommand() : base(name: "myothercommand")
             {
-                AddOption(new Option<int>("--int-option")); // or nameof(Handler.IntOption).ToKebabCase() if you don't like the string literal
-                AddArgument(new Argument<string>("One"));
+                Options.Add(new Option<int>("--int-option")); // or nameof(Handler.IntOption).ToKebabCase() if you don't like the string literal
+                Arguments.Add(new Argument<string>("One"));
             }
 
             public class MyHandler : ICommandHandler

src/System.CommandLine.Hosting.Tests/HostingTests.cs

@@ -202,7 +202,7 @@ public static void UseHost_binds_parsed_arguments_to_options()
             MyOptions options = null;
 
             var rootCmd = new RootCommand();
-            rootCmd.AddOption(new Option<int>($"-{nameof(MyOptions.MyArgument)}"));
+            rootCmd.Options.Add(new Option<int>($"-{nameof(MyOptions.MyArgument)}"));
             rootCmd.Handler = CommandHandler.Create((IHost host) =>
             {
                 options = host.Services

src/System.CommandLine.NamingConventionBinder.Tests/ModelBinderTests.cs

@@ -101,7 +101,7 @@ public void Explicitly_configured_default_values_can_be_bound_by_name_to_constru
         var option = new Option<string>("--string-option", () => "the default");
 
         var command = new Command("the-command");
-        command.AddOption(option);
+        command.Options.Add(option);
         var binder = new ModelBinder(typeof(ClassWithMultiLetterCtorParameters));
 
         var parser = new Parser(command);
@@ -176,7 +176,7 @@ public void Types_having_constructors_accepting_a_single_string_are_bound_using_
         var option = new Option<DirectoryInfo>("--value");
 
         var command = new Command("the-command");
-        command.AddOption(option);
+        command.Options.Add(option);
         var binder = new ModelBinder(typeof(ClassWithCtorParameter<DirectoryInfo>));
         var bindingContext = new InvocationContext(command.Parse($"--value \"{tempPath}\"")).BindingContext;
 
@@ -191,7 +191,7 @@ public void Explicitly_configured_default_values_can_be_bound_by_name_to_propert
         var option = new Option<string>("--value", () => "the default");
 
         var command = new Command("the-command");
-        command.AddOption(option);
+        command.Options.Add(option);
         var binder = new ModelBinder(typeof(ClassWithSetter<string>));
 
         var parser = new Parser(command);
@@ -421,7 +421,7 @@ public void PropertyInfo_can_be_bound_to_argument()
     {
         var command = new Command("the-command");
         var argument = new Argument<int> { Arity = ArgumentArity.ExactlyOne };
-        command.AddArgument(argument);
+        command.Arguments.Add(argument);
 
         var type = typeof(ClassWithMultiLetterSetters);
         var binder = new ModelBinder(type);
@@ -441,7 +441,7 @@ public void PropertyExpression_can_be_bound_to_option()
     {
         var command = new Command("the-command");
         var option = new Option<int>("--fred");
-        command.AddOption(option);
+        command.Options.Add(option);
 
         var binder = new ModelBinder<ClassWithMultiLetterSetters>();
 
@@ -461,7 +461,7 @@ public void PropertyExpression_can_be_bound_to_argument()
     {
         var command = new Command("the-command");
         var argument = new Argument<int> { Arity = ArgumentArity.ExactlyOne };
-        command.AddArgument(argument);
+        command.Arguments.Add(argument);
 
         var binder = new ModelBinder<ClassWithMultiLetterSetters>();
 
@@ -493,7 +493,7 @@ public void Option_argument_is_bound_to_longest_constructor()
     public void Command_argument_is_bound_to_longest_constructor()
     {
         var rootCommand = new RootCommand();
-        rootCommand.AddArgument(new Argument<int> { Name = nameof(ClassWithMultipleCtor.IntProperty) });
+        rootCommand.Arguments.Add(new Argument<int> { Name = nameof(ClassWithMultipleCtor.IntProperty) });
         var parser = new Parser(rootCommand);
 
         var bindingContext = new InvocationContext(parser.Parse("42")).BindingContext;

src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs

@@ -30,8 +30,8 @@ void Execute(string name, int age)
         }
 
         var command = new Command("command");
-        command.AddOption(new Option<string>("--name"));
-        command.AddOption(new Option<int>("--age"));
+        command.Options.Add(new Option<string>("--name"));
+        command.Options.Add(new Option<int>("--age"));
         command.Handler = CommandHandler.Create<string, int>(Execute);
 
         await command.InvokeAsync("command --age 425 --name Gandalf", _console);
@@ -74,8 +74,8 @@ void Execute(string name, int AGE)
         }
 
         var command = new Command("command");
-        command.AddOption(new Option<string>("--NAME"));
-        command.AddOption(new Option<int>("--age"));
+        command.Options.Add(new Option<string>("--NAME"));
+        command.Options.Add(new Option<int>("--age"));
         command.Handler = CommandHandler.Create<string, int>(Execute);
 
         await command.InvokeAsync("command --age 425 --NAME Gandalf", _console);
@@ -350,8 +350,8 @@ void Execute(string name, int age)
         }
 
         var command = new Command("command");
-        command.AddArgument(new Argument<int>("age"));
-        command.AddArgument(new Argument<string>("name"));
+        command.Arguments.Add(new Argument<int>("age"));
+        command.Arguments.Add(new Argument<string>("name"));
         command.Handler = CommandHandler.Create<string, int>(Execute);
 
         await command.InvokeAsync("command 425 Gandalf", _console);
@@ -394,8 +394,8 @@ void Execute(string name, int AGE)
         }
 
         var command = new Command("command");
-        command.AddArgument(new Argument<int>("AGE"));
-        command.AddArgument(new Argument<string>("Name"));
+        command.Arguments.Add(new Argument<int>("AGE"));
+        command.Arguments.Add(new Argument<string>("Name"));
         command.Handler = CommandHandler.Create<string, int>(Execute);
 
         await command.InvokeAsync("command 425 Gandalf", _console);
@@ -417,8 +417,8 @@ void Execute(string fullnameOrNickname, int age)
         }
 
         var command = new Command("command");
-        command.AddArgument(new Argument<int>("age"));
-        command.AddArgument(new Argument<string>("fullname|nickname"));
+        command.Arguments.Add(new Argument<int>("age"));
+        command.Arguments.Add(new Argument<string>("fullname|nickname"));
         command.Handler = CommandHandler.Create<string, int>(Execute);
 
         await command.InvokeAsync("command 425 Gandalf", _console);

src/System.CommandLine.Tests/ArgumentTests.cs

@@ -352,7 +352,7 @@ public async Task Custom_argument_parser_is_only_called_once()
 
                 var command = new RootCommand();
                 command.SetHandler((int value) => handlerWasCalled = true, option);
-                command.AddOption(option);
+                command.Options.Add(option);
 
                 await command.InvokeAsync("--value 42");
 

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

@@ -85,7 +85,7 @@ public void Binding_is_correct_for_Action_overload_having_arity_(int arity)
 
             for (var i = 1; i <= arity; i++)
             {
-                command.AddArgument(new Argument<int>($"i{i}"));
+                command.Arguments.Add(new Argument<int>($"i{i}"));
 
                 commandLine += $" {i}";
             }
@@ -176,7 +176,7 @@ public void Binding_is_correct_for_Func_overload_having_arity_(int arity)
 
             for (var i = 1; i <= arity; i++)
             {
-                command.AddArgument(new Argument<int>($"i{i}"));
+                command.Arguments.Add(new Argument<int>($"i{i}"));
 
                 commandLine += $" {i}";
             }

src/System.CommandLine.Tests/CommandTests.cs

@@ -98,7 +98,7 @@ public void Commands_at_multiple_levels_can_have_their_own_arguments()
             {
                 new Argument<string>()
             };
-            outer.AddCommand(
+            outer.Subcommands.Add(
                 new Command("inner")
                 {
                     new Argument<string[]>()

src/System.CommandLine.Tests/GlobalOptionTests.cs

@@ -19,7 +19,7 @@ public void Global_options_appear_in_options_list()
 
             var child = new Command("child");
 
-            root.AddCommand(child);
+            root.Subcommands.Add(child);
 
             root.Options.Should().Contain(option);
         }
@@ -90,7 +90,7 @@ public void Subcommands_added_after_a_global_option_is_added_to_parent_will_reco
 
             var child = new Command("child");
 
-            root.AddCommand(child);
+            root.Subcommands.Add(child);
 
             root.Parse("child --global 123").GetValue(option).Should().Be(123);
 
@@ -104,15 +104,15 @@ public void Subcommands_with_global_option_should_propagate_option_to_children()
 
             var firstChild = new Command("first");
 
-            root.AddCommand(firstChild);
+            root.Subcommands.Add(firstChild);
 
             var option = new Option<int>("--global");
 
             firstChild.AddGlobalOption(option);
 
             var secondChild = new Command("second");
 
-            firstChild.AddCommand(secondChild);
+            firstChild.Subcommands.Add(secondChild);
 
             root.Parse("first second --global 123").GetValue(option).Should().Be(123);
 

src/System.CommandLine.Tests/Help/HelpBuilderTests.Customization.cs

@@ -241,7 +241,7 @@ public void Option_can_fallback_to_default_when_customizing(bool conditionA, boo
                 var command = new Command("test");
                 var option = new Option<string>("--option", "description");
 
-                command.AddOption(option);
+                command.Options.Add(option);
 
                 var helpBuilder = new HelpBuilder(LocalizationResources.Instance, LargeMaxWidth);
                 helpBuilder.CustomizeSymbol(option,
@@ -278,7 +278,7 @@ public void Argument_can_fallback_to_default_when_customizing(
                 var argument = new Argument<string>("arg", "description");
                 argument.SetDefaultValue("default");
 
-                command.AddArgument(argument);
+                command.Arguments.Add(argument);
 
                 var helpBuilder = new HelpBuilder(LocalizationResources.Instance, LargeMaxWidth);
                 helpBuilder.CustomizeSymbol(argument,