gqlite 1.8.1 → 1.8.2

data/ext/gqlparser/src/oc/parser.rs

@@ -1035,11 +1035,11 @@ fn array_literal(input: Input) -> OCPResult<Input, ast::Expression>
   .parse(input)
 }
 
-fn node_pattern(input: Input) -> OCPResult<Input, ast::NodePattern>
+fn node_pattern<T: EdgeMode>(input: Input) -> OCPResult<Input, ast::NodePattern>
 {
-  delimited(
-    token(Token::StartParenthesis),
-    map(
+  map_res_failure(
+    delimited(
+      token(Token::StartParenthesis),
       (
         // Optional variable
         opt(ident),
@@ -1047,19 +1047,28 @@ fn node_pattern(input: Input) -> OCPResult<Input, ast::NodePattern>
         opt(labels),
         // Optional properties map or parameter
         opt(properties),
+        // Optional inline predicate: WHERE <expr>
+        opt(preceded(token(Token::Where), expression)),
       ),
-      |(ident, labels, properties)| ast::NodePattern {
+      token(Token::EndParenthesis),
+    ),
+    |(ident, labels, properties, predicate)| {
+      if predicate.is_some() && !T::ALLOW_PREDICATE
+      {
+        return Err(ErrorKind::CreatingWithPredicate);
+      }
+      Ok(ast::NodePattern {
         variable: input
           .1
           .identifiers
           .create_variable_from_name_optional(ident),
         labels: labels.unwrap_or(ast::LabelExpression::None),
         properties,
-      },
-    ),
-    token(Token::EndParenthesis),
+        predicate,
+      })
+    },
   )
-  .parse(input)
+  .parse(input.clone())
 }
 
 enum EdgeDirection
@@ -1073,6 +1082,7 @@ trait EdgeMode
 {
   const ALLOW_UNDIRECTED: bool;
   const ALLOW_LABEL_ALTERNATIVE: bool;
+  const ALLOW_PREDICATE: bool;
 }
 
 struct AllowUndirected;
@@ -1080,6 +1090,7 @@ impl EdgeMode for AllowUndirected
 {
   const ALLOW_UNDIRECTED: bool = true;
   const ALLOW_LABEL_ALTERNATIVE: bool = true;
+  const ALLOW_PREDICATE: bool = true;
 }
 
 struct DisallowUndirected;
@@ -1087,6 +1098,7 @@ impl EdgeMode for DisallowUndirected
 {
   const ALLOW_UNDIRECTED: bool = false;
   const ALLOW_LABEL_ALTERNATIVE: bool = false;
+  const ALLOW_PREDICATE: bool = false;
 }
 
 struct EdgePattern
@@ -1095,7 +1107,8 @@ struct EdgePattern
   edge_variable: Option<ast::VariableIdentifier>,
   labels: ast::LabelExpression,
   properties: Option<ast::Expression>,
-  recursive_range: Option<std::ops::Range<usize>>,
+  predicate: Option<ast::Expression>,
+  quantifier: Option<std::ops::Range<usize>>,
   destination_node: ast::NodePattern,
 }
 
@@ -1126,6 +1139,78 @@ fn edge_range(input: Input) -> OCPResult<Input, std::ops::Range<usize>>
   .parse(input)
 }
 
+fn quantifier_suffix(input: Input) -> OCPResult<Input, std::ops::Range<usize>>
+{
+  alt((
+    delimited(
+      token(Token::StartBrace),
+      map(
+        (opt(int), opt(preceded(token(Token::Comma), opt(int)))),
+        |(min, rest)| match (min, rest)
+        {
+          // {n} - exact count
+          (Some(n), None) => (n as usize)..(n as usize),
+          // {min,max}
+          (Some(min), Some(Some(max))) => (min as usize)..(max as usize),
+          // {min,}
+          (Some(min), Some(None)) => (min as usize)..usize::MAX,
+          // {,max}
+          (None, Some(Some(max))) => 0..(max as usize),
+          // {,} or {} - both omitted; treat as equivalent to bare `*`.
+          // Flagging rather than silently deciding: `{}`/`{,}` aren't
+          // shown in the source docs at all, so this is an assumption,
+          // not a confirmed spec reading.
+          (None, Some(None)) | (None, None) => 0..usize::MAX,
+        },
+      ),
+      token(Token::EndBrace),
+    ),
+    // Bare `*`: zero-or-more, spec-conformant (NOT the legacy `[*]`
+    // default of 1.. — that default is preserved unchanged for the
+    // legacy in-bracket syntax specifically; see WI4).
+    map(token(Token::Star), |_| 0..usize::MAX),
+    // Bare `+`: one-or-more.
+    map(token(Token::Plus), |_| 1..usize::MAX),
+  ))
+  .parse(input)
+}
+
+fn path_selector(input: Input) -> OCPResult<Input, ast::PathSelector>
+{
+  alt((
+    // ALL SHORTEST
+    map(pair(token(Token::All), token(Token::Shortest)), |_| {
+      ast::PathSelector::AllShortest
+    }),
+    // ALL (bare, no SHORTEST following)
+    // NOTE: Must be tried after ALL SHORTEST, since ALL is consumed by both.
+    // The pair combinator will try ALL SHORTEST first, and only if SHORTEST
+    // doesn't follow will this branch be reached.
+    map(token(Token::All), |_| ast::PathSelector::All),
+    // SHORTEST <k> GROUPS
+    // NOTE: Must be tried before bare SHORTEST <k>, since expression alone
+    // would greedily consume <k> and leave GROUPS unconsumed, falling through
+    // to a confusing trailing-token error.
+    map(
+      (token(Token::Shortest), expression, token(Token::Groups)),
+      |(_, k, _)| ast::PathSelector::ShortestGroups(k),
+    ),
+    // SHORTEST GROUP (singular sugar, k defaults to 1)
+    map(pair(token(Token::Shortest), token(Token::Group)), |_| {
+      ast::PathSelector::ShortestGroups(ast::Expression::Value(ast::Value { value: 1.into() }))
+    }),
+    // SHORTEST <k>
+    map(pair(token(Token::Shortest), expression), |(_, k)| {
+      ast::PathSelector::Shortest(k)
+    }),
+    // ANY SHORTEST | ANY
+    map(pair(token(Token::Any), opt(token(Token::Shortest))), |_| {
+      ast::PathSelector::Any
+    }),
+  ))
+  .parse(input)
+}
+
 fn edge_pattern<T: EdgeMode>(input: Input) -> OCPResult<Input, EdgePattern>
 {
   map_res_failure(
@@ -1145,6 +1230,8 @@ fn edge_pattern<T: EdgeMode>(input: Input) -> OCPResult<Input, EdgePattern>
         opt(edge_range),
         // Optional properties map or parameter
         opt(properties),
+        // Optional inline predicate: WHERE <expr>
+        opt(preceded(token(Token::Where), expression)),
         token(Token::EndBracket),
       )),
       alt((
@@ -1152,22 +1239,33 @@ fn edge_pattern<T: EdgeMode>(input: Input) -> OCPResult<Input, EdgePattern>
         map(token(Token::Minus), |_| EdgeDirection::Undirected),
         map(token(Token::LeftArrow), |_| EdgeDirection::Left),
       )),
