Merge remote-tracking branch 'jonsequitur/tab-completion' into tab-completion

build/DependencyVersions.props

@@ -16,7 +16,7 @@
     <TemplateEngineTemplate2_0Version>1.0.0-beta1-20170209-117</TemplateEngineTemplate2_0Version>
     <PlatformAbstractionsVersion>1.0.3</PlatformAbstractionsVersion>
     <DependencyModelVersion>1.0.3</DependencyModelVersion>
-    <CliCommandLineParserVersion>0.1.0-alpha-74</CliCommandLineParserVersion>
+    <CliCommandLineParserVersion>0.1.0-alpha-84</CliCommandLineParserVersion>
     
   </PropertyGroup>
 

src/Microsoft.DotNet.Cli.Utils/PathUtility.cs

@@ -313,9 +313,12 @@ namespace Microsoft.DotNet.Tools.Common
             return Path.GetFullPath(path);
         }
 
-        public static void EnsureAllPathsExist(List<string> paths, string pathDoesNotExistLocalizedFormatString)
+        public static void EnsureAllPathsExist(
+            IReadOnlyCollection<string> paths,
+            string pathDoesNotExistLocalizedFormatString)
         {
             var notExisting = new List<string>();
+
             foreach (var p in paths)
             {
                 if (!File.Exists(p))
@@ -329,7 +332,7 @@ namespace Microsoft.DotNet.Tools.Common
                 throw new GracefulException(
                     string.Join(
                         Environment.NewLine,
-                        notExisting.Select((p) => string.Format(pathDoesNotExistLocalizedFormatString, p))));
+                        notExisting.Select(p => string.Format(pathDoesNotExistLocalizedFormatString, p))));
             }
         }
     }

src/dotnet/CommandBase.cs

@@ -0,0 +1,10 @@
+// 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.
+
+namespace Microsoft.DotNet.Cli
+{
+    public abstract class CommandBase
+    {
+        public abstract int Execute();
+    }
+}

src/dotnet/CommonOptions.cs

@@ -11,7 +11,7 @@ namespace Microsoft.DotNet.Cli
             Create.Option(
                 "-h|--help",
                 "Show help information",
-                Accept.NoArguments,
+                Accept.NoArguments(),
                 materialize: o => o.Option.Command().HelpView());
 
         public static Option VerbosityOption() =>

src/dotnet/DotNetSubCommandBase.cs

@@ -1,16 +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 Microsoft.DotNet.Cli.CommandLine;
-
-namespace Microsoft.DotNet.Cli
-{
-    internal abstract class DotNetSubCommandBase : CommandLineApplication
-    {
-        internal DotNetSubCommandBase() : base(throwOnUnexpectedArg: false)
-        {
-        }
-
-        public abstract int Run(string fileOrDirectory);
-    }
-}

src/dotnet/DotNetTopLevelCommandBase.cs

