rename ParseDiagramDirective To DiagramDirective (#2135)

adamsitnik · web-flow · commit b40ebf62dfe7 · 2023-03-31T07:34:23.000-07:00
diff --git a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
@@ -116,6 +116,10 @@ System.CommandLine
   public static class CompletionSourceExtensions
     public static System.Void Add(this System.Collections.Generic.List<System.Func<System.CommandLine.Completions.CompletionContext,System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem>>> completionSources, System.Func<System.CommandLine.Completions.CompletionContext,System.Collections.Generic.IEnumerable<System.String>> completionsDelegate)
     public static System.Void Add(this System.Collections.Generic.List<System.Func<System.CommandLine.Completions.CompletionContext,System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem>>> completionSources, System.String[] completions)
+  public class DiagramDirective : CliDirective
+    .ctor()
+    public CliAction Action { get; set; }
+    public System.Int32 ParseErrorReturnValue { get; set; }
   public class EnvironmentVariablesDirective : CliDirective
     .ctor()
     public CliAction Action { get; set; }
@@ -124,10 +128,6 @@ System.CommandLine
     public static CliOption<System.IO.DirectoryInfo> AcceptExistingOnly(this CliOption<System.IO.DirectoryInfo> option)
     public static CliOption<System.IO.FileSystemInfo> AcceptExistingOnly(this CliOption<System.IO.FileSystemInfo> option)
     public static CliOption<T> AcceptExistingOnly<T>(this CliOption<T> option)
-  public class ParseDiagramDirective : CliDirective
-    .ctor()
-    public CliAction Action { get; set; }
-    public System.Int32 ParseErrorReturnValue { get; set; }
   public class ParseResult
     public CliAction Action { get; }
     public System.CommandLine.Parsing.CommandResult CommandResult { get; }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_ParseResult.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_ParseResult.cs
@@ -27,7 +27,7 @@ public Perf_Parser_ParseResult()
 
             _configuration = new CliConfiguration(new CliRootCommand { option })
             {
-                Directives = { new ParseDiagramDirective() },
+                Directives = { new DiagramDirective() },
                 Output = _output
             };
         }
