move SymbolResult.Token to OptionResult and CommandResult

jonsequitur · jonsequitur · commit eaec1c54e8a4 · 2020-01-18T13:34:48.000-08:00
diff --git a/src/System.CommandLine.Tests/Binding/TypeConversionTests.cs b/src/System.CommandLine.Tests/Binding/TypeConversionTests.cs
@@ -261,14 +261,14 @@ public void When_argument_cannot_be_parsed_as_the_specified_type_then_getting_va
             {
                 new Option(new[] { "-o", "--one" })
                 {
-                    Argument = new Argument<int>((ArgumentResult symbol, out int value) =>
+                    Argument = new Argument<int>((ArgumentResult argumentResult, out int value) =>
                     {
-                        if (int.TryParse(symbol.Tokens.Select(t => t.Value).Single(), out value))
+                        if (int.TryParse(argumentResult.Tokens.Select(t => t.Value).Single(), out value))
                         {
                             return true;
                         }
 
-                        symbol.ErrorMessage = $"'{symbol.Token.Value}' is not an integer";
+                        argumentResult.ErrorMessage = $"'{argumentResult.Tokens.Single().Value}' is not an integer";
 
                         return false;
                     }),
@@ -984,10 +984,10 @@ public async Task Custom_argument_converter_is_only_called_once()
             callCount.Should().Be(1);
             handlerWasCalled.Should().BeTrue();
 
-            bool TryConvertInt(SymbolResult result, out int value)
+            bool TryConvertInt(ArgumentResult result, out int value)
             {
                 callCount++;
-                return int.TryParse(result.Token.Value, out value);
+                return int.TryParse(result.Tokens.Single().Value, out value);
             }
 
             void Run(int value) => handlerWasCalled = true;
diff --git a/src/System.CommandLine/ArgumentArity.cs b/src/System.CommandLine/ArgumentArity.cs
@@ -59,7 +59,6 @@ internal static FailedArgumentConversionArityResult Validate(
                     throw new ArgumentException("");
             }
 
-
             var tokenCount = argumentResult?.Tokens.Count ?? 0;
 
             if (tokenCount < minimumNumberOfValues)
@@ -87,7 +86,7 @@ internal static FailedArgumentConversionArityResult Validate(
                     return new TooManyArgumentsConversionResult(
                         argument,
                         symbolResult.ValidationMessages.ExpectsFewerArguments(
-                            symbolResult.Token,
+                            symbolResult.Tokens.Last(),
                             tokenCount,
                             maximumNumberOfValues));
                 }
diff --git a/src/System.CommandLine/Parsing/ArgumentResult.cs b/src/System.CommandLine/Parsing/ArgumentResult.cs
@@ -10,8 +10,7 @@ public class ArgumentResult : SymbolResult
     {
         internal ArgumentResult(
             IArgument argument,
-            Token token,
-            SymbolResult parent) : base(argument, token, parent)
+            SymbolResult parent) : base(argument, parent)
         {
             Argument = argument;
         }
@@ -81,7 +80,7 @@ internal ArgumentConversionResult Convert(
                 }
                 else 
                 {
-                    return ArgumentConversionResult.Failure(argument, this.ErrorMessage ?? $"Invalid: {parentResult.Token} {string.Join(" ", parentResult.Tokens.Select(t => t.Value))}");
+                    return ArgumentConversionResult.Failure(argument, ErrorMessage ?? $"Invalid: {parentResult.Token()} {string.Join(" ", parentResult.Tokens.Select(t => t.Value))}");
                 }
             }
 
diff --git a/src/System.CommandLine/Parsing/CommandResult.cs b/src/System.CommandLine/Parsing/CommandResult.cs
@@ -16,10 +16,11 @@ internal CommandResult(
             Token token,
             CommandResult parent = null) :
             base(command ?? throw new ArgumentNullException(nameof(command)),
-                 token ?? throw new ArgumentNullException(nameof(token)),
                  parent)
         {
             Command = command;
+
+            Token = token ?? throw new ArgumentNullException(nameof(token));
         }
 
         public ICommand Command { get; }
@@ -31,6 +32,9 @@ public OptionResult OptionResult(string alias)
             return Children[alias] as OptionResult;
         }
 
+        public Token Token { get; }
+
+
         internal virtual RootCommandResult Root => (Parent as CommandResult)?.Root;
 
         internal bool TryGetValueForArgument(
diff --git a/src/System.CommandLine/Parsing/CommandResultExtensions.cs b/src/System.CommandLine/Parsing/CommandResultExtensions.cs
@@ -26,19 +26,21 @@ public static T GetArgumentValueOrDefault<T>(
         }
 
         internal static bool TryGetValueForOption(
-            this CommandResult commandResult, 
-            IValueDescriptor valueDescriptor, 
+            this CommandResult commandResult,
+            IValueDescriptor valueDescriptor,
             out object value)
         {
-            var children = commandResult.Children
-                                        .Where(o => valueDescriptor.ValueName.IsMatch(o.Symbol))
-                                        .ToArray();
+            var children = commandResult
+                           .Children
+                           .Where(o => valueDescriptor.ValueName.IsMatch(o.Symbol))
+                           .ToArray();
 
             SymbolResult symbolResult = null;
 
             if (children.Length > 1)
             {
-                throw new ArgumentException($"Ambiguous match while trying to bind parameter {valueDescriptor.ValueName} among: {String.Join(",", children.Select(o => o.Symbol.Name))}");
+                throw new ArgumentException(
+                    $"Ambiguous match while trying to bind parameter {valueDescriptor.ValueName} among: {string.Join(",", children.Select(o => o.Symbol.Name))}");
             }
 
             if (children.Length == 1)
diff --git a/src/System.CommandLine/Parsing/OptionResult.cs b/src/System.CommandLine/Parsing/OptionResult.cs
@@ -15,16 +15,18 @@ internal OptionResult(
             Token token,
             CommandResult parent = null) :
             base(option ?? throw new ArgumentNullException(nameof(option)),
-                 token ?? throw new ArgumentNullException(nameof(token)),
                  parent)
         {
             Option = option;
+            Token = token ?? throw new ArgumentNullException(nameof(token));
         }
 
         public IOption Option { get; }
 
         public bool IsImplicit => Token is ImplicitToken;
 
+        public Token Token { get; }
+
         private protected override int RemainingArgumentCapacity
         {
             get
diff --git a/src/System.CommandLine/Parsing/ParseResultExtensions.cs b/src/System.CommandLine/Parsing/ParseResultExtensions.cs
@@ -165,7 +165,7 @@ argumentResult.Argument is Argument argument &&
             else
             {
                 builder.Append("[ ");
-                builder.Append(symbolResult.Token.Value);
+                builder.Append(symbolResult.Token().Value);
 
                 foreach (var child in symbolResult.Children)
                 {
diff --git a/src/System.CommandLine/Parsing/ParseResultVisitor.cs b/src/System.CommandLine/Parsing/ParseResultVisitor.cs
@@ -89,9 +89,8 @@ protected override void VisitCommandArgumentNode(
                 argumentResult =
                     new ArgumentResult(
                         argumentNode.Argument,
-                        argumentNode.Token,
                         commandResult);
-
+                
                 commandResult.Children.Add(argumentResult);
             }
 
@@ -131,7 +130,6 @@ protected override void VisitOptionArgumentNode(
                 argumentResult =
                     new ArgumentResult(
                         argumentNode.Argument,
-                        argumentNode.Token,
                         optionResult);
                 optionResult.Children.Add(argumentResult);
             }
@@ -158,7 +156,7 @@ protected override void Stop(SyntaxNode node)
 
             ValidateCommandResult();
 
-            foreach (var result in _innermostCommandResult.Children)
+            foreach (var result in _innermostCommandResult.Children.ToArray())
             {
                 switch (result)
                 {
@@ -331,7 +329,6 @@ private void PopulateDefaultValues()
                                 optionResult.Children.Add(
                                     new ArgumentResult(
                                         option.Argument,
-                                        token,
                                         optionResult));
 
                                 commandResult.Children.Add(optionResult);
@@ -346,11 +343,11 @@ private void PopulateDefaultValues()
 
                                 var argumentResult = new ArgumentResult(
                                     argument,
-                                    implicitToken,
                                     commandResult);
 
                                 commandResult.Children.Add(argumentResult);
                                 commandResult.AddToken(implicitToken);
+                                argumentResult.AddToken(implicitToken);
                                 _rootCommandResult.AddToSymbolMap(argumentResult);
 
                                 break;
@@ -364,7 +361,6 @@ private void PopulateDefaultValues()
                         o.Children.Add(
                             new ArgumentResult(
                                 o.Option.Argument,
-                                new ImplicitToken(true, TokenType.Argument),
                                 o));
                     }
                 }
@@ -381,7 +377,6 @@ private void PopulateDefaultValues()
                 _unparsedTokens,
                 _unmatchedTokens,
                 _errors,
-                _rawInput
-            );
+                _rawInput);
     }
 }
diff --git a/src/System.CommandLine/Parsing/SymbolResult.cs b/src/System.CommandLine/Parsing/SymbolResult.cs
@@ -14,13 +14,10 @@ public abstract class SymbolResult
 
         private protected SymbolResult(
             ISymbol symbol, 
-            Token token, 
             SymbolResult parent = null)
         {
             Symbol = symbol ?? throw new ArgumentNullException(nameof(symbol));
 
-            Token = token ?? throw new ArgumentNullException(nameof(token));
-
             Parent = parent;
         }
 
@@ -32,8 +29,6 @@ private protected SymbolResult(
 
         public ISymbol Symbol { get; }
 
-        public Token Token { get; }
-
         public IReadOnlyList<Token> Tokens => _tokens;
 
         internal bool IsArgumentLimitReached => RemainingArgumentCapacity <= 0;
@@ -84,15 +79,16 @@ internal bool UseDefaultValueFor(IArgument argument)
             }
 
             if (this is CommandResult &&
-                Children.ResultFor(argument)?.Token is ImplicitToken)
+                Children.ResultFor(argument)?.Tokens is {} tokens && 
+                tokens.All(t => t is ImplicitToken))
             {
                 return true;
             }
 
             return _defaultArgumentValues.ContainsKey(argument);
         }
 