@@ -3,12 +3,9 @@
 
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.Tools;
-using Microsoft.DotNet.Tools.Common;
 
 namespace Microsoft.DotNet.Cli
 {
@@ -18,60 +15,34 @@ namespace Microsoft.DotNet.Cli
         protected abstract string FullCommandNameLocalized { get; }
         protected abstract string ArgumentName { get; }
         protected abstract string ArgumentDescriptionLocalized { get; }
-        internal abstract List<Func<DotNetSubCommandBase>> SubCommands { get; }
+        internal abstract Dictionary<string, Func<AppliedOption, CommandBase>> SubCommands { get; }
 
         public int RunCommand(string[] args)
         {
             DebugHelper.HandleDebugSwitch(ref args);
 
-            CommandLineApplication command = new CommandLineApplication(throwOnUnexpectedArg: true)
+            var parser = Parser.Instance;
-            {
-                Name = $"dotnet {CommandName}",
-                FullName = FullCommandNameLocalized,
-            };
 
-            command.HelpOption("-h|--help");
+            var result = parser.ParseFrom($"dotnet {CommandName}", args);
 
-            command.Argument(ArgumentName, ArgumentDescriptionLocalized);
+            Reporter.Output.WriteLine(result.Diagram());
 
-            foreach (var subCommandCreator in SubCommands)
+            result.ShowHelpIfRequested();
-            {
-                var subCommand = subCommandCreator();
-                command.AddCommand(subCommand);
 
-                subCommand.OnExecute(() => {
+            var subcommandName = result.Command().Name;
-                    try
-                    {
-                        if (!command.Arguments.Any())
-                        {
-                            throw new GracefulException(CommonLocalizableStrings.RequiredArgumentNotPassed, ArgumentDescriptionLocalized);
-                        }
 
-                        var projectOrDirectory = command.Arguments.First().Value;
+            var create = SubCommands[subcommandName];
-                        if (string.IsNullOrEmpty(projectOrDirectory))
-                        {
-                            projectOrDirectory = PathUtility.EnsureTrailingSlash(Directory.GetCurrentDirectory());
-                        }
 
-                        return subCommand.Run(projectOrDirectory);
+            var command = create(result["dotnet"][CommandName]);
-                    }
-                    catch (GracefulException e)
-                    {
-                        Reporter.Error.WriteLine(e.Message.Red());
-                        subCommand.ShowHelp();
-                        return 1;
-                    }
-                });
-            }
 
             try
             {
-                return command.Execute(args);
+                return command.Execute();
             }
             catch (GracefulException e)
             {
                 Reporter.Error.WriteLine(e.Message.Red());
-                command.ShowHelp();
+                result.ShowHelp();
                 return 1;
             }
             catch (CommandParsingException e)

src/dotnet/ParseResultExtensions.cs

@@ -14,11 +14,9 @@ namespace Microsoft.DotNet.Cli
 
         public static void ShowHelpIfRequested(this ParseResult parseResult)
         {
-            if (parseResult.HasOption("help"))
+            if (parseResult.AppliedOptions.Any(o => o.HasOption("help")))
             {
-
                 // NOTE: this is a temporary stage in refactoring toward the ClicCommandLineParser being used at the CLI entry point. 
-
                 throw new HelpException(parseResult.Command().HelpView());
             }
         }

src/dotnet/Parser.cs

@@ -12,7 +12,7 @@ namespace Microsoft.DotNet.Cli
             delimiters: Array.Empty<char>(),
             options: Create.Command("dotnet",
                                     ".NET Command Line Tools",
-                                    Accept.NoArguments,
+                                    Accept.NoArguments(),
                                     NewCommandParser.New(),
                                     RestoreCommandParser.Restore(),
                                     BuildCommandParser.Build(),

src/dotnet/Program.cs

@@ -54,7 +54,7 @@ namespace Microsoft.DotNet.Cli
             ["test"] = TestCommand.Run,
             ["vstest"] = VSTestCommand.Run,
             ["complete"] = CompleteCommand.Run,
-            ["parse"] = ParseCommand.Run,
+            ["parse"] = ParseCommand.Run
         };
 
         public static int Main(string[] args)

src/dotnet/commands/dotnet-add/AddCommandParser.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Net.Http;
 using System.Threading;
 using Microsoft.DotNet.Cli.CommandLine;
@@ -13,36 +14,48 @@ namespace Microsoft.DotNet.Cli
     internal static class AddCommandParser
     {
         public static Command Add() =>
-            Create.Command("add", 
+            Create.Command(
-                    ".NET Add Command",
+                "add",
-                    Accept.ExactlyOneArgument.DefaultToCurrentDirectory(),
+                ".NET Add Command",
-                    Create.Command("package",
+                Accept.ExactlyOneArgument()
-                            ".NET Add Package reference Command",
+                      .DefaultToCurrentDirectory(),
-                            Accept.ExactlyOneArgument
+                Create.Command(
-                                .WithSuggestionsFrom(QueryNuGet), CommonOptions.HelpOption(),
+                    "package",
-                            Create.Option("-v|--version",
+                    ".NET Add Package reference Command",
-                                   "Version for the package to be added.",
+                    Accept.ExactlyOneArgument()
-                                   Accept.ExactlyOneArgument
+                          .WithSuggestionsFrom(QueryNuGet), CommonOptions.HelpOption(),
-                                       .With(name: "VERSION")),
+                    Create.Option("-v|--version",
-                            Create.Option("-f|--framework",
+                                  "Version for the package to be added.",
-                                   "Add reference only when targetting a specific framework",
+                                  Accept.ExactlyOneArgument()
-                                   Accept.ExactlyOneArgument
+                                        .With(name: "VERSION")
-                                       .With(name: "FRAMEWORK")),
+                                        .ForwardAs(o => $"--version {o.Arguments.Single()}")),
-                            Create.Option("-n|--no-restore ",
+                    Create.Option("-f|--framework",
-                                   "Add reference without performing restore preview and compatibility check."),
+                                  "Add reference only when targetting a specific framework",
-                            Create.Option("-s|--source",
+                                  Accept.ExactlyOneArgument()
-                                   "Use specific NuGet package sources to use during the restore."),
+                                        .With(name: "FRAMEWORK")
-                            Create.Option("--package-directory",
+                                        .ForwardAs(o => $"--framework {o.Arguments.Single()}")),
-                                   "Restore the packages to this Directory .",
+                    Create.Option("-n|--no-restore ",
-                                   Accept.ExactlyOneArgument
+                                  "Add reference without performing restore preview and compatibility check."),
-                                       .With(name: "PACKAGE_DIRECTORY"))),
+                    Create.Option("-s|--source",
-                    Create.Command("reference",
+                                  "Use specific NuGet package sources to use during the restore.",
-                            "Command to add project to project reference",
+                                  Accept.ExactlyOneArgument()
-                            Accept.OneOrMoreArguments, CommonOptions.HelpOption(),
+                                        .With(name: "SOURCE")
-                            Create.Option("-f|--framework",
+                                        .ForwardAs(o => $"--source {o.Arguments.Single()}")),
-                                   "Add reference only when targetting a specific framework",
+                    Create.Option("--package-directory",
-                                   Accept.AnyOneOf(Suggest.TargetFrameworksFromProjectFile)
+                                  "Restore the packages to this Directory .",
-                                       .With(name: "FRAMEWORK"))), CommonOptions.HelpOption());
+                                  Accept.ExactlyOneArgument()
+                                        .With(name: "PACKAGE_DIRECTORY")
+                                        .ForwardAs(o => $"--package-directory {o.Arguments.Single()}"))),
+                Create.Command(
+                    "reference",
+                    "Command to add project to project reference",
+                    Accept.OneOrMoreArguments(), 
+                    CommonOptions.HelpOption(),
+                    Create.Option("-f|--framework",
+                                  "Add reference only when targetting a specific framework",
+                                  Accept.AnyOneOf(Suggest.TargetFrameworksFromProjectFile)
+                                        .With(name: "FRAMEWORK"))), 
+                CommonOptions.HelpOption());
 
         public static IEnumerable<string> QueryNuGet(string match)
         {

src/dotnet/commands/dotnet-add/Program.cs

@@ -3,7 +3,9 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.Add.PackageReference;
 using Microsoft.DotNet.Tools.Add.ProjectToProjectReference;
@@ -16,11 +18,22 @@ namespace Microsoft.DotNet.Tools.Add
         protected override string FullCommandNameLocalized => LocalizableStrings.NetAddCommand;
         protected override string ArgumentName => Constants.ProjectArgumentName;
         protected override string ArgumentDescriptionLocalized => CommonLocalizableStrings.ArgumentsProjectDescription;
-        internal override List<Func<DotNetSubCommandBase>> SubCommands =>
+
-            new List<Func<DotNetSubCommandBase>>
+        internal override Dictionary<string, Func<AppliedOption, CommandBase>> SubCommands =>
+            new Dictionary<string, Func<AppliedOption, CommandBase>>
             {
-                AddProjectToProjectReferenceCommand.Create,
+                {
-                AddPackageReferenceCommand.Create,
+                    "reference",
+                    add => new AddProjectToProjectReferenceCommand(
+                        add["reference"],
+                        add.Value<string>())
+                },
+                {
+                    "package",
+                    add => new AddPackageReferenceCommand(
+                        add["package"], 
+                        add.Value<string>())
+                }
             };
 
         public static int Run(string[] args)

src/dotnet/commands/dotnet-add/dotnet-add-package/Program.cs

@@ -1,105 +1,65 @@
 // 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 Microsoft.Build.Evaluation;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.Tools.Common;
 using Microsoft.DotNet.Tools.MSBuild;
 using Microsoft.DotNet.Tools.NuGet;
-using NuGet.Frameworks;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Text;
 
 namespace Microsoft.DotNet.Tools.Add.PackageReference
 {
-    internal class AddPackageReferenceCommand : DotNetSubCommandBase
+    internal class AddPackageReferenceCommand : CommandBase
     {
-        private CommandOption _versionOption;
+        private readonly AppliedOption _appliedCommand;
-        private CommandOption _frameworkOption;
-        private CommandOption _noRestoreOption;
-        private CommandOption _sourceOption;
-        private CommandOption _packageDirectoryOption;
-        private CommandArgument _packageNameArgument;
 
-        public static DotNetSubCommandBase Create()
+        private readonly string _packageId;
+        private readonly string _fileOrDirectory;
+
+        public AddPackageReferenceCommand(AppliedOption appliedCommand, string fileOrDirectory)
         {
-            var command = new AddPackageReferenceCommand
+            _appliedCommand = appliedCommand;
-            {
+            _fileOrDirectory = fileOrDirectory;
-                Name = "package",
+            _packageId = appliedCommand.Value<string>();
-                FullName = LocalizableStrings.AppFullName,
-                Description = LocalizableStrings.AppDescription,
-                HandleRemainingArguments = false
-            };
 
-            command.HelpOption("-h|--help");
             
-            command._packageNameArgument = command.Argument(
+            if ( string.IsNullOrWhiteSpace(_packageId) || _appliedCommand.Arguments.Count > 1) 
-                $"<{LocalizableStrings.CmdPackage}>",
-                LocalizableStrings.CmdPackageDescription,
-                multipleValues: false);
-
-            command._versionOption = command.Option(
-                $"-v|--version <{LocalizableStrings.CmdVersion}>",
-                description: LocalizableStrings.CmdVersionDescription,
-                optionType: CommandOptionType.SingleValue);
-
-            command._frameworkOption = command.Option(
-               $"-f|--framework <{LocalizableStrings.CmdFramework}>",
-               LocalizableStrings.CmdFrameworkDescription,
-               CommandOptionType.SingleValue);
-
-            command._noRestoreOption = command.Option(
-                "-n|--no-restore ",
-               LocalizableStrings.CmdNoRestoreDescription,
-               CommandOptionType.NoValue);
-
-            command._sourceOption = command.Option(
-                $"-s|--source <{LocalizableStrings.CmdSource}>",
-                LocalizableStrings.CmdSourceDescription,
-                CommandOptionType.SingleValue);
-
-            command._packageDirectoryOption = command.Option(
-                $"--package-directory <{LocalizableStrings.CmdPackageDirectory}>",
-                LocalizableStrings.CmdPackageDirectoryDescription,
-                CommandOptionType.SingleValue);
-
-            return command;
-        }
-
-        public override int Run(string fileOrDirectory)
-        {
-            if (_packageNameArgument.Values.Count != 1 || string.IsNullOrWhiteSpace(_packageNameArgument.Value) || RemainingArguments.Count > 0)
             { 
                 throw new GracefulException(LocalizableStrings.SpecifyExactlyOnePackageReference); 
             } 
+        }
 
+        public override int Execute()
+        {
             var projectFilePath = string.Empty;
 
-            if (!File.Exists(fileOrDirectory))
+            if (!File.Exists(_fileOrDirectory))
             {
-                projectFilePath = MsbuildProject.GetProjectFileFromDirectory(fileOrDirectory).FullName;
+                projectFilePath = MsbuildProject.GetProjectFileFromDirectory(_fileOrDirectory).FullName;
             }
             else
             {
-                projectFilePath = fileOrDirectory;
+                projectFilePath = _fileOrDirectory;
             }
 
             var tempDgFilePath = string.Empty;
 
-            if (!_noRestoreOption.HasValue())
+            if (!_appliedCommand.HasOption("no-restore"))
             {
                 // Create a Dependency Graph file for the project
                 tempDgFilePath = Path.GetTempFileName();
                 GetProjectDependencyGraph(projectFilePath, tempDgFilePath);
             }
 
-            var result = NuGetCommand.Run(TransformArgs(_packageNameArgument.Value, tempDgFilePath, projectFilePath));
+            var result = NuGetCommand.Run(
+                TransformArgs(
+                    _packageId,
+                    tempDgFilePath,
+                    projectFilePath));
             DisposeTemporaryFile(tempDgFilePath);
 
             return result;
@@ -136,7 +96,8 @@ namespace Microsoft.DotNet.Tools.Add.PackageReference
 
         private string[] TransformArgs(string packageId, string tempDgFilePath, string projectFilePath)
         {
-            var args = new List<string>(){
+            var args = new List<string>
+            {
                 "package",
                 "add",
                 "--package",
@@ -145,27 +106,11 @@ namespace Microsoft.DotNet.Tools.Add.PackageReference
                 projectFilePath
             };
 
-            if (_versionOption.HasValue())
+            args.AddRange(_appliedCommand
-            {
+                .OptionValuesToBeForwarded()
-                args.Add("--version");
+                .SelectMany(a => a.Split(' ')));
-                args.Add(_versionOption.Value());
+
-            }
+            if (_appliedCommand.HasOption("no-restore"))
-            if (_sourceOption.HasValue())
-            {
-                args.Add("--source");
-                args.Add(_sourceOption.Value());
-            }
-            if (_frameworkOption.HasValue())
-            {
-                args.Add("--framework");
-                args.Add(_frameworkOption.Value());
-            }
-            if (_packageDirectoryOption.HasValue())
-            {
-                args.Add("--package-directory");
-                args.Add(_packageDirectoryOption.Value());
-            }
-            if (_noRestoreOption.HasValue())
             {
                 args.Add("--no-restore");
             }

src/dotnet/commands/dotnet-add/dotnet-add-reference/Program.cs

@@ -1,59 +1,46 @@
 // 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;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
 using Microsoft.Build.Evaluation;
 using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.Common;
 using NuGet.Frameworks;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
 
 namespace Microsoft.DotNet.Tools.Add.ProjectToProjectReference
 {
-    internal class AddProjectToProjectReferenceCommand : DotNetSubCommandBase
+    internal class AddProjectToProjectReferenceCommand : CommandBase
     {
-        private CommandOption _frameworkOption;
+        private readonly AppliedOption _appliedCommand;
+        private readonly string _fileOrDirectory;
 
-        public static DotNetSubCommandBase Create()
+        public AddProjectToProjectReferenceCommand(AppliedOption appliedCommand, string fileOrDirectory)
         {
-            var command = new AddProjectToProjectReferenceCommand()
+            if (appliedCommand == null)
             {
-                Name = "reference",
+                throw new ArgumentNullException(nameof(appliedCommand));
-                FullName = LocalizableStrings.AppFullName,
+            }
-                Description = LocalizableStrings.AppDescription,
+            _appliedCommand = appliedCommand;
-                HandleRemainingArguments = true,
+            _fileOrDirectory = fileOrDirectory;
-                ArgumentSeparatorHelpText = LocalizableStrings.AppHelpText,
-            };
-
-            command.HelpOption("-h|--help");
-
-            command._frameworkOption = command.Option(
-               $"-f|--framework <{CommonLocalizableStrings.CmdFramework}>",
-               LocalizableStrings.CmdFrameworkDescription,
-               CommandOptionType.SingleValue);
-
-            return command;
         }
 
-        public override int Run(string fileOrDirectory)
+        public override int Execute()
         {
             var projects = new ProjectCollection();
-            MsbuildProject msbuildProj = MsbuildProject.FromFileOrDirectory(projects, fileOrDirectory);
+            MsbuildProject msbuildProj = MsbuildProject.FromFileOrDirectory(projects, _fileOrDirectory);
 
-            if (RemainingArguments.Count == 0)
+            var frameworkString = _appliedCommand["framework"].Value<string>();
-            {
-                throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneReferenceToAdd);
-            }
 
-            string frameworkString = _frameworkOption.Value();
+            PathUtility.EnsureAllPathsExist(_appliedCommand.Arguments, CommonLocalizableStrings.ReferenceDoesNotExist);
-            PathUtility.EnsureAllPathsExist(RemainingArguments, CommonLocalizableStrings.ReferenceDoesNotExist);
+            List<MsbuildProject> refs = _appliedCommand.Arguments
-            List<MsbuildProject> refs = RemainingArguments
+                                                       .Select((r) => MsbuildProject.FromFile(projects, r))
-                .Select((r) => MsbuildProject.FromFile(projects, r))
+                                                       .ToList();
-                .ToList();
 
             if (frameworkString == null)
             {
@@ -64,8 +51,8 @@ namespace Microsoft.DotNet.Tools.Add.ProjectToProjectReference
                         if (!@ref.CanWorkOnFramework(tfm))
                         {
                             Reporter.Error.Write(GetProjectNotCompatibleWithFrameworksDisplayString(
-                                    @ref,
+                                                     @ref,
-                                    msbuildProj.GetTargetFrameworks().Select((fx) => fx.GetShortFolderName())));
+                                                     msbuildProj.GetTargetFrameworks().Select((fx) => fx.GetShortFolderName())));
                             return 1;
                         }
                     }
@@ -77,9 +64,9 @@ namespace Microsoft.DotNet.Tools.Add.ProjectToProjectReference
                 if (!msbuildProj.IsTargetingFramework(framework))
                 {
                     Reporter.Error.WriteLine(string.Format(
-                        CommonLocalizableStrings.ProjectDoesNotTargetFramework,
+                                                 CommonLocalizableStrings.ProjectDoesNotTargetFramework,
-                        msbuildProj.ProjectRootElement.FullPath,
+                                                 msbuildProj.ProjectRootElement.FullPath,
-                        frameworkString));
+                                                 frameworkString));
                     return 1;
                 }
 
@@ -88,18 +75,19 @@ namespace Microsoft.DotNet.Tools.Add.ProjectToProjectReference
                     if (!@ref.CanWorkOnFramework(framework))
                     {
                         Reporter.Error.Write(GetProjectNotCompatibleWithFrameworksDisplayString(
-                            @ref,
+                                                 @ref,
-                            new string[] { frameworkString }));
+                                                 new string[] { frameworkString }));
                         return 1;
                     }
                 }
             }
 
-            var relativePathReferences = RemainingArguments.Select((r) =>
+            var relativePathReferences = _appliedCommand.Arguments.Select((r) =>
-                PathUtility.GetRelativePath(msbuildProj.ProjectDirectory, Path.GetFullPath(r))).ToList();
+                                                                              PathUtility.GetRelativePath(msbuildProj.ProjectDirectory, Path.GetFullPath(r)))
+                                                        .ToList();
 
             int numberOfAddedReferences = msbuildProj.AddProjectToProjectReferences(
-                _frameworkOption.Value(),
+                frameworkString,
                 relativePathReferences);
 
             if (numberOfAddedReferences != 0)

src/dotnet/commands/dotnet-build/BuildCommandParser.cs

@@ -13,12 +13,11 @@ namespace Microsoft.DotNet.Cli
             Create.Command(
                 "build",
                 LocalizableStrings.AppFullName,
-                Accept.ZeroOrMoreArguments,
                 CommonOptions.HelpOption(),
                 Create.Option(
                     "-o|--output",
                     LocalizableStrings.OutputOptionDescription,
-                    Accept.ExactlyOneArgument
+                    Accept.ExactlyOneArgument()
                           .With(name: LocalizableStrings.OutputOptionName)
                           .ForwardAs(o => $"/p:OutputPath={o.Arguments.Single()}")),
                 CommonOptions.FrameworkOption(),
@@ -31,7 +30,7 @@ namespace Microsoft.DotNet.Cli
                 Create.Option(
                     "--no-dependencies",
                     LocalizableStrings.NoDependenciesOptionDescription,
-                    Accept.NoArguments
+                    Accept.NoArguments()
                           .ForwardAs("/p:BuildProjectReferences=false")),
                 CommonOptions.VerbosityOption());
     }

src/dotnet/commands/dotnet-clean/CleanCommandParser.cs

@@ -17,7 +17,7 @@ namespace Microsoft.DotNet.Cli
                 CommonOptions.HelpOption(),
                 Create.Option("-o|--output", 
                               LocalizableStrings.CmdOutputDirDescription,
-                              Accept.ExactlyOneArgument
+                                         Accept.ExactlyOneArgument()
                         .With(name: LocalizableStrings.CmdOutputDir)
                         .ForwardAs(o => $"/p:OutputPath={o.Arguments.Single()}")),
                 CommonOptions.FrameworkOption(),

src/dotnet/commands/dotnet-complete/CompleteCommandParser.cs

@@ -11,10 +11,11 @@ namespace Microsoft.DotNet.Cli
         public static Command Complete() =>
             Create.Command(
                 "complete", "",
-                Accept.ExactlyOneArgument
+                Accept.ExactlyOneArgument()
                       .With(name: "path"),
                 Create.Option("--position", "",
-                              Accept.ExactlyOneArgument
+                              Accept.ExactlyOneArgument()
-                                    .With(name: "command")));
+                                    .With(name: "command")
+                                    .MaterializeAs(o => int.Parse(o.Arguments.Single()))));
     }
 }