-      node_pattern, // Right node
+      opt(quantifier_suffix),
+      node_pattern::<T>, // Right node
     ),
-    |(first_direction, edge_pattern, second_direction, destination_node)| {
-      let (edge_variable, recursive_range, labels, properties) = match edge_pattern
+    |(first_direction, edge_pattern, second_direction, new_quantifier, destination_node)| {
+      let (edge_variable, recursive_range, labels, properties, predicate) = match edge_pattern
       {
-        Some((_, var, labels, recursive_range, properties, _)) =>
+        Some((_, var, labels, recursive_range, properties, predicate, _)) =>
         {
-          (var, recursive_range, labels, properties)
+          (var, recursive_range, labels, properties, predicate)
         }
-        None => (None, None, None, None),
+        None => (None, None, None, None, None),
       };
       let labels = labels.unwrap_or(ast::LabelExpression::None);
       if !T::ALLOW_LABEL_ALTERNATIVE && !labels.is_all_inclusive()
       {
         return Err(ErrorKind::NoSingleRelationshipType);
       }
+      if predicate.is_some() && !T::ALLOW_PREDICATE
+      {
+        return Err(ErrorKind::CreatingWithPredicate);
+      }
+      let quantifier = match (recursive_range, new_quantifier)
+      {
+        (Some(_), Some(_)) => return Err(ErrorKind::ConflictingQuantifiers),
+        (Some(r), None) | (None, Some(r)) => Some(r),
+        (None, None) => None,
+      };
       let edge_direction = match (first_direction, second_direction)
       {
         (EdgeDirection::Right, EdgeDirection::Right)
@@ -1198,186 +1296,844 @@ fn edge_pattern<T: EdgeMode>(input: Input) -> OCPResult<Input, EdgePattern>
         edge_variable,
         labels,
         properties,
+        predicate,
         destination_node,
-        recursive_range,
+        quantifier,
       })
     },
   )
   .parse(input.clone())
 }
 
