Suggest directive - first pass

drewburlingame · drewburlingame · commit af14e6d3bc2e · 2022-12-30T13:34:34.000Z
diff --git a/CommandDotNet.Tests/FeatureTests/SuggestDirective/SuggestDirectiveTests.cs b/CommandDotNet.Tests/FeatureTests/SuggestDirective/SuggestDirectiveTests.cs
@@ -0,0 +1,133 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using CommandDotNet.Parsing;
+using CommandDotNet.Tests.FeatureTests.Suggestions;
+using CommandDotNet.TestTools.Scenarios;
+using Xunit;
+using Xunit.Abstractions;
+using static System.Environment;
+
+namespace CommandDotNet.Tests.FeatureTests.SuggestDirective;
+
+public class SuggestDirectiveTests
+{
+    public SuggestDirectiveTests(ITestOutputHelper output)
+    {
+        Ambient.Output = output;
+    }
+    
+    /* Test list:
+     * - operands
+     *   - extra operand
+     * - spaces
+     *   - after argument
+     *   - after partial **
+     * - FileInfo
+     *   - file names
+     * - DirectoryInfo
+     *   - directory names
+     * - after argument separator
+     *   ? - how to know if after arg separator vs looking for options?
+     * - response files
+     *   - file names
+     *   - directory names
+     * - clubbed options
+     *
+     * - check position argument
+     *   ? - is this used commonly?  The tests in System.CommandLine all
+     *       seem to have the position as the end of the string.
+     *
+     * - check feature list for other considerations
+     */
+
+    [SuppressMessage("Usage", "xUnit1026:Theory methods should use all of their parameters")]
+
+    [Theory]
+    [InlineData(
+        "command - includes subcommands, options and next operand allowed values", 
+        "", "--togo/nClosed/nOpened/nOrder/nReserve")]
+    [InlineData("command - invalid name", "Blah", "")]
+    [InlineData("command - partial name", "Or", "Order")]
+    [InlineData("subcommand", "Order ", "--juices/n--water/nBreakfast/nDinner/nLunch")]
+    [InlineData("subcommand - not returned when not available", "Opened", "--togo")]
+    [InlineData("option - show allowed values", "Reserve --meal", "Breakfast/nDinner/nLunch")]
+    [InlineData("option - option prefix shows only options 1", "Order --", "--juices/n--water")]
+    [InlineData("option - option prefix shows only options 2", "Order -", "--juices/n--water")]
+    [InlineData("option - option prefix shows only options 3", "Order /", "/juices/n/water")]
+    [InlineData("option - does not show already provided option", "Order --water --", "--juices")]
+    [InlineData("option - does not show already provided option using short name", "Order -w --", "--juices")]
+    [InlineData("option - partial name", "Order --jui", "--juices")]
+    [InlineData("option - partial name with backslash", "Order /jui", "/juices")]
+    [InlineData("option - partial allowed value", "Reserve --meal Br", "Breakfast")]
+    [InlineData("option - trailing space", "Order --juices", "Apple/nBanana/nCherry")]
+    [InlineData("operand - partial allowed value", "Op", "Opened")]
+    [InlineData("typo before request for autocompletion 1", "Or --jui", "", 1)]
+    [InlineData("typo before request for autocompletion 2", "Reserv --meal Br", "", 1)]
+    [InlineData("typo before request for autocompletion 3", "Reserve --mea Br", "", 1)]
+    public void Suggest(string scenario, string input, string expected, int exitCode = 0)
+    {
+        new AppRunner<DinerApp>()
+            .UseSuggestDirective_Experimental()
+            .Verify(new Scenario
+            {
+                When = { Args = $"[suggest] {input}"},
+                Then =
+                {
+                    Output = NewLine == "/n" ? expected : expected.Replace("/n", NewLine),
+                    ExitCode = exitCode
+                }
+            });
+    }
+
+    [Fact]
+    public void Suggest_works_with_default_middleware()
+    {
+        var expected = "--togo/n--version/nClosed/nOpened/nOrder/nReserve";
+        new AppRunner<DinerApp>()
+            .UseDefaultMiddleware()
+            .UseCommandLogger()
+            .UseSuggestDirective_Experimental()
+            .Verify(new Scenario
+            {
+                When = { Args = "[suggest]"},
+                Then =
+                {
+                    Output = NewLine == "/n" ? expected : expected.Replace("/n", NewLine)
+                }
+            });
+    }
+
+    public class DinerApp
+    {
+        public enum Status{ Opened, Closed }
+        
+        public enum PartySize{one,two,three,four,five,six,seven,eight,nine,ten}
+        
+        public Task<int> Interceptor(InterceptorExecutionDelegate next, IConsole console, [Option] bool togo)
+        {
+            console.WriteLine("DinerApp.Interceptor");
+            return Task.FromResult(0);
+        }
+
+        [DefaultCommand]
+        public void Default(IConsole console, Status status)
+        {
+            console.WriteLine("DinerApp.Default");
+        }
+
+        public void Reserve(IConsole console,
+            [Operand] PartySize partySize, [Operand] string name,
+            [Operand] DateOnly date, [Operand] TimeOnly time, [Option] Meal meal)
+        {
+            console.WriteLine("DinerApp.Reserve");
+        }
+
+        public void Order(IConsole console,
+            [Operand] Meal meal, [Operand] Main main, [Operand] Vegetable vegetable, [Operand] Fruit fruit,
+            [Option('w')] bool water, [Option] Fruit juices)
+        {
+            console.WriteLine("DinerApp.Order");
+        }
+    }
+}
diff --git a/CommandDotNet.Tests/FeatureTests/Suggestions/CafeApp.cs b/CommandDotNet.Tests/FeatureTests/Suggestions/CafeApp.cs
@@ -5,18 +5,16 @@ namespace CommandDotNet.Tests.FeatureTests.Suggestions
 
     public enum Fruit { Apple, Banana, Cherry }
     public enum Vegetable { Asparagus, Broccoli, Carrot }
