Remove support for slash options

Supporting slashes seems problematic for cross-platform usage. When
running on non-Windows platform, we'd have to disallow it anyways in
order to avoid parsing issues.

On Windows there is already enough prior-art to justify dropping support
for it. For instance, PowerShell doesn't slashes either. Also, Windows
users have started to use many ports of Unix tools, such as Git, that
also don't support slashes.

The only downside of removing support for slashes is that existing tools
that support slashes can't start to depend on this library. Until we've
anybody asking for it, it seems better to start clean.

Author: Immo Landwerth

src/System.CommandLine/README.md

@@ -101,44 +101,29 @@ They can be *bundled* together, such as
 
     $ tool -xdf
 
-You can also use a slash, e.g.
-
-    $ tool /x /d /f
-
-However, slashes don't support bundling. For example, the following isn't
-recognized:
-
-    # This is not equivalent to -xdf
-    $ tool /xdf
+Please note that slashes aren't supported.
 
 ### Keyword options
 
 Keyword options are delimited by two dashes, such as:
 
     $ tool --verbose
 
-Alternatively, you can use a slash:
-
-    $ tool /verbose
-
-Using two dashes avoids any ambiguity with bundled forms -- which is why
-slashes don't support bundling.
-
 ### Option arguments
 
 Both, the single letter form, as well as the long forms, support arguments.
 Arguments must be separated by either a space, an equal sign or a colon:
 
     # All three forms are identical:
-    $ tool /out result.exe
-    $ tool /out=result.exe
-    $ tool /out:result.exe
+    $ tool --out result.exe
+    $ tool --out=result.exe
+    $ tool --out:result.exe
 
 Multiple spaces are allowed as well:
 
-    $ tool /out  result.exe
-    $ tool /out =   result.exe
-    $ tool /out : result.exe
+    $ tool --out  result.exe
+    $ tool --out =   result.exe
+    $ tool --out : result.exe
 
 This even works when combined with bundling, but in that case only the last
 option can have an argument. So this:
@@ -278,7 +263,7 @@ will be an argument or the first parameter.
 Both, options and parameters, support the notion of lists. For example, consider
 the C# compiler CSC:
 
-    $ csc /r:mscorlib.dll /r:system.dll source1.cs source2.cs /out:hello.exe /t:exe
+    $ csc -r:mscorlib.dll -r:system.dll source1.cs source2.cs -out:hello.exe -t:exe
 
 You would define the options and parameters as follows:
 

src/System.CommandLine/src/System/CommandLine/ArgumentLexer.cs

@@ -160,8 +160,7 @@ private static void ExpandOptionBundle(IList<ArgumentToken> receiver, int index)
         private static bool TryExtractOption(string text, out string modifier, out string remainder)
         {
             return TryExtractOption(text, @"--", out modifier, out remainder) ||
-                   TryExtractOption(text, @"-", out modifier, out remainder) ||
-                   TryExtractOption(text, @"/", out modifier, out remainder);
+                   TryExtractOption(text, @"-", out modifier, out remainder);
         }
 
         private static bool TryExtractOption(string text, string prefix, out string modifier, out string remainder)

src/System.CommandLine/tests/System/CommandLine/Tests/ArgumentLexerTests.cs

@@ -27,12 +27,11 @@ public void Lex_Parameters()
         [Fact]
         public void Lex_Options()
         {
-            var text = "-a /b --c";
+            var text = "-a --b";
             var actual = Lex(text);
             var expected = new[] {
                 new ArgumentToken("-", "a", null),
-                new ArgumentToken("/", "b", null),
-                new ArgumentToken("--", "c", null)
+                new ArgumentToken("--", "b", null)
             };
 
             Assert.Equal(expected, actual);
@@ -41,11 +40,11 @@ public void Lex_Options()
         [Fact]
         public void Lex_OptionArguments()
         {
-            var text = "-a:va /b=vb --c vc";
+            var text = "-a:va -b=vb --c vc";
             var actual = Lex(text);
             var expected = new[] {
                 new ArgumentToken("-", "a", "va"),
-                new ArgumentToken("/", "b", "vb"),
+                new ArgumentToken("-", "b", "vb"),
                 new ArgumentToken("--", "c", null),
                 new ArgumentToken(null, "vc", null)
             };
@@ -68,12 +67,12 @@ public void Lex_ExpandsBundles()
         }
 
         [Fact]
-        public void Lex_ExpandsBundles_UnlessUsingSlash()
+        public void Lex_ExpandsBundles_UnlessUsingDashDash()
         {
-            var text = "/xdf";
+            var text = "--xdf";
             var actual = Lex(text);
             var expected = new[] {
-                new ArgumentToken("/", "xdf", null)
+                new ArgumentToken("--", "xdf", null)
             };
 
             Assert.Equal(expected, actual);
@@ -87,7 +86,7 @@ public void Lex_ExpandsReponseFile()
             {
                 "-xdf",
                 "--out:out.exe",
-                "/responseFileReader",
+                "--responseFileReader",
                 @"C:\Reference Assemblies\system.dll"
             };
 
@@ -100,7 +99,7 @@ public void Lex_ExpandsReponseFile()
                 new ArgumentToken("-", "d", null),
                 new ArgumentToken("-", "f", null),
                 new ArgumentToken("--", "out", "out.exe"),
-                new ArgumentToken("/", "responseFileReader", null),
+                new ArgumentToken("--", "responseFileReader", null),
                 new ArgumentToken(null, @"C:\Reference Assemblies\system.dll", null),
                 new ArgumentToken("--", "after", null)
             };

src/System.CommandLine/tests/System/CommandLine/Tests/ArgumentSyntaxTests.cs

@@ -466,22 +466,20 @@ public void Option_Usage_Error_RequiresValue(string commandLine)
             Assert.Equal("option -a requires a value", ex.Message);
         }
 
-        [Theory]
-        [InlineData("/")]
-        [InlineData("--")]
-        public void Option_Usage_Error_Flag_Bundle_ViaModifier(string modifier)
+        [Fact]
+        public void Option_Usage_Error_Flag_Bundle_ViaDashDash()
         {
             var ex = Assert.Throws<ArgumentSyntaxException>(() =>
             {
-                Parse(modifier + "opq", syntax =>
+                Parse("--opq", syntax =>
                 {
                     syntax.DefineOption("o", false);
                     syntax.DefineOption("p", false);
                     syntax.DefineOption("q", false);
                 });
             });
 
-            Assert.Equal("invalid option " + modifier + "opq", ex.Message);
+            Assert.Equal("invalid option --opq", ex.Message);
         }
 
         [Theory]
@@ -499,7 +497,6 @@ public void Option_Usage_ViaNonLetterName(string name)
         }
 
         [Theory]
-        [InlineData("/")]
         [InlineData("-")]
         [InlineData("--")]
         public void Option_Usage_ViaModifer(string modifier)