+struct GroupPattern
+{
+  group: Vec<ast::Pattern>,
+  group_where: Option<ast::Expression>,
+  quantifier: std::ops::Range<usize>,
+  destination_node: ast::NodePattern,
+}
+
+fn group_pattern<T: EdgeMode>(input: Input) -> OCPResult<Input, GroupPattern>
+{
+  map_res_failure(
+    (
+      delimited(
+        token(Token::StartParenthesis),
+        (
+          node_or_edges_patterns::<T>,
+          opt(preceded(token(Token::Where), expression)),
+        ),
+        token(Token::EndParenthesis),
+      ),
+      quantifier_suffix,
+      node_pattern::<T>,
+    ),
+    |((group, group_where), quantifier, destination_node)| {
+      // Check that the group has at least one edge
+      if !group.iter().any(|p| matches!(p, ast::Pattern::Edge(_)))
+      {
+        return Err(ErrorKind::EmptyQuantifiedGroup);
+      }
+      Ok(GroupPattern {
+        group,
+        group_where,
+        quantifier,
+        destination_node,
+      })
+    },
+  )
+  .parse(input)
+}
+
+enum ChainElement
+{
+  Edge(EdgePattern),
+  Group(GroupPattern),
+}
+
 fn node_or_edges_patterns<T: EdgeMode>(input: Input) -> OCPResult<Input, Vec<ast::Pattern>>
 {
-  let (input, node) = node_pattern(input)?;
+  let (input, node) = node_pattern::<T>(input)?;
 
-  let (input, edges) = many0(edge_pattern::<T>).parse(input)?;
+  let (input, elements) = many0(alt((
+    map(edge_pattern::<T>, ChainElement::Edge),
+    map(group_pattern::<T>, ChainElement::Group),
+  )))
+  .parse(input)?;
 
-  if edges.is_empty()
+  if elements.is_empty()
   {
     Ok((input, vec![ast::Pattern::Node(node)]))
   }
   else
   {
     let mut current_node = node;
-    let mut iterator = edges.into_iter().peekable();
+    let mut iterator = elements.into_iter().peekable();
     let mut patterns = Vec::new();
-    while let Some(edge) = iterator.next()
+    while let Some(element) = iterator.next()
     {
-      let EdgePattern {
-        edge_direction,
-        edge_variable,
-        labels,
-        properties,
-        mut destination_node,
-        recursive_range,
-      } = edge;
-      if destination_node.variable.is_none() && iterator.peek().is_some()
+      match element
       {
-        destination_node.variable = Some(input.1.identifiers.create_anonymous_variable());
+        ChainElement::Edge(edge) =>
+        {
+          let EdgePattern {
+            edge_direction,
+            edge_variable,
+            labels,
+            properties,
+            predicate,
+            mut destination_node,
+            quantifier,
+          } = edge;
+          if destination_node.variable.is_none() && iterator.peek().is_some()
+          {
+            destination_node.variable = Some(input.1.identifiers.create_anonymous_variable());
+          }
+          let source = current_node;
+          current_node = destination_node.clone();
+          let (source, directivity, destination) = match edge_direction
+          {
+            EdgeDirection::Right => (
+              source,
+              graphcore::EdgeDirectivity::Directed,
+              destination_node,
+            ),
+            EdgeDirection::Left => (
+              destination_node,
+              graphcore::EdgeDirectivity::Directed,
+              source,
+            ),
+            EdgeDirection::Undirected => (
+              source,
+              graphcore::EdgeDirectivity::Undirected,
+              destination_node,
+            ),
+          };
+          // Clone source and destination before they're consumed by edge_pattern
+          let qp_source = source.clone();
+          let qp_destination = destination.clone();
+          let edge_variable = if quantifier.is_some() && edge_variable.is_none()
+          {
+            // A quantified edge's own value needs to be trackable even when the
+            // user didn't name it, so path_variable construction (which walks
+            // group_variables looking for Value::Edge entries) has something to
+            // find. Without this, an unnamed quantified edge is never bound to
+            // any column, and `p` can never be assembled.
+            Some(input.1.identifiers.create_anonymous_variable())
+          }
+          else
+          {
+            edge_variable
+          };
+          let edge_pattern = ast::EdgePattern {
+            source,
+            variable: edge_variable,
+            directivity,
+            labels,
+            properties,
+            destination: destination.clone(),
+            predicate,
+          };
+          match quantifier
+          {
+            Some(range) =>
+            {
+              patterns.push(ast::Pattern::QuantifiedPath(ast::QuantifiedPathPattern {
+                variable: None,
+                source: qp_source,
+                group: vec![ast::Pattern::Edge(edge_pattern)],
+                group_where: None,
+                path_where: None,
+                quantifier: Some(range),
+                destination: qp_destination,
+                selector: ast::PathSelector::All,
+              }))
+            }
+            None => patterns.push(ast::Pattern::Edge(edge_pattern)),
+          }
+        }
+        ChainElement::Group(group) =>
+        {
+          let GroupPattern {
+            group: mut inner_group,
+            group_where,
+            quantifier,
+            mut destination_node,
+          } = group;
+
+          // Anonymize unnamed edges in the group to make them trackable for path assembly
+          // This applies the same fix as the bare-quantifier case: even if the user doesn't
+          // name an edge, it needs to be bound to a column so path_variable can find it
+          for pattern in inner_group.iter_mut()
+          {
+            if let ast::Pattern::Edge(edge) = pattern
+              && edge.variable.is_none()
+            {
+              edge.variable = Some(input.1.identifiers.create_anonymous_variable());
+            }
+          }
+
+          // Ensure the group's terminal node (the destination of the last edge) has a variable
+          // This is needed for compile_quantified_path to correctly identify which column
+          // represents the group's exit node
+          for pattern in inner_group.iter_mut().rev()
+          {
+            if let ast::Pattern::Edge(edge) = pattern
+            {
+              if edge.destination.variable.is_none()
+              {
+                edge.destination.variable = Some(input.1.identifiers.create_anonymous_variable());
+              }
+              break;
+            }
+          }
+
+          // Ensure the group's entry node (the source of the first edge) has a
+          // variable, symmetric to the terminal-node anonymization above.
+          for pattern in inner_group.iter_mut()
+          {
+            if let ast::Pattern::Edge(edge) = pattern
+            {
+              if edge.source.variable.is_none()
+              {
+                edge.source.variable = Some(input.1.identifiers.create_anonymous_variable());
+              }
+              break;
+            }
+          }
+
+          if destination_node.variable.is_none() && iterator.peek().is_some()
+          {
+            destination_node.variable = Some(input.1.identifiers.create_anonymous_variable());
+          }
+          let source = current_node;
+          current_node = destination_node.clone();
+          patterns.push(ast::Pattern::QuantifiedPath(ast::QuantifiedPathPattern {
+            variable: None,
+            source,
+            group: inner_group,
+            group_where,
+            path_where: None,
+            quantifier: Some(quantifier),
+            destination: destination_node,
+            selector: ast::PathSelector::All,
+          }));
+        }
       }
-      let source = current_node;
-      current_node = destination_node.clone();
-      let (source, directivity, destination) = match edge_direction
-      {
-        EdgeDirection::Right => (
-          source,
-          graphcore::EdgeDirectivity::Directed,
-          destination_node,
-        ),
-        EdgeDirection::Left => (
-          destination_node,
-          graphcore::EdgeDirectivity::Directed,
-          source,
-        ),
-        EdgeDirection::Undirected => (
-          source,
-          graphcore::EdgeDirectivity::Undirected,
-          destination_node,
-        ),
-      };
-      patterns.push(ast::Pattern::Edge(ast::EdgePattern {
-        source,
-        variable: edge_variable,
-        directivity,
-        labels,
-        properties,
-        destination,
-        recursive_range,
-      }));
     }
 
     Ok((input, patterns))
   }
 }
 