+    public enum Main { Chicken, Steak, Fish, Veggie}
     public enum Meal { Breakfast, Lunch, Dinner }
 
     public class CafeApp
     {
-        public void Eat(IConsole console,
+        public void Eat(
             [Operand] Meal meal,
             [Option] Vegetable vegetable,
             [Option] Fruit fruit)
         {
-            console.Out.WriteLine($"{nameof(meal)}     :{meal}");
-            console.Out.WriteLine($"{nameof(fruit)}    :{fruit}");
-            console.Out.WriteLine($"{nameof(vegetable)}:{vegetable}");
         }
     }
 }
diff --git a/CommandDotNet/AppRunnerConfigExtensions.cs b/CommandDotNet/AppRunnerConfigExtensions.cs
@@ -8,6 +8,7 @@
 using CommandDotNet.Diagnostics;
 using CommandDotNet.Execution;
 using CommandDotNet.Localization;
+using CommandDotNet.Parsing;
 using CommandDotNet.Parsing.Typos;
 using CommandDotNet.Prompts;
 using CommandDotNet.Tokens;
@@ -71,6 +72,9 @@ static void Register(bool exclude, string paramName, Action register)
                 ()=> appRunner.UseTypoSuggestions());
             return appRunner;
         }
+        
+        public static AppRunner UseAutoSuggest_Experimental(this AppRunner appRunner) => 
+            appRunner.UseSuggestDirective_Experimental();
 
         /// <summary>When an invalid arguments is entered, suggests context based alternatives</summary>
         public static AppRunner UseTypoSuggestions(this AppRunner appRunner, int maxSuggestionCount = 5)
diff --git a/CommandDotNet/Execution/MiddlewareSteps.cs b/CommandDotNet/Execution/MiddlewareSteps.cs
@@ -37,12 +37,20 @@ public static class DependencyResolver
         public static MiddlewareStep ParseInput { get; } =
             new(MiddlewareStages.ParseInput, 0);
 
+        public static class AutoSuggest
+        {
+            /// <summary>
+            /// Runs after <see cref="ParseInput"/> to suggest next possible argument or value
+            /// </summary>
+            public static MiddlewareStep Directive { get; } = ParseInput + 1000;
+        }
+        
         /// <summary>
         /// Runs after <see cref="ParseInput"/> to respond to parse errors
         /// </summary>