src/dotnet/commands/dotnet-list/ListCommandParser.cs

@@ -10,14 +10,14 @@ namespace Microsoft.DotNet.Cli
         public static Command List() =>
             Create.Command("list",
                            ".NET List Command",
-                           Accept.ZeroOrOneArgument
+                           Accept.ZeroOrOneArgument()
                                  .With(name: "PROJECT",
                                        description:
                                        "The project file to operate on. If a file is not specified, the command will search the current directory for one.")
                                  .DefaultToCurrentDirectory(),
                            CommonOptions.HelpOption(),
                            Create.Command("reference", "Command to list project to project references",
-                                          Accept.ExactlyOneArgument
+                                          Accept.ExactlyOneArgument()
                                                 .With(name: "PROJECT",
                                                       description:
                                                       "The project file to operate on. If a file is not specified, the command will search the current directory for one."),

src/dotnet/commands/dotnet-list/Program.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.List.ProjectToProjectReferences;
 
@@ -15,10 +16,11 @@ namespace Microsoft.DotNet.Tools.List
         protected override string FullCommandNameLocalized => LocalizableStrings.NetListCommand;
         protected override string ArgumentName => Constants.ProjectArgumentName;
         protected override string ArgumentDescriptionLocalized => CommonLocalizableStrings.ArgumentsProjectDescription;
-        internal override List<Func<DotNetSubCommandBase>> SubCommands =>
+
-            new List<Func<DotNetSubCommandBase>>
+        internal override Dictionary<string, Func<AppliedOption, CommandBase>> SubCommands =>
+            new Dictionary<string, Func<AppliedOption, CommandBase>>
             {
-                ListProjectToProjectReferencesCommand.Create,
+                { "list", o => new ListProjectToProjectReferencesCommand(o) }
             };
 
         public static int Run(string[] args)

src/dotnet/commands/dotnet-list/dotnet-list-reference/Program.cs

@@ -1,40 +1,40 @@
 // 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;
+using System.Linq;
 using Microsoft.Build.Evaluation;
 using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
-using System.Linq;
 
 namespace Microsoft.DotNet.Tools.List.ProjectToProjectReferences
 {
-    internal class ListProjectToProjectReferencesCommand : DotNetSubCommandBase
+    internal class ListProjectToProjectReferencesCommand : CommandBase
     {
-        public static DotNetSubCommandBase Create()
+        private readonly string _fileOrDirectory;
+
+        public ListProjectToProjectReferencesCommand(AppliedOption appliedCommand)
         {
-            var command = new ListProjectToProjectReferencesCommand()
+            if (appliedCommand == null)
             {
-                Name = "reference",
+                throw new ArgumentNullException(nameof(appliedCommand));
-                FullName = LocalizableStrings.AppFullName,
+            }
-                Description = LocalizableStrings.AppDescription,
-            };
 
-            command.HelpOption("-h|--help");
+            _fileOrDirectory = appliedCommand.Arguments.Single();
-
-            return command;
         }
 
-        public override int Run(string fileOrDirectory)
+        public override int Execute()
         {
-            var msbuildProj = MsbuildProject.FromFileOrDirectory(new ProjectCollection(), fileOrDirectory);
+            var msbuildProj = MsbuildProject.FromFileOrDirectory(new ProjectCollection(), _fileOrDirectory);
 
             var p2ps = msbuildProj.GetProjectToProjectReferences();
             if (!p2ps.Any())
             {
                 Reporter.Output.WriteLine(string.Format(
-                    CommonLocalizableStrings.NoReferencesFound,
+                                              CommonLocalizableStrings.NoReferencesFound,
-                    CommonLocalizableStrings.P2P,
+                                              CommonLocalizableStrings.P2P,
-                    fileOrDirectory));
+                                              _fileOrDirectory));
                 return 0;
             }
 

src/dotnet/commands/dotnet-new/NewCommandParser.cs

@@ -11,7 +11,7 @@ namespace Microsoft.DotNet.Cli
             Create.Command("new",
                            "Initialize .NET projects.",
                            Accept
-                               .ExactlyOneArgument
+                               .ExactlyOneArgument()
                                .WithSuggestionsFrom(
                                    "console",
                                    "classlib",

src/dotnet/commands/dotnet-nuget/NuGetCommandParser.cs

@@ -15,11 +15,11 @@ namespace Microsoft.DotNet.Cli
                                          "Show version information"),
                            Create.Option("-v|--verbosity",
                                          "The verbosity of logging to use. Allowed values: Debug, Verbose, Information, Minimal, Warning, Error.",
-                                         Accept.ExactlyOneArgument
+                                         Accept.ExactlyOneArgument()
                                                .With(name: "verbosity")),
                            Create.Command("delete",
                                           "Deletes a package from the server.",
-                                          Accept.ExactlyOneArgument
+                                          Accept.ExactlyOneArgument()
                                                 .With(name: "root",
                                                       description: "The Package Id and version."),
                                           CommonOptions.HelpOption(),
@@ -27,13 +27,13 @@ namespace Microsoft.DotNet.Cli
                                                         "Forces the application to run using an invariant, English-based culture."),
                                           Create.Option("-s|--source",
                                                         "Specifies the server URL",
-                                                        Accept.ExactlyOneArgument
+                                                        Accept.ExactlyOneArgument()
                                                               .With(name: "source")),
                                           Create.Option("--non-interactive",
                                                         "Do not prompt for user input or confirmations."),
                                           Create.Option("-k|--api-key",
                                                         "The API key for the server.",
-                                                        Accept.ExactlyOneArgument
+                                                        Accept.ExactlyOneArgument()
                                                               .With(name: "apiKey"))),
                            Create.Command("locals",
                                           "Clears or lists local NuGet resources such as http requests cache, packages cache or machine-wide global packages folder.",
@@ -54,21 +54,21 @@ namespace Microsoft.DotNet.Cli
                                                         "Forces the application to run using an invariant, English-based culture."),
                                           Create.Option("-s|--source",
                                                         "Specifies the server URL",
-                                                        Accept.ExactlyOneArgument
+                                                        Accept.ExactlyOneArgument()
                                                               .With(name: "source")),
                                           Create.Option("-ss|--symbol-source",
                                                         "Specifies the symbol server URL. If not specified, nuget.smbsrc.net is used when pushing to nuget.org.",
-                                                        Accept.ExactlyOneArgument
+                                                        Accept.ExactlyOneArgument()
                                                               .With(name: "source")),
                                           Create.Option("-t|--timeout",
                                                         "Specifies the timeout for pushing to a server in seconds. Defaults to 300 seconds (5 minutes).",
-                                                        Accept.ExactlyOneArgument
+                                                        Accept.ExactlyOneArgument()
                                                               .With(name: "timeout")),
                                           Create.Option("-k|--api-key", "The API key for the server.",
-                                                        Accept.ExactlyOneArgument
+                                                        Accept.ExactlyOneArgument()
                                                               .With(name: "apiKey")),
                                           Create.Option("-sk|--symbol-api-key", "The API key for the symbol server.",
-                                                        Accept.ExactlyOneArgument
+                                                        Accept.ExactlyOneArgument()
                                                               .With(name: "apiKey")),
                                           Create.Option("-d|--disable-buffering",
                                                         "Disable buffering when pushing to an HTTP(S) server to decrease memory usage."),

src/dotnet/commands/dotnet-pack/PackCommandParser.cs

@@ -18,7 +18,7 @@ namespace Microsoft.DotNet.Cli
                 Create.Option(
                     "-o|--output",
                     LocalizableStrings.CmdOutputDirDescription,
-                    Accept.ExactlyOneArgument
+                                         Accept.ExactlyOneArgument()
                         .With(name: LocalizableStrings.CmdOutputDir)
                         .ForwardAs(o => $"/p:PackageOutputPath={o.Arguments.Single()}")),
                 Create.Option("--no-build",

src/dotnet/commands/dotnet-publish/PublishCommandParser.cs

@@ -13,22 +13,20 @@ namespace Microsoft.DotNet.Cli
             Create.Command(
                 "publish",
                 LocalizableStrings.AppFullName,
-                Accept.ZeroOrMoreArguments,
+                Accept.ZeroOrMoreArguments(),
                 CommonOptions.HelpOption(),
                 CommonOptions.FrameworkOption(),
                 CommonOptions.RuntimeOption(),
                 Create.Option(
                     "-o|--output",
                     LocalizableStrings.OutputOptionDescription,
-                    Accept.ExactlyOneArgument
+                              Accept.ExactlyOneArgument()
                         .With(name: LocalizableStrings.OutputOption)
                         .ForwardAs(o => $"/p:PublishDir={o.Arguments.Single()}")),
                 CommonOptions.ConfigurationOption(),
-                CommonOptions.VersionSuffixOption(),
-                Create.Option(
                     "--filter", 
                     LocalizableStrings.FilterProjOptionDescription,
-                    Accept.ExactlyOneArgument
+                              Accept.ExactlyOneArgument()
                         .With(name: LocalizableStrings.FilterProjOption)
                         .ForwardAs(o => $"/p:FilterProjectFiles={o.Arguments.Single()}")),
                 CommonOptions.VerbosityOption());

src/dotnet/commands/dotnet-remove/Program.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.Remove.PackageReference;
 using Microsoft.DotNet.Tools.Remove.ProjectToProjectReference;
@@ -16,11 +17,12 @@ namespace Microsoft.DotNet.Tools.Remove
         protected override string FullCommandNameLocalized => LocalizableStrings.NetRemoveCommand;
         protected override string ArgumentName => Constants.ProjectArgumentName;
         protected override string ArgumentDescriptionLocalized => CommonLocalizableStrings.ArgumentsProjectDescription;
-        internal override List<Func<DotNetSubCommandBase>> SubCommands =>
+
-            new List<Func<DotNetSubCommandBase>>
+        internal override Dictionary<string, Func<AppliedOption, CommandBase>> SubCommands =>
+            new Dictionary<string, Func<AppliedOption, CommandBase>>
             {
-                RemoveProjectToProjectReferenceCommand.Create,
+                { "reference", o => new RemoveProjectToProjectReferenceCommand(o) },
-                RemovePackageReferenceCommand.Create
+                { "package", o => new RemovePackageReferenceCommand(o) }
             };
 
         public static int Run(string[] args)

src/dotnet/commands/dotnet-remove/RemoveCommandParser.cs

@@ -10,7 +10,7 @@ namespace Microsoft.DotNet.Cli
         public static Command Remove() =>
             Create.Command("remove",
                            ".NET Remove Command",
-                           Accept.ZeroOrOneArgument
+                           Accept.ZeroOrOneArgument()
                                  .With(name: "PROJECT")
                                  .DefaultToCurrentDirectory(),
                            CommonOptions.HelpOption(),
@@ -23,7 +23,7 @@ namespace Microsoft.DotNet.Cli
                                           CommonOptions.HelpOption(),
                                           Create.Option("-f|--framework",
                                                         "Remove reference only when targetting a specific framework",
-                                                        Accept.ExactlyOneArgument
+                                                        Accept.ExactlyOneArgument()
                                                               .With(name: "FRAMEWORK"))));
     }
 }