-fn patterns<T: EdgeMode>(input: Input) -> OCPResult<Input, Vec<ast::Pattern>>
+/// Helper function to combine patterns with an optional path variable binding.
+/// Used by both `patterns<T>` (WI3) and `selector_scoped_pattern<T>` (WI4).
+///
+/// Returns a single pattern (length-1 Vec) that represents the combined result,
+/// ready for selector application or direct use.
+fn combine_patterns_with_variable(
+  context: &Context,
+  variable_name: Option<&str>,
+  patterns: Vec<ast::Pattern>,
+) -> Result<Vec<ast::Pattern>, ErrorKind>
 {
-  let context = &input.1;
-  alt((
-    map_res(
-      (ident, token(Token::Equal), node_or_edges_patterns::<T>),
-      |(name, _, patterns)| {
-        // Accept path assignment for one or more consecutive edges by combining them into a single EdgePattern.
-        if patterns.is_empty()
+  // If there's no variable binding, just pass through the patterns as-is
+  if variable_name.is_none()
+  {
+    // No path variable binding; patterns are used as-is
+    return Ok(patterns);
+  }
+
+  let name = variable_name.unwrap();
+
+  // Accept path assignment for one or more consecutive edges by combining them into a single EdgePattern.
+  if patterns.is_empty()
+  {
+    return Err(ErrorKind::PathAcceptSingleEdge);
+  }
+  // A path variable over a single quantified segment: `p = (a)-[*1..3]->(b)`
+  // or its new-syntax/multi-element equivalents. Bind the path variable
+  // directly onto the QuantifiedPathPattern; PathPattern is not involved.
+  if let [ast::Pattern::QuantifiedPath(qp)] = patterns.as_slice()
+  {
+    let mut qp = qp.clone();
+    qp.variable = Some(context.identifiers.create_variable_from_name(name));
+    return Ok(vec![ast::Pattern::QuantifiedPath(qp)]);
+  }
+  // A path variable over one or more *un*quantified edges: today's
+  // existing combining behavior, but now handling QuantifiedPath patterns.
+  // Extract all edges and track if any have quantifiers.
+  struct EdgeWithQuantifier
+  {
+    edge: ast::EdgePattern,
+    quantifier: Option<std::ops::Range<usize>>,
+  }
+  let mut edges_with_quantifiers: Vec<EdgeWithQuantifier> = Vec::new();
+  for p in patterns
+  {
+    match p
+    {
+      ast::Pattern::Edge(e) =>
+      {
+        edges_with_quantifiers.push(EdgeWithQuantifier {
+          edge: e,
+          quantifier: None,
+        });
+      }
+      ast::Pattern::QuantifiedPath(qp) =>
+      {
+        if qp.group.len() != 1
         {
           return Err(ErrorKind::PathAcceptSingleEdge);
         }
-        // Ensure all inner patterns are edges
-        if !patterns.iter().all(|p| matches!(p, ast::Pattern::Edge(_)))
+        let ast::Pattern::Edge(e) = &qp.group[0]
+        else
         {
           return Err(ErrorKind::PathAcceptSingleEdge);
+        };
+        edges_with_quantifiers.push(EdgeWithQuantifier {
+          edge: e.clone(),
+          quantifier: qp.quantifier.clone(),
+        });
+      }
+      _ => return Err(ErrorKind::PathAcceptSingleEdge),
+    }
+  }
+  if edges_with_quantifiers.is_empty()
+  {
+    return Err(ErrorKind::PathAcceptSingleEdge);
+  }
+
+  // Check if any edge has a quantifier
+  let has_quantifier = edges_with_quantifiers
+    .iter()
+    .any(|ewq| ewq.quantifier.is_some());
+
+  // Combine edges into a single EdgePattern by taking the first source and last destination.
+  // Preserve an inner edge variable if exactly one inner edge is named.
+  let combined_variable = {
+    let mut found: Option<ast::VariableIdentifier> = None;
+    for ewq in edges_with_quantifiers.iter()
+    {
+      if let Some(var) = &ewq.edge.variable
+      {
+        if found.is_some()
+        {
+          // multiple inner variables; do not attempt to preserve a single one
+          found = None;
+          break;
         }
-        // Consume the patterns and extract their EdgePattern values
-        let mut edges: Vec<ast::EdgePattern> = patterns
-          .into_iter()
-          .map(|p| match p
+        else
+        {
+          found = Some(var.clone());
+        }
+      }
+    }
+    found
+  };
+  let original_count = edges_with_quantifiers.len();
+  let first_ewq = edges_with_quantifiers.remove(0);
+  let last_ewq = edges_with_quantifiers
+    .pop()
+    .unwrap_or_else(|| EdgeWithQuantifier {
+      edge: first_ewq.edge.clone(),
+      quantifier: first_ewq.quantifier.clone(),
+    });
+
+  // For a single-edge path, preserve that edge's labels, properties, and predicate.
+  // For multi-hop paths, all edges become fixed edges in the path representation.
+  // Use original_count (before removes) to correctly distinguish single-edge (N=1) from two-edge (N=2) paths.
+  let (combined_labels, combined_properties, combined_predicate) = if original_count == 1
+  {
+    // Single edge: preserve its constraints.
+    (
+      first_ewq.edge.labels.clone(),
+      first_ewq.edge.properties.clone(),
+      first_ewq.edge.predicate.clone(),
+    )
+  }
+  else
+  {
+    // Multi-hop: all edges become fixed edges in the path representation
+    (ast::LabelExpression::None, None, None)
+  };
+  // Clone source and destination before they're moved into combined_edge
+  let qp_source = first_ewq.edge.source.clone();
+  let qp_destination = last_ewq.edge.destination.clone();
+  let combined_edge = ast::EdgePattern {
+    variable: combined_variable,
+    source: first_ewq.edge.source,
+    destination: last_ewq.edge.destination,
+    directivity: first_ewq.edge.directivity,
+    labels: combined_labels,
+    properties: combined_properties,
+    predicate: combined_predicate,
+  };
+
+  // If any edge had a quantifier, wrap the combined result in QuantifiedPath.
+  // If all edges were unquantified, wrap in PathPattern (original behavior).
+  if has_quantifier
+  {
+    // For mixed chains with quantifiers, wrap in QuantifiedPath.
+    // Use 0..usize::MAX as the quantifier range for now (represents [*] in legacy syntax).
+    // This preserves the semantics of "at least one path must exist" while allowing
+    // variable length paths to be represented.
+    let quantifier_range = if let Some(var_range) = &last_ewq.quantifier
+    {
+      // If the last edge has a quantifier, use it (with adjustment for preceding fixed edges)
+      if original_count == 1
+      {
+        last_ewq.quantifier.clone()
+      }
+      else
+      {
+        // For multi-hop paths, each fixed edge = 1 hop, then add the variable range
+        Some(
+          (var_range.start + (original_count - 1))
+            ..var_range.end.saturating_add(original_count - 1),
+        )
+      }
+    }
+    else
+    {
+      // No quantifier found (shouldn't happen if has_quantifier is true, but defensive)
+      Some(0..usize::MAX)
+    };
+
+    Ok(vec![ast::Pattern::QuantifiedPath(
+      ast::QuantifiedPathPattern {
+        variable: Some(context.identifiers.create_variable_from_name(name)),
+        source: qp_source,
+        group: vec![ast::Pattern::Edge(combined_edge)],
+        group_where: None,
+        path_where: None,
+        quantifier: quantifier_range,
+        destination: qp_destination,
+        selector: ast::PathSelector::All,
+      },
+    )])
+  }
+  else
+  {
+    Ok(vec![
+      ast::PathPattern {
+        variable: context.identifiers.create_variable_from_name(name),
+        edge: combined_edge,
+      }
+      .into(),
+    ])
+  }
+}
+
+fn selector_scoped_pattern<T: EdgeMode>(input: Input) -> OCPResult<Input, Vec<ast::Pattern>>
+{
+  let context = &input.1;
+  map_res(
+    delimited(
+      token(Token::StartParenthesis),
+      (
+        opt((ident, token(Token::Equal))),
+        node_or_edges_patterns::<T>,
+        opt(preceded(token(Token::Where), expression)),
+      ),
+      token(Token::EndParenthesis),
+    ),
+    |(variable_name_and_equal, inner_patterns, group_where)| {
+      let variable_name = variable_name_and_equal.map(|(name, _)| name);
+
+      if inner_patterns.is_empty()
+      {
+        return Err(ErrorKind::PathAcceptSingleEdge);
+      }
+
+      // Extract source and destination from the patterns for the QuantifiedPathPattern
+      let (source, destination) = if inner_patterns.len() == 1
+      {
+        match &inner_patterns[0]
+        {
+          ast::Pattern::Node(_) => return Err(ErrorKind::PathAcceptSingleEdge),
+          ast::Pattern::Edge(e) => (e.source.clone(), e.destination.clone()),
+          ast::Pattern::Path(p) => (p.edge.source.clone(), p.edge.destination.clone()),
+          ast::Pattern::QuantifiedPath(qp) => (qp.source.clone(), qp.destination.clone()),
+        }
+      }
+      else
+      {
+        match (
+          &inner_patterns[0],
+          &inner_patterns[inner_patterns.len() - 1],
+        )
+        {
+          (
+            ast::Pattern::Edge(e_first)
+            | ast::Pattern::Path(ast::PathPattern { edge: e_first, .. }),
+            ast::Pattern::Edge(e_last) | ast::Pattern::Path(ast::PathPattern { edge: e_last, .. }),
+          ) => (e_first.source.clone(), e_last.destination.clone()),
+          _ => return Err(ErrorKind::PathAcceptSingleEdge),
+        }
+      };
+
+      // Use combine_patterns_with_variable helper to handle combining logic
+      let combined = combine_patterns_with_variable(context, variable_name, inner_patterns)?;
+
+      if combined.is_empty()
+      {
+        return Err(ErrorKind::PathAcceptSingleEdge);
+      }
+
+      // For selector_scoped_pattern, we always wrap the result in a QuantifiedPathPattern
+      // with quantifier: None and group_where set
+      // This works for any pattern type returned by combine_patterns_with_variable
+      match combined.len()
+      {
+        1 =>
+        {
+          match combined.into_iter().next().unwrap()
           {
-            ast::Pattern::Edge(e) => e,
-            _ => unreachable!(),
-          })
-          .collect();
-        // Combine edges into a single EdgePattern by taking the first source and last destination.
-        // Preserve an inner edge variable if exactly one inner edge is named.
-        let combined_variable = {
-          let mut found: Option<ast::VariableIdentifier> = None;
-          for e in edges.iter()
+            ast::Pattern::QuantifiedPath(mut qp) =>
+            {
+              // Already a QuantifiedPathPattern from combine_patterns_with_variable.
+              // If it already has a quantifier (inner pattern is quantified like --+),
+              // preserve it and just add group_where. If quantifier is None (pre-filter
+              // wrapper case), leave it as None. Do NOT unconditionally override it.
+              qp.group_where = group_where;
+              Ok(vec![ast::Pattern::QuantifiedPath(qp)])
+            }
+            ast::Pattern::Path(path_pattern) =>
+            {
+              // PathPattern from combine_patterns_with_variable (when variable bound to unquantified path)
+              // Wrap in QuantifiedPathPattern with no quantifier
+              let qp = ast::QuantifiedPathPattern {
+                variable: Some(path_pattern.variable),
+                source,
+                group: vec![ast::Pattern::Edge(path_pattern.edge)],
+                group_where,
+                path_where: None,
+                quantifier: None,
+                destination,
+                selector: ast::PathSelector::All,
+              };
+              Ok(vec![ast::Pattern::QuantifiedPath(qp)])
+            }
+            ast::Pattern::Edge(edge) =>
+            {
+              // Single Edge pattern (no variable binding)
+              // Wrap in QuantifiedPathPattern with no quantifier
+              let qp = ast::QuantifiedPathPattern {
+                variable: None,
+                source,
+                group: vec![ast::Pattern::Edge(edge)],
+                group_where,
+                path_where: None,
+                quantifier: None,
+                destination,
+                selector: ast::PathSelector::All,
+              };
+              Ok(vec![ast::Pattern::QuantifiedPath(qp)])
+            }
+            ast::Pattern::Node(_) =>
+            {
+              // Node pattern is not allowed
+              Err(ErrorKind::PathAcceptSingleEdge)
+            }
+          }
+        }
+        _ =>
+        {
+          // Multiple patterns - wrap them all in a QuantifiedPathPattern
+          let qp = ast::QuantifiedPathPattern {
+            variable: None,
+            source,
+            group: combined,
+            group_where,
+            path_where: None,
+            quantifier: None,
+            destination,
+            selector: ast::PathSelector::All,
+          };
+          Ok(vec![ast::Pattern::QuantifiedPath(qp)])
+        }
+      }
+    },
+  )
+  .parse(input)
+}
+
+fn patterns<T: EdgeMode>(input: Input) -> OCPResult<Input, Vec<ast::Pattern>>
+{
+  let context = &input.1;
+  map_res(
+    (
+      opt((ident, token(Token::Equal))),
+      opt(path_selector),
+      alt((selector_scoped_pattern::<T>, node_or_edges_patterns::<T>)),
+    ),
+    |(variable_name_and_equal, selector, patterns)| {
+      let variable_name = variable_name_and_equal.map(|(name, _)| name);
+
+      // Step 2: Run the existing combining logic completely unchanged.
+      // This is the closure body from the original `alt` branch, operating on
+      // patterns and variable_name exactly as before.
+
+      // If there's no variable binding, just pass through with selector applied (if any)
+      if variable_name.is_none()
+      {
+        // No path variable binding; patterns are used as-is with optional selector
+        let mut result = patterns;
+        if let Some(selector) = selector
+        {
+          // Step 3: Apply selector as final wrap only if present
+          if result.len() != 1
           {
-            if let Some(var) = &e.variable
+            return Err(ErrorKind::PathAcceptSingleEdge);
+          }
+          match &mut result[0]
+          {
+            ast::Pattern::QuantifiedPath(qp) =>
             {
-              if found.is_some()
-              {
-                // multiple inner variables; do not attempt to preserve a single one
-                found = None;
-                break;
-              }
-              else
-              {
-                found = Some(var.clone());
-              }
+              qp.selector = selector;
+            }
+            ast::Pattern::Edge(_) | ast::Pattern::Path(_) =>
+            {
+              // Scoping-wrapper case (design §1d): wrap the existing pattern
+              // into a QuantifiedPathPattern with no quantifier, carrying only the selector.
+              let wrapped = ast::Pattern::QuantifiedPath(ast::QuantifiedPathPattern {
+                variable: None,
+                source: match &result[0]
+                {
+                  ast::Pattern::Edge(e) => e.source.clone(),
+                  ast::Pattern::Path(p) => p.edge.source.clone(),
+                  _ => unreachable!(),
+                },
+                group: vec![result[0].clone()],
+                group_where: None,
+                path_where: None,
+                quantifier: None,
+                destination: match &result[0]
+                {
+                  ast::Pattern::Edge(e) => e.destination.clone(),
+                  ast::Pattern::Path(p) => p.edge.destination.clone(),
+                  _ => unreachable!(),
+                },
+                selector,
+              });
+              result = vec![wrapped];
+            }
+            ast::Pattern::Node(_) =>
+            {
+              return Err(ErrorKind::PathAcceptSingleEdge);
             }
           }
-          found
-        };
-        let original_count = edges.len();
-        let first_edge = edges.remove(0);
-        let last_edge = edges.pop().unwrap_or_else(|| first_edge.clone());
-        // For a single-edge path, preserve that edge's labels, properties, and recursive_range.
-        // For multi-hop paths, compute the combined hop range (each fixed edge = 1 hop,
-        // var-length edge contributes its own range). Use original_count (before removes)
-        // to correctly distinguish single-edge (N=1) from two-edge (N=2) paths.
-        let (combined_labels, combined_properties, combined_recursive_range) = if original_count
-          == 1
+        }
+        return Ok(result);
+      }
+
+      let name = variable_name.unwrap();
+
+      // Accept path assignment for one or more consecutive edges by combining them into a single EdgePattern.
+      if patterns.is_empty()
+      {
+        return Err(ErrorKind::PathAcceptSingleEdge);
+      }
+      // A path variable over a single quantified segment: `p = (a)-[*1..3]->(b)`
+      // or its new-syntax/multi-element equivalents. Bind the path variable
+      // directly onto the QuantifiedPathPattern; PathPattern is not involved.
+      if let [ast::Pattern::QuantifiedPath(qp)] = patterns.as_slice()
+      {
+        let mut qp = qp.clone();
+        qp.variable = Some(context.identifiers.create_variable_from_name(name));
+        // Step 3: Apply selector if present
+        if let Some(selector) = selector
         {
-          // Single edge: preserve its constraints.
-          (
-            first_edge.labels.clone(),
-            first_edge.properties.clone(),
-            first_edge.recursive_range.clone(),
-          )
+          qp.selector = selector;
         }
-        else
+        return Ok(vec![ast::Pattern::QuantifiedPath(qp)]);
+      }
+      // A path variable over one or more *un*quantified edges: today's
+      // existing combining behavior, but now handling QuantifiedPath patterns.
+      // Extract all edges and track if any have quantifiers.
+      struct EdgeWithQuantifier
+      {
+        edge: ast::EdgePattern,
+        quantifier: Option<std::ops::Range<usize>>,
+      }
+      let mut edges_with_quantifiers: Vec<EdgeWithQuantifier> = Vec::new();
+      for p in patterns
+      {
+        match p
         {
-          // Multi-hop: accumulate min and max hops across all constituent edges.
-          // Fixed edges contribute 1 hop each; var-length edges contribute their range.
-          let hop_range = |e: &ast::EdgePattern| -> (usize, usize) {
-            match &e.recursive_range
+          ast::Pattern::Edge(e) =>
+          {
+            edges_with_quantifiers.push(EdgeWithQuantifier {
+              edge: e,
+              quantifier: None,
+            });
+          }
+          ast::Pattern::QuantifiedPath(qp) =>
+          {
+            if qp.group.len() != 1
             {
-              Some(r) => (r.start, r.end),
-              None => (1, 1),
+              return Err(ErrorKind::PathAcceptSingleEdge);
             }
-          };
-          let (mut min_total, mut max_total) = hop_range(&first_edge);
-          for e in &edges
+            let ast::Pattern::Edge(e) = &qp.group[0]
+            else
+            {
+              return Err(ErrorKind::PathAcceptSingleEdge);
+            };
+            edges_with_quantifiers.push(EdgeWithQuantifier {
+              edge: e.clone(),
+              quantifier: qp.quantifier.clone(),
+            });
+          }
+          _ => return Err(ErrorKind::PathAcceptSingleEdge),
+        }
+      }
+      if edges_with_quantifiers.is_empty()
+      {
+        return Err(ErrorKind::PathAcceptSingleEdge);
+      }
+
+      // Check if any edge has a quantifier
+      let has_quantifier = edges_with_quantifiers
+        .iter()
+        .any(|ewq| ewq.quantifier.is_some());
+
+      // Combine edges into a single EdgePattern by taking the first source and last destination.
+      // Preserve an inner edge variable if exactly one inner edge is named.
+      let combined_variable = {
+        let mut found: Option<ast::VariableIdentifier> = None;
+        for ewq in edges_with_quantifiers.iter()
+        {
+          if let Some(var) = &ewq.edge.variable
           {
-            let (mn, mx) = hop_range(e);
-            min_total += mn;
-            max_total = max_total.saturating_add(mx);
+            if found.is_some()
+            {
+              // multiple inner variables; do not attempt to preserve a single one
+              found = None;
+              break;
+            }
+            else
+            {
+              found = Some(var.clone());
+            }
           }
-          let (mn, mx) = hop_range(&last_edge);
-          min_total += mn;
-          max_total = max_total.saturating_add(mx);
-          (ast::LabelExpression::None, None, Some(min_total..max_total))
+        }
+        found
+      };
+      let original_count = edges_with_quantifiers.len();
+      let first_ewq = edges_with_quantifiers.remove(0);
+      let last_ewq = edges_with_quantifiers
+        .pop()
+        .unwrap_or_else(|| EdgeWithQuantifier {
+          edge: first_ewq.edge.clone(),
+          quantifier: first_ewq.quantifier.clone(),
+        });
+
+      // For a single-edge path, preserve that edge's labels, properties, and predicate.
+      // For multi-hop paths, all edges become fixed edges in the path representation.
+      // Use original_count (before removes) to correctly distinguish single-edge (N=1) from two-edge (N=2) paths.
+      let (combined_labels, combined_properties, combined_predicate) = if original_count == 1
+      {
+        // Single edge: preserve its constraints.
+        (
+          first_ewq.edge.labels.clone(),
+          first_ewq.edge.properties.clone(),
+          first_ewq.edge.predicate.clone(),
+        )
+      }
+      else
+      {
+        // Multi-hop: all edges become fixed edges in the path representation
+        (ast::LabelExpression::None, None, None)
+      };
+      // Clone source and destination before they're moved into combined_edge
+      let qp_source = first_ewq.edge.source.clone();
+      let qp_destination = last_ewq.edge.destination.clone();
+      let combined_edge = ast::EdgePattern {
+        variable: combined_variable,
+        source: first_ewq.edge.source,
+        destination: last_ewq.edge.destination,
+        directivity: first_ewq.edge.directivity,
+        labels: combined_labels,
+        properties: combined_properties,
+        predicate: combined_predicate,
+      };
+
+      // If any edge had a quantifier, wrap the combined result in QuantifiedPath.
+      // If all edges were unquantified, wrap in PathPattern (original behavior).
+      if has_quantifier
+      {
+        // For mixed chains with quantifiers, wrap in QuantifiedPath.
+        // Use 0..usize::MAX as the quantifier range for now (represents [*] in legacy syntax).
+        // This preserves the semantics of "at least one path must exist" while allowing
+        // variable length paths to be represented.
+        let quantifier_range = if let Some(var_range) = &last_ewq.quantifier
+        {
+          // If the last edge has a quantifier, use it (with adjustment for preceding fixed edges)
+          if original_count == 1
+          {
+            last_ewq.quantifier.clone()
+          }
+          else
+          {
+            // For multi-hop paths, each fixed edge = 1 hop, then add the variable range
+            Some(
+              (var_range.start + (original_count - 1))
+                ..var_range.end.saturating_add(original_count - 1),
+            )
+          }
+        }
+        else
+        {
+          // No quantifier found (shouldn't happen if has_quantifier is true, but defensive)
+          Some(0..usize::MAX)
         };
-        let combined_edge = ast::EdgePattern {
-          variable: combined_variable,
-          source: first_edge.source,
-          destination: last_edge.destination,
-          directivity: first_edge.directivity,
-          labels: combined_labels,
-          properties: combined_properties,
-          recursive_range: combined_recursive_range,
+
+        let mut qp = ast::QuantifiedPathPattern {
+          variable: Some(context.identifiers.create_variable_from_name(name)),
+          source: qp_source,
+          group: vec![ast::Pattern::Edge(combined_edge)],
+          group_where: None,
+          path_where: None,
+          quantifier: quantifier_range,
+          destination: qp_destination,
+          selector: ast::PathSelector::All,
         };
-        Ok(vec![
+        // Step 3: Apply selector if present
+        if let Some(selector) = selector
+        {
+          qp.selector = selector;
+        }
+        Ok(vec![ast::Pattern::QuantifiedPath(qp)])
+      }
+      else
+      {
+        let mut result = vec![
           ast::PathPattern {
             variable: context.identifiers.create_variable_from_name(name),
             edge: combined_edge,
           }
           .into(),
-        ])
-      },
-    ),
-    node_or_edges_patterns::<T>,
-  ))
+        ];
+        // Step 3: Apply selector if present - wrap unquantified path in QuantifiedPath
+        if let Some(selector) = selector
+        {
+          let wrapped = ast::Pattern::QuantifiedPath(ast::QuantifiedPathPattern {
+            variable: Some(context.identifiers.create_variable_from_name(name)),
+            source: qp_source,
+            group: result,
+            group_where: None,
+            path_where: None,
+            quantifier: None,
+            destination: qp_destination,
+            selector,
+          });
+          result = vec![wrapped];
+        }
+        Ok(result)
+      }
+    },
+  )
   .parse(input)
 }
 
