Rebasing on powderhouse

BenjaminMichaelis · BenjaminMichaelis · commit ddf0a2aa8c15 · 2024-10-08T10:09:39.000-07:00
diff --git a/src/System.CommandLine.Subsystems.Tests/ErrorReportingFunctionalTests.cs b/src/System.CommandLine.Subsystems.Tests/ErrorReportingFunctionalTests.cs
@@ -56,9 +56,9 @@ public void Help_display_can_be_disabled()
 
         var result = rootCommand.Parse("oops", config);
 
-        if (result.Action is ParseErrorAction parseError)
+        if (result.Action is CliDiagnosticAction CliDiagnostic)
         {
-            parseError.ShowHelp = false;
+            CliDiagnostic.ShowHelp = false;
         }
 
         result.Invoke();
diff --git a/src/System.CommandLine.Subsystems.Tests/ErrorReportingSubsystemTests.cs b/src/System.CommandLine.Subsystems.Tests/ErrorReportingSubsystemTests.cs
@@ -1,9 +1,9 @@
 // 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.CommandLine.Parsing;
 using FluentAssertions;
 using Xunit;
-using System.CommandLine.Parsing;
 
 namespace System.CommandLine.Subsystems.Tests;
 
@@ -12,8 +12,8 @@ public class ErrorReportingSubsystemTests
     [Fact]
     public void Report_when_single_error_writes_to_console_hack()
     {
-        var error = new ParseError("a sweet error message");
-        var errors = new List<ParseError> { error };
+        var error = new CliDiagnostic(new("", "", "a sweet error message", CliDiagnosticSeverity.Warning, null), []);
+        var errors = new List<CliDiagnostic> { error };
         var errorSubsystem = new ErrorReportingSubsystem();
         var consoleHack = new ConsoleHack().RedirectToBuffer(true);
 
@@ -25,9 +25,9 @@ public void Report_when_single_error_writes_to_console_hack()
     [Fact]
     public void Report_when_multiple_error_writes_to_console_hack()
     {
-        var error = new ParseError("a sweet error message");
-        var anotherError = new ParseError("another sweet error message");
-        var errors = new List<ParseError> { error, anotherError };
+        var error = new CliDiagnostic(new("", "", "a sweet error message", CliDiagnosticSeverity.Warning, null), []);
+        var anotherError = new CliDiagnostic(new("", "", "another sweet error message", CliDiagnosticSeverity.Warning, null), []);
+        var errors = new List<CliDiagnostic> { error, anotherError };
         var errorSubsystem = new ErrorReportingSubsystem();
         var consoleHack = new ConsoleHack().RedirectToBuffer(true);
 
@@ -39,7 +39,7 @@ public void Report_when_multiple_error_writes_to_console_hack()
     [Fact]
     public void Report_when_no_errors_writes_nothing_to_console_hack()
     {
-        var errors = new List<ParseError> { };
+        var errors = new List<CliDiagnostic> { };
         var errorSubsystem = new ErrorReportingSubsystem();
         var consoleHack = new ConsoleHack().RedirectToBuffer(true);
 
@@ -53,7 +53,7 @@ public void Report_when_no_errors_writes_nothing_to_console_hack()
     [InlineData("-non_existant_option")]
     public void GetIsActivated_GivenInvalidInput_SubsystemIsActive(string input)
     {
-        var rootCommand = new CliRootCommand {new CliOption<bool>("-v")};
+        var rootCommand = new CliRootCommand { new CliOption<bool>("-v") };
         var configuration = new CliConfiguration(rootCommand);
         var errorSubsystem = new ErrorReportingSubsystem();
         IReadOnlyList<string> args = [""];
diff --git a/src/System.CommandLine.Subsystems/ErrorReportingSubsystem.cs b/src/System.CommandLine.Subsystems/ErrorReportingSubsystem.cs
@@ -33,7 +33,7 @@ public override void Execute(PipelineResult pipelineResult)
         pipelineResult.SetSuccess();
     }
 
-    public void Report(ConsoleHack consoleHack, IReadOnlyList<ParseError> errors)
+    public void Report(ConsoleHack consoleHack, IReadOnlyList<CliDiagnostic> errors)
     {
         ConsoleHelpers.ResetTerminalForegroundColor();
         ConsoleHelpers.SetTerminalForegroundRed();
diff --git a/src/System.CommandLine.Subsystems/PipelineResult.cs b/src/System.CommandLine.Subsystems/PipelineResult.cs
@@ -1,4 +1,4 @@
-﻿// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// 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.CommandLine.Parsing;
@@ -9,8 +9,8 @@ namespace System.CommandLine;
 public class PipelineResult
 {
     // TODO: Try to build workflow so it is illegal to create this without a ParseResult
-    private readonly List<ParseError> errors = [];
-    private ValueProvider valueProvider { get; } 
+    private readonly List<CliDiagnostic> errors = [];
+    private ValueProvider valueProvider { get; }
 
     public PipelineResult(ParseResult parseResult, string rawInput, Pipeline? pipeline, ConsoleHack? consoleHack = null)
     {
@@ -44,18 +44,18 @@ public PipelineResult(ParseResult parseResult, string rawInput, Pipeline? pipeli
      => ParseResult.GetValueResult(valueSymbol);
 
 
-    public void AddErrors(IEnumerable<ParseError> errors)
+    public void AddErrors(IEnumerable<CliDiagnostic> errors)
     {
         if (errors is not null)
         {
             this.errors.AddRange(errors);
         }
     }
 
-    public void AddError(ParseError error)
+    public void AddError(CliDiagnostic error)
         => errors.Add(error);
 
-    public IEnumerable<ParseError> GetErrors(bool excludeParseErrors = false)
+    public IEnumerable<CliDiagnostic> GetErrors(bool excludeParseErrors = false)
         => excludeParseErrors || ParseResult is null
             ? errors
             : ParseResult.Errors.Concat(errors);
diff --git a/src/System.CommandLine.Subsystems/Validation/InclusiveGroupValidator.cs b/src/System.CommandLine.Subsystems/Validation/InclusiveGroupValidator.cs
@@ -44,9 +44,9 @@ public override void Validate(CliCommandResult commandResult,
             // TODO: Rework to allow localization
             var pluralToBe = "are";
             var singularToBe = "is";
-            validationContext.AddError(new ParseError( $"The members {string.Join(", ", groupMembers.Select(m => m.Name))} " +
-                $"must all be used if one is used. {string.Join(", ", missingMembers.Select(m => m.Name))} " +
-                $"{(missingMembers.Skip(1).Any() ? pluralToBe : singularToBe)} missing."));
+            validationContext.AddError(new CliDiagnostic(new("", "", $"The members {string.Join(", ", groupMembers.Select(m => m.Name))} " +
+            $"must all be used if one is used. {string.Join(", ", missingMembers.Select(m => m.Name))} " +
+            $"{(missingMembers.Skip(1).Any() ? pluralToBe : singularToBe)} missing.", severity: CliDiagnosticSeverity.Error, null), []));
         }
     }
 }
diff --git a/src/System.CommandLine.Subsystems/Validation/RangeValidator.cs b/src/System.CommandLine.Subsystems/Validation/RangeValidator.cs
@@ -24,9 +24,7 @@ public override void Validate(object? value, CliValueSymbol valueSymbol,
         }
         if (valueCondition.MustHaveValidator)
         {
-            validationContext.AddError(new ParseError($"Range validator missing for {valueSymbol.Name}"));
+            validationContext.AddError(new CliDiagnostic(new("", "", $"Range validator missing for {valueSymbol.Name}", severity: CliDiagnosticSeverity.Error, null), [], cliSymbolResult: valueResult));
         }
     }
-
-
 }
diff --git a/src/System.CommandLine.Subsystems/Validation/ValidationContext.cs b/src/System.CommandLine.Subsystems/Validation/ValidationContext.cs
@@ -3,7 +3,6 @@
 
 using System.CommandLine.Parsing;
 using System.CommandLine.ValueSources;
-using static System.Runtime.InteropServices.JavaScript.JSType;
 
 namespace System.CommandLine.Validation;
 
@@ -24,7 +23,7 @@ internal ValidationContext(PipelineResult pipelineResult, ValidationSubsystem va
     /// Adds an error to the PipelineContext.
     /// </summary>
     /// <param name="error">The <see cref="ParseError"/> to add</param>
-    public void AddError(ParseError error)
+    public void AddError(CliDiagnostic error)
         => pipelineResult.AddError(error);
 
     /// <summary>
diff --git a/src/System.CommandLine.Subsystems/Validation/Validator.cs b/src/System.CommandLine.Subsystems/Validation/Validator.cs
@@ -31,11 +31,11 @@ internal Validator(string name, Type valueConditionType, params Type[] moreValue
     /// <remarks>
     /// This method needs to be evolved as we replace ParseError with CliError
     /// </remarks>
-    protected static List<ParseError> AddValidationError(ref List<ParseError>? parseErrors, string message, IEnumerable<object?> errorValues)
+    protected static List<CliDiagnostic> AddValidationError(ref List<CliDiagnostic>? parseErrors, string message, IEnumerable<object?> errorValues)
     {
         // TODO: Review the handling of errors. They are currently transient and returned by the Validate method, and to avoid allocating in the case of no errors (the common case) this method is used. This adds complexity to creating a new validator.
-        parseErrors ??= new List<ParseError>();
-        parseErrors.Add(new ParseError(message));
+        parseErrors ??= new List<CliDiagnostic>();
+        parseErrors.Add(new CliDiagnostic(new("", "", message, severity: CliDiagnosticSeverity.Error, null), []));
         return parseErrors;
     }
 
diff --git a/src/System.CommandLine.Subsystems/ValidationSubsystem.cs b/src/System.CommandLine.Subsystems/ValidationSubsystem.cs
@@ -81,7 +81,8 @@ private void ValidateValue(CliValueSymbol valueSymbol, ValidationContext validat
         var value = validationContext.GetValue(valueSymbol);
         var valueResult = validationContext.GetValueResult(valueSymbol);
 
-        do {
+        do
+        {
             ValidateValueCondition(value, valueSymbol, valueResult, enumerator.Current, validationContext);
         } while (enumerator.MoveNext());
     }
@@ -123,9 +124,9 @@ private void ValidateValueCondition(object? value, CliValueSymbol valueSymbol, C
         {
             if (condition.MustHaveValidator)
             {
-                validationContext.AddError(new ParseError($"{valueSymbol.Name} must have {condition.Name} validator."));
+                validationContext.AddError(new CliDiagnostic(new("", "", $"{valueSymbol.Name} must have {condition.Name} validator.", severity: CliDiagnosticSeverity.Error, null), [], cliSymbolResult: valueResult));
             }
-            return; 
+            return;
         }
         validator.Validate(value, valueSymbol, valueResult, condition, validationContext);
 
@@ -169,7 +170,7 @@ private void ValidateCommandCondition(CliCommandResult commandResult, CommandCon
         {
             if (condition.MustHaveValidator)
             {
-                validationContext.AddError(new ParseError($"{commandResult.Command.Name} must have {condition.Name} validator."));
+                validationContext.AddError(new CliDiagnostic(new("", "", $"{commandResult.Command.Name} must have {condition.Name} validator.", severity: CliDiagnosticSeverity.Error, null), []));
             }
             return;
         }
diff --git a/src/System.CommandLine.Subsystems/ValueConditions/Range.cs b/src/System.CommandLine.Subsystems/ValueConditions/Range.cs
@@ -40,8 +40,8 @@ internal Range(ValueSource<T>? lowerBound, ValueSource<T>? upperBound, RangeBoun
         LowerBound = lowerBound;
         UpperBound = upperBound;
         RangeBound = rangeBound;
-    }    
-    
+    }
+
     /// <inheritdoc/>
     public void Validate(object? value,
                          CliValueSymbol valueSymbol,
@@ -59,15 +59,15 @@ public void Validate(object? value,
             && validationContext.TryGetTypedValue(LowerBound, out var lowerValue)
             && comparableValue.CompareTo(lowerValue) < 0)
         {
-            validationContext.AddError(new ParseError($"The value for '{valueSymbol.Name}' is below the lower bound of {LowerBound}"));
+            validationContext.AddError(new CliDiagnostic(new("", "", $"The value for '{valueSymbol.Name}' is below the lower bound of {LowerBound}", severity: CliDiagnosticSeverity.Error, null), [], cliSymbolResult: valueResult));
         }
 
 
         if (UpperBound is not null
            && validationContext.TryGetTypedValue(UpperBound, out var upperValue)
            && comparableValue.CompareTo(upperValue) > 0)
         {
-            validationContext.AddError(new ParseError($"The value for '{valueSymbol.Name}' is above the upper bound of {UpperBound}"));
+            validationContext.AddError(new CliDiagnostic(new("", "", $"The value for '{valueSymbol.Name}' is above the upper bound of {UpperBound}", severity: CliDiagnosticSeverity.Error, null), [], cliSymbolResult: valueResult));
         }
     }
 
diff --git a/src/System.CommandLine/ParseResult.cs b/src/System.CommandLine/ParseResult.cs
@@ -3,9 +3,6 @@
 
 using System.Collections.Generic;
 using System.CommandLine.Parsing;
-using System.Linq;
-using System.Threading.Tasks;
-using System.Threading;
 
 namespace System.CommandLine
 {
@@ -39,7 +36,7 @@ internal ParseResult(
             */
             // TODO: unmatched tokens
             // List<CliToken>? unmatchedTokens,
-            List<ParseError>? errors,
+            List<CliDiagnostic>? errors,
             // TODO: commandLineText should be string array
             string? commandLineText = null //,
             // TODO: invocation
@@ -82,12 +79,11 @@ internal ParseResult(
             // TODO: unmatched tokens
             // _unmatchedTokens = unmatchedTokens is null ? Array.Empty<CliToken>() : unmatchedTokens;
 
-            Errors = errors is not null ? errors : Array.Empty<ParseError>();
+            Errors = errors is not null ? errors : Array.Empty<CliDiagnostic>();
         }
 
         public CliSymbol? GetSymbolByName(string name, bool valuesOnly = false)
         {
-
             symbolLookupByName ??= new SymbolLookupByName(this);
             return symbolLookupByName.TryGetSymbol(name, out var symbol, valuesOnly: valuesOnly)
                         ? symbol
diff --git a/src/System.CommandLine/Parsing/CliArgumentResultInternal.cs b/src/System.CommandLine/Parsing/CliArgumentResultInternal.cs
@@ -138,9 +138,9 @@ public void OnlyTake(int numberOfTokens)
         public override string ToString() => $"{nameof(CliArgumentResultInternal)} {Argument.Name}: {string.Join(" ", Tokens.Select(t => $"<{t.Value}>"))}";
 
         /// <inheritdoc/>
-        internal override void AddError(string errorMessage)
+        internal override void AddError(string errorMessage, CliValueResult valueResult)
         {
-            SymbolResultTree.AddError(new CliDiagnostic(new("", "", errorMessage, CliDiagnosticSeverity.Warning, null), [], symbolResult: AppliesToPublicSymbolResult));
+            SymbolResultTree.AddError(new CliDiagnostic(new("", "", errorMessage, CliDiagnosticSeverity.Warning, null), [], cliSymbolResult: valueResult));
             _conversionResult = ArgumentConversionResult.Failure(this, errorMessage, ArgumentConversionResultType.Failed);
         }
 
@@ -150,33 +150,37 @@ private ArgumentConversionResult ValidateAndConvert(bool useValidators)
             {
                 return ReportErrorIfNeeded(arityFailure);
             }
-// TODO: validators
-/*
-            // There is nothing that stops user-defined Validator from calling ArgumentResult.GetValueOrDefault.
-            // In such cases, we can't call the validators again, as it would create infinite recursion.
-            // GetArgumentConversionResult => ValidateAndConvert => Validator
-            //        => GetValueOrDefault => ValidateAndConvert (again)
-            if (useValidators && Argument.HasValidators)
-            {
-                for (var i = 0; i < Argument.Validators.Count; i++)
-                {
-                    Argument.Validators[i](this);
-                }
-
-                // validator provided by the user might report an error, which sets _conversionResult
-                if (_conversionResult is not null)
-                {
-                    return _conversionResult;
-                }
-            }
-*/
+            // TODO: validators
+            /*
+                        // There is nothing that stops user-defined Validator from calling ArgumentResult.GetValueOrDefault.
+                        // In such cases, we can't call the validators again, as it would create infinite recursion.
+                        // GetArgumentConversionResult => ValidateAndConvert => Validator
+                        //        => GetValueOrDefault => ValidateAndConvert (again)
+                        if (useValidators && Argument.HasValidators)
+                        {
+                            for (var i = 0; i < Argument.Validators.Count; i++)
+                            {
+                                Argument.Validators[i](this);
+                            }
+
+                            // validator provided by the user might report an error, which sets _conversionResult
+                            if (_conversionResult is not null)
+                            {
+                                return _conversionResult;
+                            }
+                        }
+            */
+
+            // TODO: defaults
+            /* 
             if (Parent!.UseDefaultValueFor(this))
             {
                 var defaultValue = Argument.GetDefaultValue(this);
 
                 // default value factory provided by the user might report an error, which sets _conversionResult
                 return _conversionResult ?? ArgumentConversionResult.Success(this, defaultValue);
             }
+            */
 
             if (Argument.ConvertArguments is null)
             {
@@ -218,7 +222,7 @@ ArgumentConversionResult ReportErrorIfNeeded(ArgumentConversionResult result)
             {
                 if (result.Result >= ArgumentConversionResultType.Failed)
                 {
-                    SymbolResultTree.AddError(new CliDiagnostic(new("ArgumentConversionResultTypeFailed", "Type Conversion Failed", result.ErrorMessage!, CliDiagnosticSeverity.Warning, null), [], symbolResult: AppliesToPublicSymbolResult));
+                    SymbolResultTree.AddError(new CliDiagnostic(new("ArgumentConversionResultTypeFailed", "Type Conversion Failed", result.ErrorMessage!, CliDiagnosticSeverity.Warning, null), [], cliSymbolResult: ValueResult));
                 }
 
                 return result;
diff --git a/src/System.CommandLine/Parsing/CliCommandResultInternal.cs b/src/System.CommandLine/Parsing/CliCommandResultInternal.cs
@@ -84,7 +84,7 @@ internal void Validate(bool completeValidation)
                 if (Command.HasSubcommands)
                 {
                     SymbolResultTree.InsertFirstError(
-                        new CliDiagnostic(new("validateSubCommandError", "Validation Error", LocalizationResources.RequiredCommandWasNotProvided(), CliDiagnosticSeverity.Warning, null), [], symbolResult: this));
+                        new CliDiagnostic(new("validateSubCommandError", "Validation Error", LocalizationResources.RequiredCommandWasNotProvided(), CliDiagnosticSeverity.Warning, null), [], valueResult: ));
                 }
 
                 // TODO: validators
@@ -171,10 +171,10 @@ private void ValidateOptions(bool completeValidation)
                 {
                     int errorsBefore = SymbolResultTree.ErrorCount;
 
-                    for (var j = 0; j < optionResult.Option.Validators.Count; j++)
-                    {
-                        optionResult.Option.Validators[j](optionResult);
-                    }
+                                    for (var j = 0; j < optionResult.Option.Validators.Count; j++)
+                                    {
+                                        optionResult.Option.Validators[j](optionResult);
+                                    }
 
                     if (errorsBefore != SymbolResultTree.ErrorCount)
                     {
diff --git a/src/System.CommandLine/Parsing/CliDiagnostic.cs b/src/System.CommandLine/Parsing/CliDiagnostic.cs
diff --git a/src/System.CommandLine/Parsing/CliSymbolResultInternal.cs b/src/System.CommandLine/Parsing/CliSymbolResultInternal.cs
diff --git a/src/System.CommandLine/Parsing/ParseOperation.cs b/src/System.CommandLine/Parsing/ParseOperation.cs
diff --git a/src/System.CommandLine/Parsing/SymbolResultTree.cs b/src/System.CommandLine/Parsing/SymbolResultTree.cs

Original file line number	Diff line number	Diff line change
`@@ -56,9 +56,9 @@ public void Help_display_can_be_disabled()`
`56`	`56`
`57`	`57`	`var result = rootCommand.Parse("oops", config);`
`58`	`58`
`59`		`- if (result.Action is ParseErrorAction parseError)`
	`59`	`+ if (result.Action is CliDiagnosticAction CliDiagnostic)`
`60`	`60`	`{`
`61`		`- parseError.ShowHelp = false;`
	`61`	`+ CliDiagnostic.ShowHelp = false;`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`result.Invoke();`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public override void Execute(PipelineResult pipelineResult)`
`33`	`33`	`pipelineResult.SetSuccess();`
`34`	`34`	`}`
`35`	`35`
`36`		`- public void Report(ConsoleHack consoleHack, IReadOnlyList<ParseError> errors)`
	`36`	`+ public void Report(ConsoleHack consoleHack, IReadOnlyList<CliDiagnostic> errors)`
`37`	`37`	`{`
`38`	`38`	`ConsoleHelpers.ResetTerminalForegroundColor();`
`39`	`39`	`ConsoleHelpers.SetTerminalForegroundRed();`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-// Copyright (c) .NET Foundation and contributors. All rights reserved.`
	`1`	`+// Copyright (c) .NET Foundation and contributors. All rights reserved.`
`2`	`2`	`// Licensed under the MIT license. See LICENSE file in the project root for full license information.`
`3`	`3`
`4`	`4`	`using System.CommandLine.Parsing;`
`@@ -9,8 +9,8 @@ namespace System.CommandLine;`
`9`	`9`	`public class PipelineResult`
`10`	`10`	`{`
`11`	`11`	`// TODO: Try to build workflow so it is illegal to create this without a ParseResult`
`12`		`- private readonly List<ParseError> errors = [];`
`13`		`- private ValueProvider valueProvider { get; }`
	`12`	`+ private readonly List<CliDiagnostic> errors = [];`
	`13`	`+ private ValueProvider valueProvider { get; }`
`14`	`14`
`15`	`15`	`public PipelineResult(ParseResult parseResult, string rawInput, Pipeline? pipeline, ConsoleHack? consoleHack = null)`
`16`	`16`	`{`
`@@ -44,18 +44,18 @@ public PipelineResult(ParseResult parseResult, string rawInput, Pipeline? pipeli`
`44`	`44`	`=> ParseResult.GetValueResult(valueSymbol);`
`45`	`45`
`46`	`46`
`47`		`- public void AddErrors(IEnumerable<ParseError> errors)`
	`47`	`+ public void AddErrors(IEnumerable<CliDiagnostic> errors)`
`48`	`48`	`{`
`49`	`49`	`if (errors is not null)`
`50`	`50`	`{`
`51`	`51`	`this.errors.AddRange(errors);`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
`55`		`- public void AddError(ParseError error)`
	`55`	`+ public void AddError(CliDiagnostic error)`
`56`	`56`	`=> errors.Add(error);`
`57`	`57`
`58`		`- public IEnumerable<ParseError> GetErrors(bool excludeParseErrors = false)`
	`58`	`+ public IEnumerable<CliDiagnostic> GetErrors(bool excludeParseErrors = false)`
`59`	`59`	`=> excludeParseErrors \|\| ParseResult is null`
`60`	`60`	`? errors`
`61`	`61`	`: ParseResult.Errors.Concat(errors);`
Original file line number	Diff line number	Diff line change
`@@ -44,9 +44,9 @@ public override void Validate(CliCommandResult commandResult,`
`44`	`44`	`// TODO: Rework to allow localization`
`45`	`45`	`var pluralToBe = "are";`
`46`	`46`	`var singularToBe = "is";`
`47`		`- validationContext.AddError(new ParseError( $"The members {string.Join(", ", groupMembers.Select(m => m.Name))} " +`
`48`		`- $"must all be used if one is used. {string.Join(", ", missingMembers.Select(m => m.Name))} " +`
`49`		`- $"{(missingMembers.Skip(1).Any() ? pluralToBe : singularToBe)} missing."));`
	`47`	`+ validationContext.AddError(new CliDiagnostic(new("", "", $"The members {string.Join(", ", groupMembers.Select(m => m.Name))} " +`
	`48`	`+ $"must all be used if one is used. {string.Join(", ", missingMembers.Select(m => m.Name))} " +`
	`49`	`+ $"{(missingMembers.Skip(1).Any() ? pluralToBe : singularToBe)} missing.", severity: CliDiagnosticSeverity.Error, null), []));`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,9 +24,7 @@ public override void Validate(object? value, CliValueSymbol valueSymbol,`
`24`	`24`	`}`
`25`	`25`	`if (valueCondition.MustHaveValidator)`
`26`	`26`	`{`
`27`		`- validationContext.AddError(new ParseError($"Range validator missing for {valueSymbol.Name}"));`
	`27`	`+ validationContext.AddError(new CliDiagnostic(new("", "", $"Range validator missing for {valueSymbol.Name}", severity: CliDiagnosticSeverity.Error, null), [], cliSymbolResult: valueResult));`
`28`	`28`	`}`
`29`	`29`	`}`
`30`		`-`
`31`		`-`
`32`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,11 +31,11 @@ internal Validator(string name, Type valueConditionType, params Type[] moreValue`
`31`	`31`	`/// <remarks>`
`32`	`32`	`/// This method needs to be evolved as we replace ParseError with CliError`
`33`	`33`	`/// </remarks>`
`34`		`- protected static List<ParseError> AddValidationError(ref List<ParseError>? parseErrors, string message, IEnumerable<object?> errorValues)`
	`34`	`+ protected static List<CliDiagnostic> AddValidationError(ref List<CliDiagnostic>? parseErrors, string message, IEnumerable<object?> errorValues)`
`35`	`35`	`{`
`36`	`36`	`// TODO: Review the handling of errors. They are currently transient and returned by the Validate method, and to avoid allocating in the case of no errors (the common case) this method is used. This adds complexity to creating a new validator.`
`37`		`- parseErrors ??= new List<ParseError>();`
`38`		`- parseErrors.Add(new ParseError(message));`
	`37`	`+ parseErrors ??= new List<CliDiagnostic>();`
	`38`	`+ parseErrors.Add(new CliDiagnostic(new("", "", message, severity: CliDiagnosticSeverity.Error, null), []));`
`39`	`39`	`return parseErrors;`
`40`	`40`	`}`
`41`	`41`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,8 @@ private void ValidateValue(CliValueSymbol valueSymbol, ValidationContext validat`
`81`	`81`	`var value = validationContext.GetValue(valueSymbol);`
`82`	`82`	`var valueResult = validationContext.GetValueResult(valueSymbol);`
`83`	`83`
`84`		`- do {`
	`84`	`+ do`
	`85`	`+ {`
`85`	`86`	`ValidateValueCondition(value, valueSymbol, valueResult, enumerator.Current, validationContext);`
`86`	`87`	`} while (enumerator.MoveNext());`
`87`	`88`	`}`
`@@ -123,9 +124,9 @@ private void ValidateValueCondition(object? value, CliValueSymbol valueSymbol, C`
`123`	`124`	`{`
`124`	`125`	`if (condition.MustHaveValidator)`
`125`	`126`	`{`
`126`		`- validationContext.AddError(new ParseError($"{valueSymbol.Name} must have {condition.Name} validator."));`
	`127`	`+ validationContext.AddError(new CliDiagnostic(new("", "", $"{valueSymbol.Name} must have {condition.Name} validator.", severity: CliDiagnosticSeverity.Error, null), [], cliSymbolResult: valueResult));`
`127`	`128`	`}`
`128`		`- return;`
	`129`	`+ return;`
`129`	`130`	`}`
`130`	`131`	`validator.Validate(value, valueSymbol, valueResult, condition, validationContext);`
`131`	`132`
`@@ -169,7 +170,7 @@ private void ValidateCommandCondition(CliCommandResult commandResult, CommandCon`
`169`	`170`	`{`
`170`	`171`	`if (condition.MustHaveValidator)`
`171`	`172`	`{`
`172`		`- validationContext.AddError(new ParseError($"{commandResult.Command.Name} must have {condition.Name} validator."));`
	`173`	`+ validationContext.AddError(new CliDiagnostic(new("", "", $"{commandResult.Command.Name} must have {condition.Name} validator.", severity: CliDiagnosticSeverity.Error, null), []));`
`173`	`174`	`}`
`174`	`175`	`return;`
`175`	`176`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,8 +40,8 @@ internal Range(ValueSource<T>? lowerBound, ValueSource<T>? upperBound, RangeBoun`
`40`	`40`	`LowerBound = lowerBound;`
`41`	`41`	`UpperBound = upperBound;`
`42`	`42`	`RangeBound = rangeBound;`
`43`		`- }`
`44`		`-`
	`43`	`+ }`
	`44`	`+`
`45`	`45`	`/// <inheritdoc/>`
`46`	`46`	`public void Validate(object? value,`
`47`	`47`	`CliValueSymbol valueSymbol,`
`@@ -59,15 +59,15 @@ public void Validate(object? value,`
`59`	`59`	`&& validationContext.TryGetTypedValue(LowerBound, out var lowerValue)`
`60`	`60`	`&& comparableValue.CompareTo(lowerValue) < 0)`
`61`	`61`	`{`
`62`		`- validationContext.AddError(new ParseError($"The value for '{valueSymbol.Name}' is below the lower bound of {LowerBound}"));`
	`62`	`+ validationContext.AddError(new CliDiagnostic(new("", "", $"The value for '{valueSymbol.Name}' is below the lower bound of {LowerBound}", severity: CliDiagnosticSeverity.Error, null), [], cliSymbolResult: valueResult));`
`63`	`63`	`}`
`64`	`64`
`65`	`65`
`66`	`66`	`if (UpperBound is not null`
`67`	`67`	`&& validationContext.TryGetTypedValue(UpperBound, out var upperValue)`
`68`	`68`	`&& comparableValue.CompareTo(upperValue) > 0)`
`69`	`69`	`{`
`70`		`- validationContext.AddError(new ParseError($"The value for '{valueSymbol.Name}' is above the upper bound of {UpperBound}"));`
	`70`	`+ validationContext.AddError(new CliDiagnostic(new("", "", $"The value for '{valueSymbol.Name}' is above the upper bound of {UpperBound}", severity: CliDiagnosticSeverity.Error, null), [], cliSymbolResult: valueResult));`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`