-        public override string ToString() => $"{GetType().Name}: {Token}";
+        public override string ToString() => $"{GetType().Name}: {this.Token()}";
 
         internal ParseError UnrecognizedArgumentError(Argument argument)
         {
diff --git a/src/System.CommandLine/Parsing/SymbolResultExtensions.cs b/src/System.CommandLine/Parsing/SymbolResultExtensions.cs
@@ -23,5 +23,18 @@ internal static IEnumerable<SymbolResult> AllSymbolResults(this SymbolResult sym
                 yield return item;
             }
         }
+
+        internal static Token Token(this SymbolResult symbolResult)
+        {
+            switch (symbolResult)
+            {
+                case CommandResult commandResult:
+                    return commandResult.Token;
+                case OptionResult optionResult:
+                    return optionResult.Token;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(symbolResult));
+            }
+        }
     }
 }
diff --git a/src/System.CommandLine/ValidationMessages.cs b/src/System.CommandLine/ValidationMessages.cs
@@ -16,15 +16,17 @@ protected ValidationMessages()
         {
         }
 
-        public virtual string ExpectsOneArgument(SymbolResult symbolResult) =>
-            symbolResult is CommandResult
-                ? $"Command '{symbolResult.Token.Value}' expects a single argument but {symbolResult.Tokens.Count} were provided."
-                : $"Option '{symbolResult.Token.Value}' expects a single argument but {symbolResult.Tokens.Count} were provided.";
+        public virtual string ExpectsOneArgument(SymbolResult symbolResult)
+        {
+            return symbolResult is CommandResult
+                       ? $"Command '{symbolResult.Token().Value}' expects a single argument but {symbolResult.Tokens.Count} were provided."
+                       : $"Option '{symbolResult.Token().Value}' expects a single argument but {symbolResult.Tokens.Count} were provided.";
+        }
 
         public virtual string NoArgumentProvided(SymbolResult symbolResult) =>
             symbolResult is CommandResult