@@ -1451,6 +2207,7 @@ fn match_statement(input: Input) -> OCPResult<Input, ast::Statement>
             ast::Pattern::Node(n) => n.variable.as_ref().map(|v| v.name().clone()),
             ast::Pattern::Edge(e) => e.variable.as_ref().map(|v| v.name().clone()),
             ast::Pattern::Path(p) => Some(p.variable.name().clone()),
+            ast::Pattern::QuantifiedPath(qp) => qp.variable.as_ref().map(|v| v.name().clone()),
           })
           .collect();
 
@@ -2080,3 +2837,299 @@ pub fn queries(input: Input) -> OCPResult<Input, ast::Queries>
 {
   separated_list1(token(Token::Semi), query).parse(input)
 }
+
+#[cfg(test)]
+mod quantifier_suffix_tests
+{
+  use super::*;
+  use crate::oc::lexer::tokenize;
+
+  fn parse_quantifier(input: &str) -> Option<std::ops::Range<usize>>
+  {
+    let spanned_tokens = tokenize(input).ok()?;
+    let context = Context::new(input);
+    let input = Input(&spanned_tokens, &context);
+    quantifier_suffix(input).ok().map(|(_, range)| range)
+  }
+
+  #[test]
+  fn test_quantifier_braced_min_max()
+  {
+    // {min,max} form
+    let result = parse_quantifier("{1,5}");
+    assert_eq!(result, Some(1..5));
+  }
+
+  #[test]
+  fn test_quantifier_braced_exact()
+  {
+    // {n} form - exact count
+    let result = parse_quantifier("{3}");
+    assert_eq!(result, Some(3..3));
+  }
+
+  #[test]
+  fn test_quantifier_braced_min_open()
+  {
+    // {min,} form
+    let result = parse_quantifier("{2,}");
+    assert_eq!(result, Some(2..usize::MAX));
+  }
+
+  #[test]
+  fn test_quantifier_braced_max_open()
+  {
+    // {,max} form
+    let result = parse_quantifier("{,4}");
+    assert_eq!(result, Some(0..4));
+  }
+
+  #[test]
+  fn test_quantifier_bare_star()
+  {
+    // Bare `*` form: zero-or-more
+    let result = parse_quantifier("*");
+    assert_eq!(result, Some(0..usize::MAX));
+  }
+
+  #[test]
+  fn test_quantifier_bare_plus()
+  {
+    // Bare `+` form: one-or-more
+    let result = parse_quantifier("+");
+    assert_eq!(result, Some(1..usize::MAX));
+  }
+}
+
+#[cfg(test)]
+mod path_selector_tests
+{
+  use super::*;
+  use crate::oc::lexer::tokenize;
+
+  fn parse_path_selector(input: &str) -> Option<ast::PathSelector>
+  {
+    let spanned_tokens = tokenize(input).ok()?;
+    let context = Context::new(input);
+    let input = Input(&spanned_tokens, &context);
+    path_selector(input).ok().map(|(_, selector)| selector)
+  }
+
+  fn assert_selector_eq(actual: ast::PathSelector, expected: ast::PathSelector, msg: &str)
+  {
+    assert_eq!(
+      format!("{:?}", actual),
+      format!("{:?}", expected),
+      "{}",
+      msg
+    );
+  }
+
+  #[test]
+  fn test_path_selector_shortest_k()
+  {
+    // SHORTEST 1
+    let result = parse_path_selector("SHORTEST 1");
+    assert!(result.is_some(), "Expected SHORTEST 1 to parse");
+    if let Some(selector) = result
+    {
+      assert!(
+        matches!(selector, ast::PathSelector::Shortest(_)),
+        "Expected Shortest variant"
+      );
+    }
+  }
+
+  #[test]
+  fn test_path_selector_shortest_parameter()
+  {
+    // SHORTEST $k
+    let result = parse_path_selector("SHORTEST $k");
+    assert!(result.is_some(), "Expected SHORTEST $k to parse");
+    if let Some(selector) = result
+    {
+      assert!(
+        matches!(selector, ast::PathSelector::Shortest(_)),
+        "Expected Shortest variant"
+      );
+    }
+  }
+
+  #[test]
+  fn test_path_selector_shortest_k_groups()
+  {
+    // SHORTEST 2 GROUPS
+    let result = parse_path_selector("SHORTEST 2 GROUPS");
+    assert!(result.is_some(), "Expected SHORTEST 2 GROUPS to parse");
+    if let Some(selector) = result
+    {
+      assert!(
+        matches!(selector, ast::PathSelector::ShortestGroups(_)),
+        "Expected ShortestGroups variant"
+      );
+    }
+  }
+
+  #[test]
+  fn test_path_selector_shortest_group_sugar()
+  {
+    // SHORTEST GROUP (singular sugar, k defaults to 1)
+    let result = parse_path_selector("SHORTEST GROUP");
+    assert!(result.is_some(), "Expected SHORTEST GROUP to parse");
+    if let Some(selector) = result
+    {
+      assert!(
+        matches!(selector, ast::PathSelector::ShortestGroups(_)),
+        "Expected ShortestGroups variant for SHORTEST GROUP"
+      );
+    }
+  }
+
+  #[test]
+  fn test_path_selector_shortest_group_equivalence()
+  {
+    // SHORTEST GROUP and SHORTEST 1 GROUPS produce same representation
+    let result_group = parse_path_selector("SHORTEST GROUP");
+    let result_groups = parse_path_selector("SHORTEST 1 GROUPS");
+
+    assert!(result_group.is_some(), "Expected SHORTEST GROUP to parse");
+    assert!(
+      result_groups.is_some(),
+      "Expected SHORTEST 1 GROUPS to parse"
+    );
+
+    if let (Some(group_selector), Some(groups_selector)) = (result_group, result_groups)
+    {
+      // Both should be ShortestGroups and should have the same string representation
+      // (confirming alias normalization collapses them to one representation)
+      assert_selector_eq(
+        group_selector,
+        groups_selector,
+        "Expected SHORTEST GROUP to be equivalent to SHORTEST 1 GROUPS",
+      );
+    }
+  }
+
+  #[test]
+  fn test_path_selector_all_shortest()
+  {
+    // ALL SHORTEST
+    let result = parse_path_selector("ALL SHORTEST");
+    assert!(result.is_some(), "Expected ALL SHORTEST to parse");
+    if let Some(selector) = result
+    {
+      assert_selector_eq(
+        selector,
+        ast::PathSelector::AllShortest,
+        "Expected AllShortest variant",
+      );
+    }
+  }
+
+  #[test]
+  fn test_path_selector_any()
+  {
+    // ANY
+    let result = parse_path_selector("ANY");
+    assert!(result.is_some(), "Expected ANY to parse");
+    if let Some(selector) = result
+    {
+      assert_selector_eq(
+        selector,
+        ast::PathSelector::Any,
+        "Expected Any variant for bare ANY",
+      );
+    }
+  }
+
+  #[test]
+  fn test_path_selector_any_shortest()
+  {
+    // ANY SHORTEST
+    let result = parse_path_selector("ANY SHORTEST");
+    assert!(result.is_some(), "Expected ANY SHORTEST to parse");
+    if let Some(selector) = result
+    {
+      assert_selector_eq(
+        selector,
+        ast::PathSelector::Any,
+        "Expected Any variant for ANY SHORTEST (alias normalized to Any)",
+      );
+    }
+  }
+
+  #[test]
+  fn test_path_selector_all()
+  {
+    // ALL (bare, no SHORTEST following)
+    let result = parse_path_selector("ALL");
+    assert!(result.is_some(), "Expected ALL to parse");
+    if let Some(selector) = result
+    {
+      assert_selector_eq(
+        selector,
+        ast::PathSelector::All,
+        "Expected All variant for bare ALL",
+      );
+    }
+  }
+
+  #[test]
+  fn test_path_selector_ordering_all_shortest_before_all()
+  {
+    // ALL SHORTEST - verifies that ALL SHORTEST is tried
+    // before bare ALL in the alt ordering
+    let result = parse_path_selector("ALL SHORTEST");
+    assert!(result.is_some(), "Expected ALL SHORTEST to parse correctly");
+
+    if let Some(selector) = result
+    {
+      // Confirm it parsed as AllShortest, not just All
+      match selector
+      {
+        ast::PathSelector::AllShortest =>
+        {
+          // Success: alt correctly tried ALL SHORTEST before bare ALL
+        }
+        _ =>
+        {
+          panic!(
+            "Expected AllShortest variant, got {:?}. This indicates alt ordering issue where ALL consumed and SHORTEST was left unparsed.",
+            selector
+          );
+        }
+      }
+    }
+  }
+
+  #[test]
+  fn test_path_selector_ordering_shortest_k_groups_before_shortest_k()
+  {
+    // SHORTEST 2 GROUPS - verifies that SHORTEST <k> GROUPS is tried
+    // before bare SHORTEST <k> in the alt ordering
+    let result = parse_path_selector("SHORTEST 2 GROUPS");
+    assert!(
+      result.is_some(),
+      "Expected SHORTEST 2 GROUPS to parse correctly"
+    );
+
+    if let Some(selector) = result
+    {
+      // Confirm it parsed as ShortestGroups, not just Shortest
+      match selector
+      {
+        ast::PathSelector::ShortestGroups(_) =>
+        {
+          // Success: alt correctly tried SHORTEST <k> GROUPS before SHORTEST <k>
+        }
+        _ =>
+        {
+          panic!(
+            "Expected ShortestGroups variant, got {:?}. This indicates alt ordering issue where SHORTEST <k> consumed '2' and left 'GROUPS' unparsed.",
+            selector
+          );
+        }
+      }
+    }
+  }
+}