fix(PR-6192): preserve nested keyword choices as unsupported

Route the parser's strict nested-choice outcome through the subject AST so imperative fallback cannot reinterpret it as fixed keyword grants.

Co-authored-by: Try everything <tryeverything24@users.noreply.github.com>

Author: matthewevans

crates/engine/src/parser/oracle_effect/subject.rs

@@ -142,17 +142,35 @@ pub(super) fn try_parse_subject_predicate_ast(
         return Some(clause);
     }
 
-    if let Some(clause) = try_parse_subject_continuous_clause(text, ctx) {
-        return Some(subject_predicate_ast_from_clause(
-            text,
-            clause,
-            |effect, duration, sub_ability| PredicateAst::Continuous {
-                effect,
-                duration,
-                sub_ability,
-            },
-            ctx,
-        ));
+    match try_parse_subject_continuous_clause(text, ctx) {
+        Ok(Some(clause)) => {
+            return Some(subject_predicate_ast_from_clause(
+                text,
+                clause,
+                |effect, duration, sub_ability| PredicateAst::Continuous {
+                    effect,
+                    duration,
+                    sub_ability,
+                },
+                ctx,
+            ));
+        }
+        Ok(None) => {}
+        // `parse_keyword_choice_grant` recognized an outer menu containing an
+        // inner player choice. Preserve that unsupported semantic instead of
+        // allowing the imperative fallback to reinterpret it as fixed keywords.
+        Err(()) => {
+            return Some(subject_predicate_ast_from_clause(
+                text,
+                super::parsed_clause(Effect::unimplemented("nested keyword choice", text)),
+                |effect, duration, sub_ability| PredicateAst::Continuous {
+                    effect,
+                    duration,
+                    sub_ability,
+                },
+                ctx,
+            ));
+        }
     }
 
     // CR 613.4b + CR 613.1f: "[subject]'s base power and toughness become N/M and
@@ -469,8 +487,10 @@ fn try_parse_contracted_subject_additive_type_clause(
 fn try_parse_subject_continuous_clause(
     text: &str,
     ctx: &mut ParseContext,
-) -> Option<ParsedEffectClause> {
-    let verb_start = find_predicate_start(text)?;
+) -> Result<Option<ParsedEffectClause>, ()> {
+    let Some(verb_start) = find_predicate_start(text) else {
+        return Ok(None);
+    };
     // CR 608.2c: An additive "also" sitting between a filter subject and its
     // continuous verb ("Kithkin creatures you control *also* gain first strike
     // until end of turn") is a natural-language connector with no semantic
@@ -489,12 +509,14 @@ fn try_parse_subject_continuous_clause(
     // the continuous arm misclassifies imperatives like "you get an emblem
     // with \"…\"" as `get +X/+X`-style P/T modifications.
     if subject.eq_ignore_ascii_case("you") {
-        return None;
+        return Ok(None);
     }
     if let Some(clause) = try_parse_additive_type_continuous_clause(subject, predicate, ctx) {
-        return Some(clause);
+        return Ok(Some(clause));
     }
-    let application = parse_subject_application(subject, ctx)?;
+    let Some(application) = parse_subject_application(subject, ctx) else {
+        return Ok(None);
+    };
     build_continuous_clause(application, predicate, ctx)
 }
 
@@ -3527,7 +3549,7 @@ fn build_continuous_clause(
     application: SubjectApplication,
     predicate: &str,
     ctx: &ParseContext,
-) -> Option<ParsedEffectClause> {
+) -> Result<Option<ParsedEffectClause>, ()> {
     let normalized = deconjugate_verb(predicate);
 
     // B15: Guard against "becomes" predicates routing through continuous clause parsing.
@@ -3537,21 +3559,21 @@ fn build_continuous_clause(
         .parse(normalized.as_str())
         .is_ok()
     {
-        return None;
+        return Ok(None);
     }
     if tag::<_, _, OracleError<'_>>("create ")
         .parse(normalized.as_str())
         .is_ok()
     {
-        return None;
+        return Ok(None);
     }
 
     // Try the full predicate first (simple pump with no compound).
     if let Some((power, toughness, duration)) =
         super::lower::parse_pump_clause_with_context(&normalized, ctx)
     {
         let effect = build_pump_effect(&application, power, toughness);
-        return Some(ParsedEffectClause {
+        return Ok(Some(ParsedEffectClause {
             effect,
             duration,
             sub_ability: None,
@@ -3560,23 +3582,23 @@ fn build_continuous_clause(
             condition: None,
             optional: false,
             unless_pay: None,
-        });
+        }));
     }
 
     // Compound: "get +1/+1 until end of turn and you gain 1 life"
     // Split on " and " that follows a duration marker, producing a pump
     // with a chained sub_ability for the remainder.
     if let Some(clause) = try_split_pump_compound(&normalized, &application, ctx) {
-        return Some(clause);
+        return Ok(Some(clause));
     }
 
     match build_keyword_choice_clause(&application, &normalized) {
-        Ok(Some(clause)) => return Some(clause),
+        Ok(Some(clause)) => return Ok(Some(clause)),
         Ok(None) => {}
         // A nested keyword choice cannot be represented by a fixed AddKeyword.
         // Do not fall through to generic static parsing, which would turn the
         // menu into simultaneous grants and falsely mark the card supported.
-        Err(()) => return None,
+        Err(()) => return Err(()),
     }
 
     // Strip "where X is..." and "for each..." suffixes before extracting duration,
@@ -3595,7 +3617,7 @@ fn build_continuous_clause(
     if let Some(static_abilities) =
         build_defender_attack_continuous_compound(&application, predicate_text)
     {
-        return Some(ParsedEffectClause {
+        return Ok(Some(ParsedEffectClause {
             effect: Effect::GenericEffect {
                 static_abilities,
                 duration: duration.clone(),
@@ -3608,12 +3630,12 @@ fn build_continuous_clause(
             condition: None,
             optional: false,
             unless_pay: None,
-        });
+        }));
     }
 
     let modifications = parse_continuous_modifications(predicate_text);
     if modifications.is_empty() {
-        return None;
+        return Ok(None);
     }
 
     // CR 702.62b + CR 611.2a + CR 611.2c: A "gains suspend" grant onto an exiled
@@ -3638,7 +3660,7 @@ fn build_continuous_clause(
 
     if let Some((power, toughness)) = extract_pump_modifiers(&modifications) {
         let effect = build_pump_effect(&application, power, toughness);
-        return Some(ParsedEffectClause {
+        return Ok(Some(ParsedEffectClause {
             effect,
             duration,
             sub_ability: None,
@@ -3647,7 +3669,7 @@ fn build_continuous_clause(
             condition: None,
             optional: false,
             unless_pay: None,
-        });
+        }));
     }
 
     let affected = static_affected_for_application(&application);
@@ -3674,7 +3696,7 @@ fn build_continuous_clause(
                 .description(predicate_text.to_string())]
         };
 
-    Some(ParsedEffectClause {
+    Ok(Some(ParsedEffectClause {
         effect: Effect::GenericEffect {
             static_abilities,
             duration: duration.clone(),
@@ -3687,7 +3709,7 @@ fn build_continuous_clause(
         condition: None,
         optional: false,
         unless_pay: None,
-    })
+    }))
 }
 
 /// CR 702.62a + CR 702.62b + CR 611.2a + CR 608.2c: Recognize the plural,
@@ -3766,6 +3788,8 @@ pub(super) fn try_parse_exiled_this_way_keyword_grant(
         is_optional: false,
     };
     build_continuous_clause(application, after_head.trim(), ctx)
+        .ok()
+        .flatten()
 }
 
 /// Strip "for each [clause]" suffix from text so that duration extraction can find