src/dotnet/commands/dotnet-remove/dotnet-remove-package/Program.cs

@@ -1,61 +1,50 @@
 // 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 Microsoft.Build.Evaluation;
+using System;
+using System.IO;
+using System.Linq;
 using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.Tools.Common;
-using Microsoft.DotNet.Tools.MSBuild;
 using Microsoft.DotNet.Tools.NuGet;
-using NuGet.Frameworks;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Text;
 
 namespace Microsoft.DotNet.Tools.Remove.PackageReference
 {
-    internal class RemovePackageReferenceCommand : DotNetSubCommandBase
+    internal class RemovePackageReferenceCommand : CommandBase
     {
+        private readonly AppliedOption _appliedCommand;
+        private readonly string _fileOrDirectory;
 
-        public static DotNetSubCommandBase Create()
+        public RemovePackageReferenceCommand(AppliedOption appliedCommand)
         {
-            var command = new RemovePackageReferenceCommand
+            if (appliedCommand == null)
             {
-                Name = "package",
+                throw new ArgumentNullException(nameof(appliedCommand));
-                FullName = LocalizableStrings.AppFullName,
+            }
-                Description = LocalizableStrings.AppDescription,
+            if (_appliedCommand.Arguments.Count != 1)
-                HandleRemainingArguments = true,
-                ArgumentSeparatorHelpText = LocalizableStrings.AppHelpText,
-            };
-
-            command.HelpOption("-h|--help");
-
-            return command;
-        }
-
-        public override int Run(string fileOrDirectory)
-        {
-            if (RemainingArguments.Count != 1)
             {
                 throw new GracefulException(LocalizableStrings.SpecifyExactlyOnePackageReference);
             }
 
+            _appliedCommand = appliedCommand;
+            _fileOrDirectory = appliedCommand.Arguments.Single();
+        }
+
+        public override int Execute()
+        {
             var projectFilePath = string.Empty;
 
-            if (!File.Exists(fileOrDirectory))
+            if (!File.Exists(_fileOrDirectory))
             {
-                projectFilePath = MsbuildProject.GetProjectFileFromDirectory(fileOrDirectory).FullName;
+                projectFilePath = MsbuildProject.GetProjectFileFromDirectory(_fileOrDirectory).FullName;
             }
             else
             {
-                projectFilePath = fileOrDirectory;
+                projectFilePath = _fileOrDirectory;
             }
 
-            var packageToRemove = RemainingArguments.First();
+            var packageToRemove = _appliedCommand.Arguments.Single();
             var result = NuGetCommand.Run(TransformArgs(packageToRemove, projectFilePath));
 
             return result;
@@ -63,7 +52,8 @@ namespace Microsoft.DotNet.Tools.Remove.PackageReference
 
         private string[] TransformArgs(string packageId, string projectFilePath)
         {
-            return new string[]{
+            return new string[]
+            {
                 "package",
                 "remove",
                 "--package",

src/dotnet/commands/dotnet-remove/dotnet-remove-reference/Program.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;
+using System.Linq;
 using Microsoft.Build.Evaluation;
 using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.CommandLine;
@@ -8,42 +10,34 @@ using Microsoft.DotNet.Cli.Utils;
 
 namespace Microsoft.DotNet.Tools.Remove.ProjectToProjectReference
 {
-    internal class RemoveProjectToProjectReferenceCommand : DotNetSubCommandBase
+    internal class RemoveProjectToProjectReferenceCommand : CommandBase
     {
-        private CommandOption _frameworkOption;
+        private readonly AppliedOption _appliedCommand;
+        private readonly string _fileOrDirectory;
 
-        public static DotNetSubCommandBase Create()
+        public RemoveProjectToProjectReferenceCommand(AppliedOption appliedCommand)
         {
-            var command = new RemoveProjectToProjectReferenceCommand()
+            if (appliedCommand == null)
             {
-                Name = "reference",
+                throw new ArgumentNullException(nameof(appliedCommand));
-                FullName = LocalizableStrings.AppFullName,
+            }
-                Description = LocalizableStrings.AppDescription,
-                HandleRemainingArguments = true,
-                ArgumentSeparatorHelpText = LocalizableStrings.AppHelpText,
-            };
 
-            command.HelpOption("-h|--help");
+            if (_appliedCommand.Arguments.Count == 0)
-
-            command._frameworkOption = command.Option(
-               $"-f|--framework <{CommonLocalizableStrings.CmdFramework}>",
-               LocalizableStrings.CmdFrameworkDescription,
-               CommandOptionType.SingleValue);
-
-            return command;
-        }
-
-        public override int Run(string fileOrDirectory)
-        {
-            var msbuildProj = MsbuildProject.FromFileOrDirectory(new ProjectCollection(), fileOrDirectory);
-            if (RemainingArguments.Count == 0)
             {
                 throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneReferenceToRemove);
             }
 
+            _appliedCommand = appliedCommand;
+            _fileOrDirectory = appliedCommand.Arguments.Single();
+        }
+
+        public override int Execute()
+        {
+            var msbuildProj = MsbuildProject.FromFileOrDirectory(new ProjectCollection(), _fileOrDirectory);
+
             int numberOfRemovedReferences = msbuildProj.RemoveProjectToProjectReferences(
-                _frameworkOption.Value(),
+                _appliedCommand["framework"].Value<string>(),
-                RemainingArguments);
+                _appliedCommand.Arguments);
 
             if (numberOfRemovedReferences != 0)
             {

src/dotnet/commands/dotnet-restore/RestoreCommandParser.cs

@@ -13,52 +13,52 @@ namespace Microsoft.DotNet.Cli
             Create.Command(
                 "restore",
                 LocalizableStrings.AppFullName,
-                Accept.ZeroOrMoreArguments,
+                Accept.ZeroOrMoreArguments(),
                 CommonOptions.HelpOption(),
                 Create.Option(
                     "-s|--source",
                     LocalizableStrings.CmdSourceOptionDescription,
-                    Accept.OneOrMoreArguments
+                    Accept.OneOrMoreArguments()
                           .With(name: LocalizableStrings.CmdSourceOption)
                           .ForwardAs(o => $"/p:RestoreSources={string.Join("%3B", o.Arguments)}")),
                 Create.Option(
                     "-r|--runtime",
                     LocalizableStrings.CmdRuntimeOptionDescription,
-                    Accept.OneOrMoreArguments
+                    Accept.OneOrMoreArguments()
                           .WithSuggestionsFrom(_ => Suggest.RunTimesFromProjectFile())
                           .With(name: LocalizableStrings.CmdRuntimeOption)
                           .ForwardAs(o => $"/p:RuntimeIdentifiers={string.Join("%3B", o.Arguments)}")),
                 Create.Option(
                     "--packages",
                     LocalizableStrings.CmdPackagesOptionDescription,
-                    Accept.ExactlyOneArgument
+                    Accept.ExactlyOneArgument()
                           .With(name: LocalizableStrings.CmdPackagesOption)
                           .ForwardAs(o => $"/p:RestorePackagesPath={o.Arguments.Single()}")),
                 Create.Option(
                     "--disable-parallel",
                     LocalizableStrings.CmdDisableParallelOptionDescription,
-                    Accept.NoArguments
+                    Accept.NoArguments()
                           .ForwardAs("/p:RestoreDisableParallel=true")),
                 Create.Option(
                     "--configfile",
                     LocalizableStrings.CmdConfigFileOptionDescription,
-                    Accept.ExactlyOneArgument
+                    Accept.ExactlyOneArgument()
                           .With(name: LocalizableStrings.CmdConfigFileOption)
                           .ForwardAs(o => $"/p:RestoreConfigFile={o.Arguments.Single()}")),
                 Create.Option(
                     "--no-cache",
                     LocalizableStrings.CmdNoCacheOptionDescription,
-                    Accept.NoArguments
+                    Accept.NoArguments()
                           .ForwardAs("/p:RestoreNoCache=true")),
                 Create.Option(
                     "--ignore-failed-sources",
                     LocalizableStrings.CmdIgnoreFailedSourcesOptionDescription,
-                    Accept.NoArguments
+                    Accept.NoArguments()
                           .ForwardAs("/p:RestoreIgnoreFailedSources=true")),
                 Create.Option(
                     "--no-dependencies",
                     LocalizableStrings.CmdNoDependenciesOptionDescription,
-                    Accept.NoArguments
+                    Accept.NoArguments()
                           .ForwardAs("/p:RestoreRecursive=false")),
                 CommonOptions.VerbosityOption());
     }

src/dotnet/commands/dotnet-run/RunCommandParser.cs

@@ -14,7 +14,7 @@ namespace Microsoft.DotNet.Cli
             Create.Command(
                 "run",
                 LocalizableStrings.AppFullName,
-                Accept.ZeroOrMoreArguments
+                Accept.ZeroOrMoreArguments()
                     .MaterializeAs(o =>
                     {
                         return new RunCommand()
@@ -31,6 +31,6 @@ namespace Microsoft.DotNet.Cli
                 Create.Option(
                     "-p|--project",
                     LocalizableStrings.CommandOptionProjectDescription,
-                    Accept.ExactlyOneArgument));
+                    Accept.ExactlyOneArgument()));
     }
 }

src/dotnet/commands/dotnet-sln/Program.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.Sln.Add;
 using Microsoft.DotNet.Tools.Sln.List;
@@ -17,12 +18,13 @@ namespace Microsoft.DotNet.Tools.Sln
         protected override string FullCommandNameLocalized => LocalizableStrings.AppFullName;
         protected override string ArgumentName => Constants.SolutionArgumentName;
         protected override string ArgumentDescriptionLocalized => CommonLocalizableStrings.ArgumentsSolutionDescription;
-        internal override List<Func<DotNetSubCommandBase>> SubCommands =>
+
-            new List<Func<DotNetSubCommandBase>>
+        internal override Dictionary<string, Func<AppliedOption, CommandBase>> SubCommands =>
+            new Dictionary<string, Func<AppliedOption, CommandBase>>
             {
-                AddProjectToSolutionCommand.Create,
+                { "add", o => new AddProjectToSolutionCommand(o) },
-                ListProjectsInSolutionCommand.Create,
+                { "list", o => new ListProjectsInSolutionCommand(o) },
-                RemoveProjectFromSolutionCommand.Create
+                { "remove", o => new RemoveProjectFromSolutionCommand(o) }
             };
 
         public static int Run(string[] args)

src/dotnet/commands/dotnet-sln/SlnCommandParser.cs

@@ -13,12 +13,12 @@ namespace Microsoft.DotNet.Cli
                            CommonOptions.HelpOption(),
                            Create.Command("add",
                                           ".NET Add project(s) to a solution file Command",
-                                          Accept.ExactlyOneArgument
+                                          Accept.ExactlyOneArgument()
                                                 .With(name: "SLN_FILE"),
                                           CommonOptions.HelpOption()),
                            Create.Command("list",
                                           "List all projects in the solution.",
-                                          Accept.ExactlyOneArgument
+                                          Accept.ExactlyOneArgument()
                                                 .With(name: "SLN_FILE"),
                                           CommonOptions.HelpOption()),
                            Create.Command("remove",

src/dotnet/commands/dotnet-sln/add/Program.cs

@@ -1,49 +1,50 @@
 // 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;
+using System.IO;
+using System.Linq;
 using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Sln.Internal;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.Common;
-using Microsoft.DotNet.Tools.Sln;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 
 namespace Microsoft.DotNet.Tools.Sln.Add
 {
-    internal class AddProjectToSolutionCommand : DotNetSubCommandBase
+    internal class AddProjectToSolutionCommand : CommandBase
     {
-        public static DotNetSubCommandBase Create()
+        private readonly AppliedOption _appliedCommand;
+        private readonly string _fileOrDirectory;
+
+        public AddProjectToSolutionCommand(AppliedOption appliedCommand)
         {
-            var command = new AddProjectToSolutionCommand()
+            if (appliedCommand == null)
             {
-                Name = "add",
+                throw new ArgumentNullException(nameof(appliedCommand));
-                FullName = LocalizableStrings.AddAppFullName,
+            }
-                Description = LocalizableStrings.AddSubcommandHelpText,
+            _appliedCommand = appliedCommand;
-                HandleRemainingArguments = true,
-                ArgumentSeparatorHelpText = LocalizableStrings.AddSubcommandHelpText,
-            };
 
-            command.HelpOption("-h|--help");
+            _fileOrDirectory = appliedCommand.Arguments.Single();
-
-            return command;
         }
 
-        public override int Run(string fileOrDirectory)
+        public override int Execute()
         {
-            SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(fileOrDirectory);
+            SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(_fileOrDirectory);
 
-            if (RemainingArguments.Count == 0)
+            if (_appliedCommand.Arguments.Count == 0)
             {
                 throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneProjectToAdd);
             }
 
-            PathUtility.EnsureAllPathsExist(RemainingArguments, CommonLocalizableStrings.ProjectDoesNotExist);
+            PathUtility.EnsureAllPathsExist(_appliedCommand.Arguments, CommonLocalizableStrings.ProjectDoesNotExist);
-            var fullProjectPaths = RemainingArguments.Select((p) => Path.GetFullPath(p)).ToList();
+
+            var fullProjectPaths = _appliedCommand.Arguments
+                                                  .Select(Path.GetFullPath)
+                                                  .ToList();
+
+            var preAddProjectCount = slnFile.Projects.Count;
 
-            int preAddProjectCount = slnFile.Projects.Count;
             foreach (var fullProjectPath in fullProjectPaths)
             {
                 slnFile.AddProject(fullProjectPath);

src/dotnet/commands/dotnet-sln/list/Program.cs

@@ -1,33 +1,32 @@
 // 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;
+using System.Linq;
 using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Sln.Internal;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.Common;
-using Microsoft.DotNet.Tools.Sln;
 
 namespace Microsoft.DotNet.Tools.Sln.List
 {
-    internal class ListProjectsInSolutionCommand : DotNetSubCommandBase
+    internal class ListProjectsInSolutionCommand : CommandBase
     {
-        public static DotNetSubCommandBase Create()
+        private readonly string _fileOrDirectory;
+
+        public ListProjectsInSolutionCommand(AppliedOption appliedCommand)
         {
-            var command = new ListProjectsInSolutionCommand()
+            if (appliedCommand == null)
             {
-                Name = "list",
+                throw new ArgumentNullException(nameof(appliedCommand));
-                FullName = LocalizableStrings.ListAppFullName,
+            }
-                Description = LocalizableStrings.ListSubcommandHelpText,
+            _fileOrDirectory = appliedCommand.Arguments.Single();
-            };
-
-            command.HelpOption("-h|--help");
-
-            return command;
         }
 
-        public override int Run(string fileOrDirectory)
+        public override int Execute()
         {
-            SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(fileOrDirectory);
+            SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(_fileOrDirectory);
             if (slnFile.Projects.Count == 0)
             {
                 Reporter.Output.WriteLine(CommonLocalizableStrings.NoProjectsFound);

src/dotnet/commands/dotnet-sln/remove/Program.cs

@@ -1,49 +1,47 @@
 // 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;
+using System.IO;
+using System.Linq;
 using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Sln.Internal;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.Common;
-using Microsoft.DotNet.Tools.Sln;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 
 namespace Microsoft.DotNet.Tools.Sln.Remove
 {
-    internal class RemoveProjectFromSolutionCommand : DotNetSubCommandBase
+    internal class RemoveProjectFromSolutionCommand : CommandBase
     {
-        public static DotNetSubCommandBase Create()
+        private readonly AppliedOption _appliedCommand;
+        private readonly string _fileOrDirectory;
+
+        public RemoveProjectFromSolutionCommand(AppliedOption appliedCommand)
         {
-            var command = new RemoveProjectFromSolutionCommand()
+            if (appliedCommand == null)
             {
-                Name = "remove",
+                throw new ArgumentNullException(nameof(appliedCommand));
-                FullName = LocalizableStrings.RemoveAppFullName,
+            }
-                Description = LocalizableStrings.RemoveSubcommandHelpText,
-                HandleRemainingArguments = true,
-                ArgumentSeparatorHelpText = LocalizableStrings.RemoveSubcommandHelpText,
-            };
 
-            command.HelpOption("-h|--help");
+            if (_appliedCommand.Arguments.Count == 0)
-
-            return command;
-        }
-
-        public override int Run(string fileOrDirectory)
-        {
-            SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(fileOrDirectory);
-
-            if (RemainingArguments.Count == 0)
             {
                 throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneProjectToRemove);
             }
 
-            var relativeProjectPaths = RemainingArguments.Select((p) =>
+            _appliedCommand = appliedCommand;
-                PathUtility.GetRelativePath(
+            _fileOrDirectory = appliedCommand.Arguments.Single();
-                    PathUtility.EnsureTrailingSlash(slnFile.BaseDirectory),
+        }
-                    Path.GetFullPath(p))).ToList();
+
+        public override int Execute()
+        {
+            SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(_fileOrDirectory);
+
+            var relativeProjectPaths = _appliedCommand.Arguments.Select(p =>
+                                                                            PathUtility.GetRelativePath(
+                                                                                PathUtility.EnsureTrailingSlash(slnFile.BaseDirectory),
+                                                                                Path.GetFullPath(p)))
+                                                      .ToList();
 
             bool slnChanged = false;
             foreach (var path in relativeProjectPaths)

src/dotnet/commands/dotnet-test/TestCommandParser.cs

@@ -16,7 +16,7 @@ namespace Microsoft.DotNet.Cli
                   Create.Option(
                         "-s|--settings",
                         LocalizableStrings.CmdSettingsDescription,
-                        Accept.ExactlyOneArgument
+                                         Accept.ExactlyOneArgument()
                               .With(name: LocalizableStrings.CmdSettingsFile)
                               .ForwardAs(o => $"/p:VSTestSetting={o.Arguments.Single()}")),
                   Create.Option(
@@ -27,19 +27,19 @@ namespace Microsoft.DotNet.Cli
                   Create.Option(
                         "--filter",
                         LocalizableStrings.CmdTestCaseFilterDescription,
-                        Accept.ExactlyOneArgument
+                                         Accept.ExactlyOneArgument()
                               .With(name: LocalizableStrings.CmdTestCaseFilterExpression)
                               .ForwardAs(o => $"/p:VSTestTestCaseFilter={o.Arguments.Single()}")),
                   Create.Option(
                         "-a|--test-adapter-path",
                         LocalizableStrings.CmdTestAdapterPathDescription,
-                        Accept.ExactlyOneArgument
+                                         Accept.ExactlyOneArgument()
                               .With(name: LocalizableStrings.CmdTestAdapterPath)
                               .ForwardAs(o => $"/p:VSTestTestAdapterPath={o.Arguments.Single()}")),
                   Create.Option(
                         "-l|--logger",
                         LocalizableStrings.CmdLoggerDescription,
-                        Accept.ExactlyOneArgument
+                                         Accept.ExactlyOneArgument()
                               .With(name: LocalizableStrings.CmdLoggerOption)
                               .ForwardAs(o => 
                                     {
@@ -52,13 +52,13 @@ namespace Microsoft.DotNet.Cli
                   Create.Option(
                         "-o|--output",
                         LocalizableStrings.CmdOutputDescription,
-                        Accept.ExactlyOneArgument
+                                         Accept.ExactlyOneArgument()
                               .With(name: LocalizableStrings.CmdOutputDir)
                               .ForwardAs(o => $"/p:OutputPath={o.Arguments.Single()}")),
                   Create.Option(
                         "-d|--diag",
                         LocalizableStrings.CmdPathTologFileDescription,
-                        Accept.ExactlyOneArgument
+                                         Accept.ExactlyOneArgument()
                               .With(name: LocalizableStrings.CmdPathToLogFile)
                               .ForwardAs(o => $"/p:VSTestDiag={o.Arguments.Single()}")),
                   Create.Option(

src/dotnet/dotnet.csproj

@@ -40,7 +40,7 @@
     <PackageReference Include="Microsoft.Win32.Registry" Version="4.3.0" />
     <PackageReference Include="Microsoft.Build" Version="$(CLI_MSBuild_Version)" />
     <PackageReference Include="Microsoft.DotNet.PlatformAbstractions" Version="$(PlatformAbstractionsVersion)" />
-    <PackageReference Include="Microsoft.DotNet.Cli.CommandLine" Version="0.1.0-alpha-80" />
+    <PackageReference Include="Microsoft.DotNet.Cli.CommandLine" Version="0.1.0-alpha-84" />
     <PackageReference Include="Microsoft.TemplateEngine.Abstractions" Version="$(TemplateEngineVersion)" />
     <PackageReference Include="Microsoft.TemplateEngine.Cli" Version="$(TemplateEngineVersion)" />
     <PackageReference Include="Microsoft.TemplateEngine.Orchestrator.RunnableProjects" Version="$(TemplateEngineVersion)" />

test/dotnet.Tests/ParserTests/ArgumentForwardingExtensionsTests.cs

@@ -18,10 +18,10 @@ namespace Microsoft.DotNet.Tests.ParserTests
         {
             var command = Command("the-command", "",
                                   Option("-o|--one", "",
-                                         ZeroOrOneArgument
+                                         ZeroOrOneArgument()
                                              .ForwardAs(o => $"/i:{o.Arguments.Single()}")),
                                   Option("-t|--two", "",
-                                         NoArguments
+                                         NoArguments()
                                              .ForwardAs("/s:true")));
 
             var result = command.Parse("the-command -t -o 123");
@@ -37,7 +37,7 @@ namespace Microsoft.DotNet.Tests.ParserTests
         {
             var command = Command("the-command", "",
                                   Option("-x", "",
-                                         ZeroOrMoreArguments
+                                         ZeroOrMoreArguments()
                                              .ForwardAs(o => $"/x:{string.Join("&", o.Arguments)}")));
 
             var result = command.Parse("the-command -x one -x two");
@@ -53,7 +53,7 @@ namespace Microsoft.DotNet.Tests.ParserTests
         {
             var command = Command("the-command", "",
                                   Option("-x", "",
-                                         ZeroOrMoreArguments
+                                         ZeroOrMoreArguments()
                                              .Forward()));
 
             var result = command.Parse("the-command -x one");

test/dotnet.Tests/dotnet.Tests.csproj

@@ -42,6 +42,6 @@
     <PackageReference Include="xunit" Version="2.2.0-beta4-build3444" />
     <PackageReference Include="xunit.netcore.extensions" Version="1.0.0-prerelease-00206" />
     <PackageReference Include="Microsoft.DotNet.PlatformAbstractions" Version="$(PlatformAbstractionsVersion)" />
-    <PackageReference Include="Microsoft.DotNet.Cli.CommandLine" Version="0.1.0-alpha-80" />
+    <PackageReference Include="Microsoft.DotNet.Cli.CommandLine" Version="0.1.0-alpha-84" />
   </ItemGroup>
 </Project>