-        public static MiddlewareStep TypoSuggest { get; } = ParseInput + 1000;
+        public static MiddlewareStep TypoSuggest { get; } = AutoSuggest.Directive + 1000;
 
-        public static MiddlewareStep AssembleInvocationPipeline { get; } = ParseInput + 2000;
+        public static MiddlewareStep AssembleInvocationPipeline { get; } = TypoSuggest + 1000;
 
         /// <summary>Runs before <see cref="Help"/> to ensure default values are included in the help output</summary>
         public static MiddlewareStep Version { get; } = Help.CheckIfShouldShowHelp - 2000;
diff --git a/CommandDotNet/Parsing/CommandParser.OperandQueue.cs b/CommandDotNet/Parsing/CommandParser.OperandQueue.cs
@@ -19,7 +19,7 @@ public OperandQueue(IEnumerable<Operand> operands)
             public bool TryDequeue([NotNullWhen(true)] out Operand? operand)
             {
                 operand = Dequeue();
-                return operand is { };
+                return operand is not null;
             }
 
             public Operand? Dequeue()
diff --git a/CommandDotNet/Parsing/CommandParser.ParseContext.cs b/CommandDotNet/Parsing/CommandParser.ParseContext.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Collections.Generic;
+using CommandDotNet.Extensions;
 using CommandDotNet.Tokens;
 
 namespace CommandDotNet.Parsing
@@ -32,6 +33,7 @@ public Command Command
                 }
             }
 
+            public int TokensEvaluated { get; set; }
 
             public bool SubcommandsAreAllowed { get; private set; } = true;
 
@@ -70,6 +72,20 @@ public void ClearOption()
             }
 
             public void CommandArgumentParsed() => SubcommandsAreAllowed = false;
+
+            public ParseResult ToParseResult() =>
+                ParserError is null
+                    ? new ParseResult(
+                        Command,
+                        RemainingOperands.ToReadOnlyCollection(),
+                        CommandContext.Tokens.Separated,
+                        Operands.Dequeue(), 
+                        TokensEvaluated,
+                        !SubcommandsAreAllowed)
+                    : new ParseResult(ParserError,
+                        Operands.Dequeue(),
+                        TokensEvaluated,
+                        !SubcommandsAreAllowed);
         }
     }
 }