-                ? $"No argument was provided for Command '{symbolResult.Token.Value}'."
-                : $"No argument was provided for Option '{symbolResult.Token.Value}'.";
+                ? $"No argument was provided for Command '{symbolResult.Token().Value}'."
+                : $"No argument was provided for Option '{symbolResult.Token().Value}'.";
 
         public virtual string ExpectsFewerArguments(
             Token token, 
@@ -48,8 +50,8 @@ public virtual string InvalidCharactersInPath(char invalidChar) =>
 
         public virtual string RequiredArgumentMissing(SymbolResult symbolResult) =>
             symbolResult is CommandResult
-                ? $"Required argument missing for command: {symbolResult.Token.Value}"
-                : $"Required argument missing for option: {symbolResult.Token.Value}";
+                ? $"Required argument missing for command: {symbolResult.Token().Value}"
+                : $"Required argument missing for option: {symbolResult.Token().Value}";
 
         public virtual string RequiredCommandWasNotProvided() =>
             "Required command was not provided.";

Original file line number	Diff line number	Diff line change
`@@ -261,14 +261,14 @@ public void When_argument_cannot_be_parsed_as_the_specified_type_then_getting_va`
`261`	`261`	`{`
`262`	`262`	`new Option(new[] { "-o", "--one" })`
`263`	`263`	`{`
`264`		`- Argument = new Argument<int>((ArgumentResult symbol, out int value) =>`
	`264`	`+ Argument = new Argument<int>((ArgumentResult argumentResult, out int value) =>`
`265`	`265`	`{`
`266`		`- if (int.TryParse(symbol.Tokens.Select(t => t.Value).Single(), out value))`
	`266`	`+ if (int.TryParse(argumentResult.Tokens.Select(t => t.Value).Single(), out value))`
`267`	`267`	`{`
`268`	`268`	`return true;`
`269`	`269`	`}`
`270`	`270`
`271`		`- symbol.ErrorMessage = $"'{symbol.Token.Value}' is not an integer";`
	`271`	`+ argumentResult.ErrorMessage = $"'{argumentResult.Tokens.Single().Value}' is not an integer";`
`272`	`272`
`273`	`273`	`return false;`
`274`	`274`	`}),`
`@@ -984,10 +984,10 @@ public async Task Custom_argument_converter_is_only_called_once()`
`984`	`984`	`callCount.Should().Be(1);`
`985`	`985`	`handlerWasCalled.Should().BeTrue();`
`986`	`986`
`987`		`- bool TryConvertInt(SymbolResult result, out int value)`
	`987`	`+ bool TryConvertInt(ArgumentResult result, out int value)`
`988`	`988`	`{`
`989`	`989`	`callCount++;`
`990`		`- return int.TryParse(result.Token.Value, out value);`
	`990`	`+ return int.TryParse(result.Tokens.Single().Value, out value);`
`991`	`991`	`}`
`992`	`992`
`993`	`993`	`void Run(int value) => handlerWasCalled = true;`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,6 @@ internal static FailedArgumentConversionArityResult Validate(`
`59`	`59`	`throw new ArgumentException("");`
`60`	`60`	`}`
`61`	`61`
`62`		`-`
`63`	`62`	`var tokenCount = argumentResult?.Tokens.Count ?? 0;`
`64`	`63`
`65`	`64`	`if (tokenCount < minimumNumberOfValues)`
`@@ -87,7 +86,7 @@ internal static FailedArgumentConversionArityResult Validate(`
`87`	`86`	`return new TooManyArgumentsConversionResult(`
`88`	`87`	`argument,`
`89`	`88`	`symbolResult.ValidationMessages.ExpectsFewerArguments(`
`90`		`- symbolResult.Token,`
	`89`	`+ symbolResult.Tokens.Last(),`
`91`	`90`	`tokenCount,`
`92`	`91`	`maximumNumberOfValues));`
`93`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,7 @@ public class ArgumentResult : SymbolResult`
`10`	`10`	`{`
`11`	`11`	`internal ArgumentResult(`
`12`	`12`	`IArgument argument,`
`13`		`- Token token,`
`14`		`- SymbolResult parent) : base(argument, token, parent)`
	`13`	`+ SymbolResult parent) : base(argument, parent)`
`15`	`14`	`{`
`16`	`15`	`Argument = argument;`
`17`	`16`	`}`
`@@ -81,7 +80,7 @@ internal ArgumentConversionResult Convert(`
`81`	`80`	`}`
`82`	`81`	`else`
`83`	`82`	`{`
`84`		`- return ArgumentConversionResult.Failure(argument, this.ErrorMessage ?? $"Invalid: {parentResult.Token} {string.Join(" ", parentResult.Tokens.Select(t => t.Value))}");`
	`83`	`+ return ArgumentConversionResult.Failure(argument, ErrorMessage ?? $"Invalid: {parentResult.Token()} {string.Join(" ", parentResult.Tokens.Select(t => t.Value))}");`
`85`	`84`	`}`
`86`	`85`	`}`
`87`	`86`
Original file line number	Diff line number	Diff line change
`@@ -16,10 +16,11 @@ internal CommandResult(`
`16`	`16`	`Token token,`
`17`	`17`	`CommandResult parent = null) :`
`18`	`18`	`base(command ?? throw new ArgumentNullException(nameof(command)),`
`19`		`- token ?? throw new ArgumentNullException(nameof(token)),`
`20`	`19`	`parent)`
`21`	`20`	`{`
`22`	`21`	`Command = command;`
	`22`	`+`
	`23`	`+ Token = token ?? throw new ArgumentNullException(nameof(token));`
`23`	`24`	`}`
`24`	`25`
`25`	`26`	`public ICommand Command { get; }`
`@@ -31,6 +32,9 @@ public OptionResult OptionResult(string alias)`
`31`	`32`	`return Children[alias] as OptionResult;`
`32`	`33`	`}`
`33`	`34`
	`35`	`+ public Token Token { get; }`
	`36`	`+`
	`37`	`+`
`34`	`38`	`internal virtual RootCommandResult Root => (Parent as CommandResult)?.Root;`
`35`	`39`
`36`	`40`	`internal bool TryGetValueForArgument(`
Original file line number	Diff line number	Diff line change
`@@ -26,19 +26,21 @@ public static T GetArgumentValueOrDefault<T>(`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`internal static bool TryGetValueForOption(`
`29`		`- this CommandResult commandResult,`
`30`		`- IValueDescriptor valueDescriptor,`
	`29`	`+ this CommandResult commandResult,`
	`30`	`+ IValueDescriptor valueDescriptor,`
`31`	`31`	`out object value)`
`32`	`32`	`{`
`33`		`- var children = commandResult.Children`
`34`		`- .Where(o => valueDescriptor.ValueName.IsMatch(o.Symbol))`
`35`		`- .ToArray();`
	`33`	`+ var children = commandResult`
	`34`	`+ .Children`
	`35`	`+ .Where(o => valueDescriptor.ValueName.IsMatch(o.Symbol))`
	`36`	`+ .ToArray();`
`36`	`37`
`37`	`38`	`SymbolResult symbolResult = null;`
`38`	`39`
`39`	`40`	`if (children.Length > 1)`
`40`	`41`	`{`
`41`		`- throw new ArgumentException($"Ambiguous match while trying to bind parameter {valueDescriptor.ValueName} among: {String.Join(",", children.Select(o => o.Symbol.Name))}");`
	`42`	`+ throw new ArgumentException(`
	`43`	`+ $"Ambiguous match while trying to bind parameter {valueDescriptor.ValueName} among: {string.Join(",", children.Select(o => o.Symbol.Name))}");`
`42`	`44`	`}`
`43`	`45`
`44`	`46`	`if (children.Length == 1)`
Original file line number	Diff line number	Diff line change
`@@ -15,16 +15,18 @@ internal OptionResult(`
`15`	`15`	`Token token,`
`16`	`16`	`CommandResult parent = null) :`
`17`	`17`	`base(option ?? throw new ArgumentNullException(nameof(option)),`
`18`		`- token ?? throw new ArgumentNullException(nameof(token)),`
`19`	`18`	`parent)`
`20`	`19`	`{`
`21`	`20`	`Option = option;`
	`21`	`+ Token = token ?? throw new ArgumentNullException(nameof(token));`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`public IOption Option { get; }`
`25`	`25`
`26`	`26`	`public bool IsImplicit => Token is ImplicitToken;`
`27`	`27`
	`28`	`+ public Token Token { get; }`
	`29`	`+`
`28`	`30`	`private protected override int RemainingArgumentCapacity`
`29`	`31`	`{`
`30`	`32`	`get`
Original file line number	Diff line number	Diff line change
`@@ -165,7 +165,7 @@ argumentResult.Argument is Argument argument &&`
`165`	`165`	`else`
`166`	`166`	`{`
`167`	`167`	`builder.Append("[ ");`
`168`		`- builder.Append(symbolResult.Token.Value);`
	`168`	`+ builder.Append(symbolResult.Token().Value);`
`169`	`169`
`170`	`170`	`foreach (var child in symbolResult.Children)`
`171`	`171`	`{`
Original file line number	Diff line number	Diff line change
`@@ -14,13 +14,10 @@ public abstract class SymbolResult`
`14`	`14`
`15`	`15`	`private protected SymbolResult(`
`16`	`16`	`ISymbol symbol,`
`17`		`- Token token,`
`18`	`17`	`SymbolResult parent = null)`
`19`	`18`	`{`
`20`	`19`	`Symbol = symbol ?? throw new ArgumentNullException(nameof(symbol));`
`21`	`20`
`22`		`- Token = token ?? throw new ArgumentNullException(nameof(token));`
`23`		`-`
`24`	`21`	`Parent = parent;`
`25`	`22`	`}`
`26`	`23`
`@@ -32,8 +29,6 @@ private protected SymbolResult(`
`32`	`29`
`33`	`30`	`public ISymbol Symbol { get; }`
`34`	`31`
`35`		`- public Token Token { get; }`
`36`		`-`
`37`	`32`	`public IReadOnlyList<Token> Tokens => _tokens;`
`38`	`33`
`39`	`34`	`internal bool IsArgumentLimitReached => RemainingArgumentCapacity <= 0;`
`@@ -84,15 +79,16 @@ internal bool UseDefaultValueFor(IArgument argument)`
`84`	`79`	`}`
`85`	`80`
`86`	`81`	`if (this is CommandResult &&`
`87`		`- Children.ResultFor(argument)?.Token is ImplicitToken)`
	`82`	`+ Children.ResultFor(argument)?.Tokens is {} tokens &&`
	`83`	`+ tokens.All(t => t is ImplicitToken))`
`88`	`84`	`{`
`89`	`85`	`return true;`
`90`	`86`	`}`
`91`	`87`
`92`	`88`	`return _defaultArgumentValues.ContainsKey(argument);`
`93`	`89`	`}`
`94`	`90`
`95`		`- public override string ToString() => $"{GetType().Name}: {Token}";`
	`91`	`+ public override string ToString() => $"{GetType().Name}: {this.Token()}";`
`96`	`92`
`97`	`93`	`internal ParseError UnrecognizedArgumentError(Argument argument)`
`98`	`94`	`{`
Original file line number	Diff line number	Diff line change
`@@ -23,5 +23,18 @@ internal static IEnumerable<SymbolResult> AllSymbolResults(this SymbolResult sym`
`23`	`23`	`yield return item;`
`24`	`24`	`}`
`25`	`25`	`}`
	`26`	`+`
	`27`	`+ internal static Token Token(this SymbolResult symbolResult)`
	`28`	`+ {`
	`29`	`+ switch (symbolResult)`
	`30`	`+ {`
	`31`	`+ case CommandResult commandResult:`
	`32`	`+ return commandResult.Token;`
	`33`	`+ case OptionResult optionResult:`
	`34`	`+ return optionResult.Token;`
	`35`	`+ default:`
	`36`	`+ throw new ArgumentOutOfRangeException(nameof(symbolResult));`
	`37`	`+ }`
	`38`	`+ }`
`26`	`39`	`}`
`27`	`40`	`}`