diff --git a/src/System.CommandLine.Suggest/SuggestionDispatcher.cs b/src/System.CommandLine.Suggest/SuggestionDispatcher.cs
@@ -75,7 +75,7 @@ public SuggestionDispatcher(ISuggestionRegistration suggestionRegistration, ISug
             {
                 Directives =
                 {
-                    new ParseDiagramDirective(),
+                    new DiagramDirective(),
                     new SuggestDirective(),
                 }
             };
diff --git a/src/System.CommandLine.Tests/ParseDirectiveTests.cs b/src/System.CommandLine.Tests/ParseDirectiveTests.cs
@@ -9,17 +9,17 @@
 
 namespace System.CommandLine.Tests
 {
-    public class ParseDirectiveTests
+    public class DiagramDirectiveTests
     {
         private readonly ITestOutputHelper output;
 
-        public ParseDirectiveTests(ITestOutputHelper output)
+        public DiagramDirectiveTests(ITestOutputHelper output)
         {
             this.output = output;
         }
 
         [Fact]
-        public async Task Parse_directive_writes_parse_diagram()
+        public async Task Diagram_directive_writes_parse_diagram()
         {
             var rootCommand = new CliRootCommand();
             var subcommand = new CliCommand("subcommand");
@@ -30,10 +30,10 @@ public async Task Parse_directive_writes_parse_diagram()
             CliConfiguration config = new(rootCommand)
             {
                 Output = new StringWriter(),
-                Directives = { new ParseDiagramDirective() }
+                Directives = { new DiagramDirective() }
             };
 
-            var result = rootCommand.Parse("[parse] subcommand -c 34 --nonexistent wat", config);
+            var result = rootCommand.Parse("[diagram] subcommand -c 34 --nonexistent wat", config);
 
             output.WriteLine(result.Diagram());
 
@@ -46,17 +46,17 @@ public async Task Parse_directive_writes_parse_diagram()
         }
 
         [Fact]
-        public async Task When_parse_directive_is_used_the_help_is_not_displayed()
+        public async Task When_diagram_directive_is_used_the_help_is_not_displayed()
         {
             CliRootCommand rootCommand = new ();
 
             CliConfiguration config = new(rootCommand)
             {
                 Output = new StringWriter(),
-                Directives = { new ParseDiagramDirective() }
+                Directives = { new DiagramDirective() }
             };
 
-            var result = rootCommand.Parse("[parse] --help", config);
+            var result = rootCommand.Parse("[diagram] --help", config);
 
             output.WriteLine(result.Diagram());
 
@@ -69,17 +69,17 @@ public async Task When_parse_directive_is_used_the_help_is_not_displayed()
         }
 
         [Fact]
-        public async Task When_parse_directive_is_used_the_version_is_not_displayed()
+        public async Task When_diagram_directive_is_used_the_version_is_not_displayed()
         {
             CliRootCommand rootCommand = new();
 
             CliConfiguration config = new(rootCommand)
             {
                 Output = new StringWriter(),
-                Directives = { new ParseDiagramDirective() }
+                Directives = { new DiagramDirective() }
             };
 
-            var result = rootCommand.Parse("[parse] --version", config);
+            var result = rootCommand.Parse("[diagram] --version", config);
 
             output.WriteLine(result.Diagram());
 
@@ -92,7 +92,7 @@ public async Task When_parse_directive_is_used_the_version_is_not_displayed()
         }
 
         [Fact]
-        public async Task When_there_are_no_errors_then_parse_directive_sets_exit_code_0()
+        public async Task When_there_are_no_errors_then_diagram_directive_sets_exit_code_0()
         {
             CliRootCommand command = new ()
             {
@@ -102,16 +102,16 @@ public async Task When_there_are_no_errors_then_parse_directive_sets_exit_code_0
             CliConfiguration config = new(command)
             {
                 Output = new StringWriter(),
-                Directives = { new ParseDiagramDirective() }
+                Directives = { new DiagramDirective() }
             };
 
-            var exitCode = await command.Parse("[parse] -x 123", config).InvokeAsync();
+            var exitCode = await command.Parse("[diagram] -x 123", config).InvokeAsync();
 
             exitCode.Should().Be(0);
         }
 
         [Fact]
-        public async Task When_there_are_errors_then_parse_directive_sets_exit_code_1()
+        public async Task When_there_are_errors_then_diagram_directive_sets_exit_code_1()
         {
             CliRootCommand command = new()
             {
@@ -121,16 +121,16 @@ public async Task When_there_are_errors_then_parse_directive_sets_exit_code_1()
             CliConfiguration config = new(command)
             {
                 Output = new StringWriter(),
-                Directives = { new ParseDiagramDirective() }
+                Directives = { new DiagramDirective() }
             };
 
-            var exitCode = await command.Parse("[parse] -x not-an-int", config).InvokeAsync();
+            var exitCode = await command.Parse("[diagram] -x not-an-int", config).InvokeAsync();
 
             exitCode.Should().Be(1);
         }
 
         [Fact]
-        public async Task When_there_are_errors_then_parse_directive_sets_exit_code_to_custom_value()
+        public async Task When_there_are_errors_then_diagram_directive_sets_exit_code_to_custom_value()
         {
             CliRootCommand command = new ()
             {
@@ -140,13 +140,13 @@ public async Task When_there_are_errors_then_parse_directive_sets_exit_code_to_c
             CliConfiguration config = new(command)
             {
                 Output = new StringWriter(),
-                Directives = { new ParseDiagramDirective
+                Directives = { new DiagramDirective
                 {
                     ParseErrorReturnValue = 42
                 } }
             };
 
-            int exitCode = await config.InvokeAsync("[parse] -x not-an-int");
+            int exitCode = await config.InvokeAsync("[diagram] -x not-an-int");
 
             exitCode.Should().Be(42);
         }
diff --git a/src/System.CommandLine.Tests/Utility/ParseResultExtensions.cs b/src/System.CommandLine.Tests/Utility/ParseResultExtensions.cs
@@ -11,7 +11,7 @@ internal static string Diagram(this ParseResult parseResult)
             try
             {
                 parseResult.Configuration.Output = new StringWriter();
-                new ParseDiagramDirective().Action.Invoke(parseResult);
+                new DiagramDirective().Action.Invoke(parseResult);
                 return parseResult.Configuration.Output.ToString()
                     .TrimEnd(); // the directive adds a new line, tests that used to rely on Diagram extension method don't expect it
             }
diff --git a/src/System.CommandLine/ParseDiagramDirective.cs b/src/System.CommandLine/ParseDiagramDirective.cs
@@ -3,24 +3,24 @@
 namespace System.CommandLine
 {
     /// <summary>
-    /// Enables the use of the <c>[parse]</c> directive, which when specified on the command line will short 
+    /// Enables the use of the <c>[diagram]</c> directive, which when specified on the command line will short 
     /// circuit normal command handling and display a diagram explaining the parse result for the command line input.
     /// </summary>
-    public sealed class ParseDiagramDirective : CliDirective
+    public sealed class DiagramDirective : CliDirective
     {
         private CliAction? _action;
 
         /// <summary>
-        /// Writes a diagram of the parse result to the console.
+        /// Writes a diagram of the parse result to the output.
         /// </summary>
-        public ParseDiagramDirective() : base("parse")
+        public DiagramDirective() : base("diagram")
         {
         }
 
         /// <inheritdoc />
         public override CliAction? Action
         {
-            get => _action ??= new ParseDiagramAction(ParseErrorReturnValue);
+            get => _action ??= new DiagramAction(ParseErrorReturnValue);
             set => _action = value ?? throw new ArgumentNullException(nameof(value));
         }
 
diff --git a/src/System.CommandLine/ParseResult.cs b/src/System.CommandLine/ParseResult.cs
@@ -194,7 +194,7 @@ void Populate<TSymbol>(Dictionary<string, SymbolResult?> cache, IList<TSymbol> s
         }
 
         /// <inheritdoc />
-        public override string ToString() => ParseDiagramAction.Diagram(this).ToString();
+        public override string ToString() => DiagramAction.Diagram(this).ToString();
 
         /// <summary>
         /// Gets the result, if any, for the specified argument.
diff --git a/src/System.CommandLine/Parsing/ParseDiagramAction.cs b/src/System.CommandLine/Parsing/ParseDiagramAction.cs
@@ -11,14 +11,14 @@
 namespace System.CommandLine.Parsing
 {
     /// <summary>
-    /// Implements the <c>[parse]</c> directive action, which when specified on the command line 
+    /// Implements the <c>[diagram]</c> directive action, which when specified on the command line 
     /// will short circuit normal command handling and display a diagram explaining the parse result for the command line input.
     /// </summary>
-    internal sealed class ParseDiagramAction : CliAction
+    internal sealed class DiagramAction : CliAction
     {
         private readonly int _parseErrorReturnValue;
 
-        internal ParseDiagramAction(int parseErrorReturnValue) => _parseErrorReturnValue = parseErrorReturnValue;
+        internal DiagramAction(int parseErrorReturnValue) => _parseErrorReturnValue = parseErrorReturnValue;
 
         public override int Invoke(ParseResult parseResult)
         {
@@ -79,7 +79,7 @@ private static void Diagram(
 
             switch (symbolResult)
             {
-                case DirectiveResult directiveResult when directiveResult.Directive is not ParseDiagramDirective:
+                case DirectiveResult directiveResult when directiveResult.Directive is not DiagramDirective:
                     break;
                 case ArgumentResult argumentResult:
                 {
diff --git a/src/System.CommandLine/Parsing/ParseOperation.cs b/src/System.CommandLine/Parsing/ParseOperation.cs
@@ -321,7 +321,7 @@ void ParseDirective()
 
                 _action = directive.Action;
 
-                if (directive is ParseDiagramDirective)
+                if (directive is DiagramDirective)
                 {
                     _isParseRequested = true;
                 }

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public Perf_Parser_ParseResult()`
`27`	`27`
`28`	`28`	`_configuration = new CliConfiguration(new CliRootCommand { option })`
`29`	`29`	`{`
`30`		`- Directives = { new ParseDiagramDirective() },`
	`30`	`+ Directives = { new DiagramDirective() },`
`31`	`31`	`Output = _output`
`32`	`32`	`};`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ public SuggestionDispatcher(ISuggestionRegistration suggestionRegistration, ISug`
`75`	`75`	`{`
`76`	`76`	`Directives =`
`77`	`77`	`{`
`78`		`- new ParseDiagramDirective(),`
	`78`	`+ new DiagramDirective(),`
`79`	`79`	`new SuggestDirective(),`
`80`	`80`	`}`
`81`	`81`	`};`
Original file line number	Diff line number	Diff line change
`@@ -9,17 +9,17 @@`
`9`	`9`
`10`	`10`	`namespace System.CommandLine.Tests`
`11`	`11`	`{`
`12`		`- public class ParseDirectiveTests`
	`12`	`+ public class DiagramDirectiveTests`
`13`	`13`	`{`
`14`	`14`	`private readonly ITestOutputHelper output;`
`15`	`15`
`16`		`- public ParseDirectiveTests(ITestOutputHelper output)`
	`16`	`+ public DiagramDirectiveTests(ITestOutputHelper output)`
`17`	`17`	`{`
`18`	`18`	`this.output = output;`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`[Fact]`
`22`		`- public async Task Parse_directive_writes_parse_diagram()`
	`22`	`+ public async Task Diagram_directive_writes_parse_diagram()`
`23`	`23`	`{`
`24`	`24`	`var rootCommand = new CliRootCommand();`
`25`	`25`	`var subcommand = new CliCommand("subcommand");`
`@@ -30,10 +30,10 @@ public async Task Parse_directive_writes_parse_diagram()`
`30`	`30`	`CliConfiguration config = new(rootCommand)`
`31`	`31`	`{`
`32`	`32`	`Output = new StringWriter(),`
`33`		`- Directives = { new ParseDiagramDirective() }`
	`33`	`+ Directives = { new DiagramDirective() }`
`34`	`34`	`};`
`35`	`35`
`36`		`- var result = rootCommand.Parse("[parse] subcommand -c 34 --nonexistent wat", config);`
	`36`	`+ var result = rootCommand.Parse("[diagram] subcommand -c 34 --nonexistent wat", config);`
`37`	`37`
`38`	`38`	`output.WriteLine(result.Diagram());`
`39`	`39`
`@@ -46,17 +46,17 @@ public async Task Parse_directive_writes_parse_diagram()`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`[Fact]`
`49`		`- public async Task When_parse_directive_is_used_the_help_is_not_displayed()`
	`49`	`+ public async Task When_diagram_directive_is_used_the_help_is_not_displayed()`
`50`	`50`	`{`
`51`	`51`	`CliRootCommand rootCommand = new ();`
`52`	`52`
`53`	`53`	`CliConfiguration config = new(rootCommand)`
`54`	`54`	`{`
`55`	`55`	`Output = new StringWriter(),`
`56`		`- Directives = { new ParseDiagramDirective() }`
	`56`	`+ Directives = { new DiagramDirective() }`
`57`	`57`	`};`
`58`	`58`
`59`		`- var result = rootCommand.Parse("[parse] --help", config);`
	`59`	`+ var result = rootCommand.Parse("[diagram] --help", config);`
`60`	`60`
`61`	`61`	`output.WriteLine(result.Diagram());`
`62`	`62`
`@@ -69,17 +69,17 @@ public async Task When_parse_directive_is_used_the_help_is_not_displayed()`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`[Fact]`
`72`		`- public async Task When_parse_directive_is_used_the_version_is_not_displayed()`
	`72`	`+ public async Task When_diagram_directive_is_used_the_version_is_not_displayed()`
`73`	`73`	`{`
`74`	`74`	`CliRootCommand rootCommand = new();`
`75`	`75`
`76`	`76`	`CliConfiguration config = new(rootCommand)`
`77`	`77`	`{`
`78`	`78`	`Output = new StringWriter(),`
`79`		`- Directives = { new ParseDiagramDirective() }`
	`79`	`+ Directives = { new DiagramDirective() }`
`80`	`80`	`};`
`81`	`81`
`82`		`- var result = rootCommand.Parse("[parse] --version", config);`
	`82`	`+ var result = rootCommand.Parse("[diagram] --version", config);`
`83`	`83`
`84`	`84`	`output.WriteLine(result.Diagram());`
`85`	`85`
`@@ -92,7 +92,7 @@ public async Task When_parse_directive_is_used_the_version_is_not_displayed()`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`[Fact]`
`95`		`- public async Task When_there_are_no_errors_then_parse_directive_sets_exit_code_0()`
	`95`	`+ public async Task When_there_are_no_errors_then_diagram_directive_sets_exit_code_0()`
`96`	`96`	`{`
`97`	`97`	`CliRootCommand command = new ()`
`98`	`98`	`{`
`@@ -102,16 +102,16 @@ public async Task When_there_are_no_errors_then_parse_directive_sets_exit_code_0`
`102`	`102`	`CliConfiguration config = new(command)`
`103`	`103`	`{`
`104`	`104`	`Output = new StringWriter(),`
`105`		`- Directives = { new ParseDiagramDirective() }`
	`105`	`+ Directives = { new DiagramDirective() }`
`106`	`106`	`};`
`107`	`107`
`108`		`- var exitCode = await command.Parse("[parse] -x 123", config).InvokeAsync();`
	`108`	`+ var exitCode = await command.Parse("[diagram] -x 123", config).InvokeAsync();`
`109`	`109`
`110`	`110`	`exitCode.Should().Be(0);`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`[Fact]`
`114`		`- public async Task When_there_are_errors_then_parse_directive_sets_exit_code_1()`
	`114`	`+ public async Task When_there_are_errors_then_diagram_directive_sets_exit_code_1()`
`115`	`115`	`{`
`116`	`116`	`CliRootCommand command = new()`
`117`	`117`	`{`
`@@ -121,16 +121,16 @@ public async Task When_there_are_errors_then_parse_directive_sets_exit_code_1()`
`121`	`121`	`CliConfiguration config = new(command)`
`122`	`122`	`{`
`123`	`123`	`Output = new StringWriter(),`
`124`		`- Directives = { new ParseDiagramDirective() }`
	`124`	`+ Directives = { new DiagramDirective() }`
`125`	`125`	`};`
`126`	`126`
`127`		`- var exitCode = await command.Parse("[parse] -x not-an-int", config).InvokeAsync();`
	`127`	`+ var exitCode = await command.Parse("[diagram] -x not-an-int", config).InvokeAsync();`
`128`	`128`
`129`	`129`	`exitCode.Should().Be(1);`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`[Fact]`
`133`		`- public async Task When_there_are_errors_then_parse_directive_sets_exit_code_to_custom_value()`
	`133`	`+ public async Task When_there_are_errors_then_diagram_directive_sets_exit_code_to_custom_value()`
`134`	`134`	`{`
`135`	`135`	`CliRootCommand command = new ()`
`136`	`136`	`{`
`@@ -140,13 +140,13 @@ public async Task When_there_are_errors_then_parse_directive_sets_exit_code_to_c`
`140`	`140`	`CliConfiguration config = new(command)`
`141`	`141`	`{`
`142`	`142`	`Output = new StringWriter(),`
`143`		`- Directives = { new ParseDiagramDirective`
	`143`	`+ Directives = { new DiagramDirective`
`144`	`144`	`{`
`145`	`145`	`ParseErrorReturnValue = 42`
`146`	`146`	`} }`
`147`	`147`	`};`
`148`	`148`
`149`		`- int exitCode = await config.InvokeAsync("[parse] -x not-an-int");`
	`149`	`+ int exitCode = await config.InvokeAsync("[diagram] -x not-an-int");`
`150`	`150`
`151`	`151`	`exitCode.Should().Be(42);`
`152`	`152`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ internal static string Diagram(this ParseResult parseResult)`
`11`	`11`	`try`
`12`	`12`	`{`
`13`	`13`	`parseResult.Configuration.Output = new StringWriter();`
`14`		`- new ParseDiagramDirective().Action.Invoke(parseResult);`
	`14`	`+ new DiagramDirective().Action.Invoke(parseResult);`
`15`	`15`	`return parseResult.Configuration.Output.ToString()`
`16`	`16`	`.TrimEnd(); // the directive adds a new line, tests that used to rely on Diagram extension method don't expect it`
`17`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,24 +3,24 @@`
`3`	`3`	`namespace System.CommandLine`
`4`	`4`	`{`
`5`	`5`	`/// <summary>`
`6`		`- /// Enables the use of the <c>[parse]</c> directive, which when specified on the command line will short`
	`6`	`+ /// Enables the use of the <c>[diagram]</c> directive, which when specified on the command line will short`
`7`	`7`	`/// circuit normal command handling and display a diagram explaining the parse result for the command line input.`
`8`	`8`	`/// </summary>`
`9`		`- public sealed class ParseDiagramDirective : CliDirective`
	`9`	`+ public sealed class DiagramDirective : CliDirective`
`10`	`10`	`{`
`11`	`11`	`private CliAction? _action;`
`12`	`12`
`13`	`13`	`/// <summary>`
`14`		`- /// Writes a diagram of the parse result to the console.`
	`14`	`+ /// Writes a diagram of the parse result to the output.`
`15`	`15`	`/// </summary>`
`16`		`- public ParseDiagramDirective() : base("parse")`
	`16`	`+ public DiagramDirective() : base("diagram")`
`17`	`17`	`{`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`/// <inheritdoc />`
`21`	`21`	`public override CliAction? Action`
`22`	`22`	`{`
`23`		`- get => _action ??= new ParseDiagramAction(ParseErrorReturnValue);`
	`23`	`+ get => _action ??= new DiagramAction(ParseErrorReturnValue);`
`24`	`24`	`set => _action = value ?? throw new ArgumentNullException(nameof(value));`
`25`	`25`	`}`
`26`	`26`
Original file line number	Diff line number	Diff line change
`@@ -194,7 +194,7 @@ void Populate<TSymbol>(Dictionary<string, SymbolResult?> cache, IList<TSymbol> s`
`194`	`194`	`}`
`195`	`195`
`196`	`196`	`/// <inheritdoc />`
`197`		`- public override string ToString() => ParseDiagramAction.Diagram(this).ToString();`
	`197`	`+ public override string ToString() => DiagramAction.Diagram(this).ToString();`
`198`	`198`
`199`	`199`	`/// <summary>`
`200`	`200`	`/// Gets the result, if any, for the specified argument.`
Original file line number	Diff line number	Diff line change
`@@ -11,14 +11,14 @@`
`11`	`11`	`namespace System.CommandLine.Parsing`
`12`	`12`	`{`
`13`	`13`	`/// <summary>`
`14`		`- /// Implements the <c>[parse]</c> directive action, which when specified on the command line`
	`14`	`+ /// Implements the <c>[diagram]</c> directive action, which when specified on the command line`
`15`	`15`	`/// will short circuit normal command handling and display a diagram explaining the parse result for the command line input.`
`16`	`16`	`/// </summary>`
`17`		`- internal sealed class ParseDiagramAction : CliAction`
	`17`	`+ internal sealed class DiagramAction : CliAction`
`18`	`18`	`{`
`19`	`19`	`private readonly int _parseErrorReturnValue;`
`20`	`20`
`21`		`- internal ParseDiagramAction(int parseErrorReturnValue) => _parseErrorReturnValue = parseErrorReturnValue;`
	`21`	`+ internal DiagramAction(int parseErrorReturnValue) => _parseErrorReturnValue = parseErrorReturnValue;`
`22`	`22`
`23`	`23`	`public override int Invoke(ParseResult parseResult)`
`24`	`24`	`{`
`@@ -79,7 +79,7 @@ private static void Diagram(`
`79`	`79`
`80`	`80`	`switch (symbolResult)`
`81`	`81`	`{`
`82`		`- case DirectiveResult directiveResult when directiveResult.Directive is not ParseDiagramDirective:`
	`82`	`+ case DirectiveResult directiveResult when directiveResult.Directive is not DiagramDirective:`
`83`	`83`	`break;`
`84`	`84`	`case ArgumentResult argumentResult:`
`85`	`85`	`{`
Original file line number	Diff line number	Diff line change
`@@ -321,7 +321,7 @@ void ParseDirective()`
`321`	`321`
`322`	`322`	`_action = directive.Action;`
`323`	`323`
`324`		`- if (directive is ParseDiagramDirective)`
	`324`	`+ if (directive is DiagramDirective)`
`325`	`325`	`{`
`326`	`326`	`_isParseRequested = true;`
`327`	`327`	`}`