Remove Argument.AllowedValues, use Validator to implement the logic

src/System.CommandLine/Argument.cs

@@ -39,8 +39,6 @@ protected Argument(string? name = null, string? description = null)
             Description = description;
         }
 
-        internal HashSet<string>? AllowedValues { get; private set; }
-
         /// <summary>
         /// Gets or sets the arity of the argument.
         /// </summary>
@@ -105,14 +103,15 @@ private protected override string DefaultName
             }
         }
 
-        internal List<Action<ArgumentResult>> Validators => _validators ??= new ();
+        internal IReadOnlyList<Action<ArgumentResult>> Validators
+            => _validators is null ? Array.Empty<Action<ArgumentResult>>() : _validators;
 
         /// <summary>
         /// Adds a custom validator to the argument. Validators can be used
         /// to provide custom errors based on user input.
         /// </summary>
         /// <param name="validate">The action to validate the parsed argument.</param>
-        public void AddValidator(Action<ArgumentResult> validate) => Validators.Add(validate);
+        public void AddValidator(Action<ArgumentResult> validate) => (_validators ??= new()).Add(validate);
 
         /// <summary>
         /// Gets the default value for the argument.
@@ -179,16 +178,6 @@ public void SetDefaultValueFactory(Func<ArgumentResult, object?> defaultValueFac
             Arity = ArgumentArity.Zero
         };
 
-        internal void AddAllowedValues(IReadOnlyList<string> values)
-        {
-            if (AllowedValues is null)
-            {
-                AllowedValues = new HashSet<string>();
-            }
-
-            AllowedValues.UnionWith(values);
-        }
-
         /// <inheritdoc />
         public override IEnumerable<CompletionItem> GetCompletions(CompletionContext context)
         {
@@ -244,12 +233,30 @@ public Argument AddCompletions(Func<CompletionContext, IEnumerable<CompletionIte
         /// <returns>The configured argument.</returns>
         public Argument AcceptOnlyFromAmong(params string[] values)
         {
-            AllowedValues?.Clear();
-            AddAllowedValues(values);
-            Completions.Clear();
-            Completions.Add(values);
+            if (values is not null && values.Length > 0)
+            {
+                AddValidator(UnrecognizedArgumentError);
+                Completions.Clear();
+                Completions.Add(values);
+            }
 
             return this;
+
+            void UnrecognizedArgumentError(ArgumentResult argumentResult)
+            {
+                for (var i = 0; i < argumentResult.Tokens.Count; i++)
+                {
+                    var token = argumentResult.Tokens[i];
+
+                    if (token.Symbol is null || token.Symbol == this)
+                    {
+                        if (!values.Contains(token.Value))
+                        {
+                            argumentResult.ErrorMessage = argumentResult.LocalizationResources.UnrecognizedArgument(token.Value, values);
+                        }
+                    }
+                }
+            }
         }
 
         /// <summary>

src/System.CommandLine/Option.cs

@@ -242,10 +242,7 @@ public override IEnumerable<CompletionItem> GetCompletions(CompletionContext con
         /// <returns>The configured option.</returns>
         public Option AcceptOnlyFromAmong(params string[] values)
         {
-            Argument.AllowedValues?.Clear();
-            Argument.AddAllowedValues(values);
-            Argument.Completions.Clear();
-            Argument.Completions.Add(values);
+            Argument.AcceptOnlyFromAmong(values);
 
             return this;
         }

src/System.CommandLine/Parsing/ArgumentResult.cs

@@ -83,7 +83,7 @@ public void OnlyTake(int numberOfTokens)
 
                 if (!string.IsNullOrWhiteSpace(ErrorMessage))
                 {
-                    return new ParseError(ErrorMessage!, this);
+                    return new ParseError(ErrorMessage!, Parent is OptionResult option ? option : this);
                 }
             }
 

src/System.CommandLine/Parsing/ParseResultVisitor.cs

@@ -505,9 +505,7 @@ private void ValidateAndConvertArgumentResult(ArgumentResult argumentResult)
         {
             var argument = argumentResult.Argument;
 
-            var parseError =
-                argumentResult.Parent?.UnrecognizedArgumentError(argument) ??
-                argumentResult.CustomError(argument);
+            var parseError = argumentResult.CustomError(argument);
 
             if (parseError is { })
             {

src/System.CommandLine/Parsing/SymbolResult.cs

@@ -185,29 +185,5 @@ internal ArgumentResult GetOrCreateDefaultArgumentResult(Argument argument) =>
 
         /// <inheritdoc/>
         public override string ToString() => $"{GetType().Name}: {this.Token()} {string.Join(" ", Tokens.Select(t => t.Value))}";
-
-        internal ParseError? UnrecognizedArgumentError(Argument argument)
-        {
-            if (argument.AllowedValues?.Count > 0 &&
-                Tokens.Count > 0)
-            {
-                for (var i = 0; i < Tokens.Count; i++)
-                {
-                    var token = Tokens[i];
-
-                    if (token.Symbol is null || token.Symbol == argument)
-                    {
-                        if (!argument.AllowedValues.Contains(token.Value))
-                        {
-                            return new ParseError(
-                                LocalizationResources.UnrecognizedArgument(token.Value, argument.AllowedValues),
-                                this);
-                        }
-                    }
-                }
-            }
-
-            return null;
-        }
     }
 }