diff --git a/CommandDotNet/Parsing/CommandParser.cs b/CommandDotNet/Parsing/CommandParser.cs
@@ -18,17 +18,15 @@ internal static Task<int> ParseInputMiddleware(CommandContext commandContext, Ex
                 : null;
             var parseContext = new ParseContext(commandContext, new Queue<Token>(commandContext.Tokens.Arguments), separator);
             ParseCommand(commandContext, parseContext);
-            if (parseContext.ParserError is { })
-            {
-                commandContext.ParseResult = new ParseResult(parseContext.ParserError);
-            }
+            commandContext.ParseResult = parseContext.ToParseResult();
             return next(commandContext);
         }
 
         private static void ParseCommand(CommandContext commandContext, ParseContext parseContext)
         {
             foreach (var token in commandContext.Tokens.Arguments)
             {
+                parseContext.TokensEvaluated++;
                 switch (token.TokenType)
                 {
                     case TokenType.Argument:
@@ -68,11 +66,6 @@ private static void ParseCommand(CommandContext commandContext, ParseContext par
                     .TakeWhile(_ => parseContext.ParserError is null)
                     .ForEach(t => ParseValue(parseContext, t, operandsOnly:true));
             }
-
-            commandContext.ParseResult = new ParseResult(
-                parseContext.Command,
-                parseContext.RemainingOperands.ToReadOnlyCollection(),
-                commandContext.Tokens.Separated);
         }
 
         private static void ParseValue(ParseContext parseContext, Token token, bool operandsOnly = false)
@@ -150,7 +143,8 @@ private static bool TryParseOption(ParseContext parseContext, Token token)
                 if (node is Command)
                 {
                     var suggestion = parseContext.CommandContext.Original.Args.ToCsv(" ").Replace(token.RawValue, optionName);
-                    parseContext.ParserError = new UnrecognizedArgumentParseError(parseContext.Command, token, optionPrefix,
+                    parseContext.ParserError = new UnrecognizedArgumentParseError(
+                        parseContext.Command, token, optionPrefix, null,
                         Resources.A.Parse_Intended_command_instead_of_option(token.RawValue, optionName, suggestion));
                     return true;
                 }
@@ -275,10 +269,11 @@ private static void ParseOperand(ParseContext parseContext, Token token)
         {
             if (parseContext.Operands.TryDequeue(out var operand))
             {
-                var currentOperand = operand!;
-                if (ValueIsAllowed(parseContext, currentOperand, token))
+                // do not combine with the above if statement
+                // ValueIsAllowed will set the ParserError if the value is not allowed
+                if (ValueIsAllowed(parseContext, operand, token))
                 {
-                    currentOperand
+                    operand
                         .GetAlreadyParsedValues()
                         .Add(new ValueFromToken(token.Value, token, null));
                     parseContext.CommandArgumentParsed();
@@ -291,7 +286,8 @@ private static void ParseOperand(ParseContext parseContext, Token token)
             }
             else
             {
-                parseContext.ParserError = new UnrecognizedArgumentParseError(parseContext.Command, token, null,
+                parseContext.ParserError = new UnrecognizedArgumentParseError(
+                    parseContext.Command, token, null, operand,
                     Resources.A.Parse_Unrecognized_command_or_argument(token.RawValue));
             }
         }
diff --git a/CommandDotNet/Parsing/ParseResult.cs b/CommandDotNet/Parsing/ParseResult.cs
@@ -14,6 +14,23 @@ public class ParseResult : IIndentableToString
         /// <summary>The command that addressed by the command line arguments</summary>
         public Command TargetCommand { get; }
 
+        /// <summary>
+        /// The next operand that could receive a value.
+        /// If the operand is a list value, it may already have values assigned.
+        /// </summary>
+        public Operand? NextAvailableOperand { get; }
+
+        /// <summary>
+        /// The count of tokens evaluated.
+        /// If there was an error evaluating the token, it's count is included.
+        /// </summary>
+        public int TokensEvaluatedCount { get; }
+        
+        /// <summary>
+        /// True if a command was identified.  No subcommands could be targets at this point.
+        /// </summary>
+        public bool IsCommandIdentified { get; }
+
         /// <summary>
         /// If extra operands were provided and <see cref="ParseAppSettings.IgnoreUnexpectedOperands"/> is true,
         /// The extra operands will be stored in the <see cref="RemainingOperands"/> collection.
@@ -43,16 +60,28 @@ public bool HelpWasRequested() =>
 
         public ParseResult(Command command,
             IReadOnlyCollection<Token> remainingOperands,
-            IReadOnlyCollection<Token> separatedArguments)
+            IReadOnlyCollection<Token> separatedArguments,
+            Operand? nextAvailableOperand,
+            int tokensEvaluatedCount, 
+            bool isCommandIdentified)
         {
             TargetCommand = command ?? throw new ArgumentNullException(nameof(command));
             RemainingOperands = remainingOperands.ToArgsArray();
             SeparatedArguments = separatedArguments.ToArgsArray();
+            NextAvailableOperand = nextAvailableOperand;
+            TokensEvaluatedCount = tokensEvaluatedCount;
+            IsCommandIdentified = isCommandIdentified;
         }
 
-        public ParseResult(IParseError error)
+        public ParseResult(IParseError error, 
+            Operand? nextAvailableOperand,
+            int tokensEvaluatedCount, 
+            bool isCommandIdentified)
         {
             ParseError = error ?? throw new ArgumentNullException(nameof(error));
+            NextAvailableOperand = nextAvailableOperand;
+            TokensEvaluatedCount = tokensEvaluatedCount;
+            IsCommandIdentified = isCommandIdentified;
             TargetCommand = error.Command;
             RemainingOperands = Array.Empty<string>();
             SeparatedArguments = Array.Empty<string>();
@@ -69,7 +98,9 @@ public string ToString(Indent indent)
                    $"{indent}{nameof(TargetCommand)}:{TargetCommand}{NewLine}" +
                    $"{indent}{nameof(RemainingOperands)}:{RemainingOperands.ToCsv()}{NewLine}" +
                    $"{indent}{nameof(SeparatedArguments)}:{SeparatedArguments.ToCsv()}{NewLine}" +
-                   $"{indent}{nameof(ParseError)}:{ParseError?.Message}";
+                   $"{indent}{nameof(NextAvailableOperand)}:{NextAvailableOperand}{NewLine}" +
+                   $"{indent}{nameof(ParseError)}:" + 
+                   (ParseError is null ? null : $"<{ParseError.GetType().Name}> {ParseError.Message}");
         }
     }
 }
diff --git a/CommandDotNet/Parsing/SuggestDirectiveMiddleware.cs b/CommandDotNet/Parsing/SuggestDirectiveMiddleware.cs
diff --git a/CommandDotNet/Parsing/UnrecognizedArgumentParseError.cs b/CommandDotNet/Parsing/UnrecognizedArgumentParseError.cs
diff --git a/CommandDotNet/Parsing/UnrecognizedOptionParseError.cs b/CommandDotNet/Parsing/UnrecognizedOptionParseError.cs

Original file line number	Diff line number	Diff line change
`@@ -5,18 +5,16 @@ namespace CommandDotNet.Tests.FeatureTests.Suggestions`
`5`	`5`
`6`	`6`	`public enum Fruit { Apple, Banana, Cherry }`
`7`	`7`	`public enum Vegetable { Asparagus, Broccoli, Carrot }`
	`8`	`+ public enum Main { Chicken, Steak, Fish, Veggie}`
`8`	`9`	`public enum Meal { Breakfast, Lunch, Dinner }`
`9`	`10`
`10`	`11`	`public class CafeApp`
`11`	`12`	`{`
`12`		`- public void Eat(IConsole console,`
	`13`	`+ public void Eat(`
`13`	`14`	`[Operand] Meal meal,`
`14`	`15`	`[Option] Vegetable vegetable,`
`15`	`16`	`[Option] Fruit fruit)`
`16`	`17`	`{`
`17`		`- console.Out.WriteLine($"{nameof(meal)} :{meal}");`
`18`		`- console.Out.WriteLine($"{nameof(fruit)} :{fruit}");`
`19`		`- console.Out.WriteLine($"{nameof(vegetable)}:{vegetable}");`
`20`	`18`	`}`
`21`	`19`	`}`
`22`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public OperandQueue(IEnumerable<Operand> operands)`
`19`	`19`	`public bool TryDequeue([NotNullWhen(true)] out Operand? operand)`
`20`	`20`	`{`
`21`	`21`	`operand = Dequeue();`
`22`		`- return operand is { };`
	`22`	`+ return operand is not null;`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`public Operand? Dequeue()`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using CommandDotNet.Extensions;`
`3`	`4`	`using CommandDotNet.Tokens;`
`4`	`5`
`5`	`6`	`namespace CommandDotNet.Parsing`
`@@ -32,6 +33,7 @@ public Command Command`
`32`	`33`	`}`
`33`	`34`	`}`
`34`	`35`
	`36`	`+ public int TokensEvaluated { get; set; }`
`35`	`37`
`36`	`38`	`public bool SubcommandsAreAllowed { get; private set; } = true;`
`37`	`39`
`@@ -70,6 +72,20 @@ public void ClearOption()`
`70`	`72`	`}`
`71`	`73`
`72`	`74`	`public void CommandArgumentParsed() => SubcommandsAreAllowed = false;`
	`75`	`+`
	`76`	`+ public ParseResult ToParseResult() =>`
	`77`	`+ ParserError is null`
	`78`	`+ ? new ParseResult(`
	`79`	`+ Command,`
	`80`	`+ RemainingOperands.ToReadOnlyCollection(),`
	`81`	`+ CommandContext.Tokens.Separated,`
	`82`	`+ Operands.Dequeue(),`
	`83`	`+ TokensEvaluated,`
	`84`	`+ !SubcommandsAreAllowed)`
	`85`	`+ : new ParseResult(ParserError,`
	`86`	`+ Operands.Dequeue(),`
	`87`	`+ TokensEvaluated,`
	`88`	`+ !SubcommandsAreAllowed);`
`73`	`89`	`}`
`74`	`90`	`}`
`75`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,17 +18,15 @@ internal static Task<int> ParseInputMiddleware(CommandContext commandContext, Ex`
`18`	`18`	`: null;`
`19`	`19`	`var parseContext = new ParseContext(commandContext, new Queue<Token>(commandContext.Tokens.Arguments), separator);`
`20`	`20`	`ParseCommand(commandContext, parseContext);`
`21`		`- if (parseContext.ParserError is { })`
`22`		`- {`
`23`		`- commandContext.ParseResult = new ParseResult(parseContext.ParserError);`
`24`		`- }`
	`21`	`+ commandContext.ParseResult = parseContext.ToParseResult();`
`25`	`22`	`return next(commandContext);`
`26`	`23`	`}`
`27`	`24`
`28`	`25`	`private static void ParseCommand(CommandContext commandContext, ParseContext parseContext)`
`29`	`26`	`{`
`30`	`27`	`foreach (var token in commandContext.Tokens.Arguments)`
`31`	`28`	`{`
	`29`	`+ parseContext.TokensEvaluated++;`
`32`	`30`	`switch (token.TokenType)`
`33`	`31`	`{`
`34`	`32`	`case TokenType.Argument:`
`@@ -68,11 +66,6 @@ private static void ParseCommand(CommandContext commandContext, ParseContext par`
`68`	`66`	`.TakeWhile(_ => parseContext.ParserError is null)`
`69`	`67`	`.ForEach(t => ParseValue(parseContext, t, operandsOnly:true));`
`70`	`68`	`}`
`71`		`-`
`72`		`- commandContext.ParseResult = new ParseResult(`
`73`		`- parseContext.Command,`
`74`		`- parseContext.RemainingOperands.ToReadOnlyCollection(),`
`75`		`- commandContext.Tokens.Separated);`
`76`	`69`	`}`
`77`	`70`
`78`	`71`	`private static void ParseValue(ParseContext parseContext, Token token, bool operandsOnly = false)`
`@@ -150,7 +143,8 @@ private static bool TryParseOption(ParseContext parseContext, Token token)`
`150`	`143`	`if (node is Command)`
`151`	`144`	`{`
`152`	`145`	`var suggestion = parseContext.CommandContext.Original.Args.ToCsv(" ").Replace(token.RawValue, optionName);`
`153`		`- parseContext.ParserError = new UnrecognizedArgumentParseError(parseContext.Command, token, optionPrefix,`
	`146`	`+ parseContext.ParserError = new UnrecognizedArgumentParseError(`
	`147`	`+ parseContext.Command, token, optionPrefix, null,`
`154`	`148`	`Resources.A.Parse_Intended_command_instead_of_option(token.RawValue, optionName, suggestion));`
`155`	`149`	`return true;`
`156`	`150`	`}`
`@@ -275,10 +269,11 @@ private static void ParseOperand(ParseContext parseContext, Token token)`
`275`	`269`	`{`
`276`	`270`	`if (parseContext.Operands.TryDequeue(out var operand))`
`277`	`271`	`{`
`278`		`- var currentOperand = operand!;`
`279`		`- if (ValueIsAllowed(parseContext, currentOperand, token))`
	`272`	`+ // do not combine with the above if statement`
	`273`	`+ // ValueIsAllowed will set the ParserError if the value is not allowed`
	`274`	`+ if (ValueIsAllowed(parseContext, operand, token))`
`280`	`275`	`{`
`281`		`- currentOperand`
	`276`	`+ operand`
`282`	`277`	`.GetAlreadyParsedValues()`
`283`	`278`	`.Add(new ValueFromToken(token.Value, token, null));`
`284`	`279`	`parseContext.CommandArgumentParsed();`
`@@ -291,7 +286,8 @@ private static void ParseOperand(ParseContext parseContext, Token token)`
`291`	`286`	`}`
`292`	`287`	`else`
`293`	`288`	`{`
`294`		`- parseContext.ParserError = new UnrecognizedArgumentParseError(parseContext.Command, token, null,`
	`289`	`+ parseContext.ParserError = new UnrecognizedArgumentParseError(`
	`290`	`+ parseContext.Command, token, null, operand,`
`295`	`291`	`Resources.A.Parse_Unrecognized_command_or_argument(token.RawValue));`
`296`	`292`	`}`
`297`	`293`	`}`