From a432bf94ec5cd44f836fac6f5aecccdc7a02d39a Mon Sep 17 00:00:00 2001
From: Wind <WindSoilder@outlook.com>
Date: Tue, 13 Aug 2024 06:50:12 +0800
Subject: [PATCH] support SyntaxShape::OneOf in named args (#13553)

# Description
Fixes: #13253

The issue is because nushell use `parse_value` to parse named args, but
`parse_value` doesn't parse `OneOf` syntax shape.

# User-Facing Changes
`OneOf` in named args should works again.

# Tests + Formatting
I think it's hard to add a test, because nushell doesn't support `oneof`
syntax in custom command yet.

# After Submitting
NaN
---
 crates/nu-parser/src/parser.rs | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/crates/nu-parser/src/parser.rs b/crates/nu-parser/src/parser.rs
index 3470b07e14..a47873c392 100644
--- a/crates/nu-parser/src/parser.rs
+++ b/crates/nu-parser/src/parser.rs
@@ -4701,6 +4701,15 @@ pub fn parse_value(
             | SyntaxShape::String
             | SyntaxShape::GlobPattern
             | SyntaxShape::ExternalArgument => {}
+            SyntaxShape::OneOf(possible_shapes) => {
+                if !possible_shapes
+                    .iter()
+                    .any(|s| matches!(s, SyntaxShape::List(_)))
+                {
+                    working_set.error(ParseError::Expected("non-[] value", span));
+                    return Expression::garbage(working_set, span);
+                }
+            }
             _ => {
                 working_set.error(ParseError::Expected("non-[] value", span));
                 return Expression::garbage(working_set, span);
@@ -4778,6 +4787,31 @@ pub fn parse_value(
         }
 
         SyntaxShape::ExternalArgument => parse_regular_external_arg(working_set, span),
+        SyntaxShape::OneOf(possible_shapes) => {
+            for s in possible_shapes {
+                let starting_error_count = working_set.parse_errors.len();
+                let value = parse_value(working_set, span, s);
+
+                if starting_error_count == working_set.parse_errors.len() {
+                    return value;
+                } else if let Some(
+                    ParseError::Expected(..) | ParseError::ExpectedWithStringMsg(..),
+                ) = working_set.parse_errors.last()
+                {
+                    working_set.parse_errors.truncate(starting_error_count);
+                    continue;
+                }
+            }
+
+            if working_set.parse_errors.is_empty() {
+                working_set.error(ParseError::ExpectedWithStringMsg(
+                    format!("one of a list of accepted shapes: {possible_shapes:?}"),
+                    span,
+                ));
+            }
+
+            Expression::garbage(working_set, span)
+        }
 
         SyntaxShape::Any => {
             if bytes.starts_with(b"[") {