diff options
| -rw-r--r-- | dhall_core/src/parser.rs | 392 |
1 files changed, 82 insertions, 310 deletions
diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs index 6718c00..30e3367 100644 --- a/dhall_core/src/parser.rs +++ b/dhall_core/src/parser.rs @@ -71,137 +71,7 @@ fn debug_pair(pair: Pair<Rule>) -> String { s } -// #[derive(Debug)] -// enum IterMatchError<T> { -// NoMatchFound, -// Other(T), // Allow other macros to inject their own errors -// } - -// macro_rules! match_iter_typed { -// // Collect untyped arguments to pass to match_iter! -// (@collect, ($($vars:tt)*), ($($args:tt)*), ($($acc:tt)*), ($x:ident : $ty:ident, $($rest:tt)*)) => { -// match_iter_typed!(@collect, ($($vars)*), ($($args)*), ($($acc)*, $x), ($($rest)*)) -// }; -// (@collect, ($($vars:tt)*), ($($args:tt)*), ($($acc:tt)*), ($x:ident.. : $ty:ident, $($rest:tt)*)) => { -// match_iter_typed!(@collect, ($($vars)*), ($($args)*), ($($acc)*, $x..), ($($rest)*)) -// }; -// // Catch extra comma if exists -// (@collect, ($($vars:tt)*), ($($args:tt)*), (,$($acc:tt)*), ($(,)*)) => { -// match_iter_typed!(@collect, ($($vars)*), ($($args)*), ($($acc)*), ()) -// }; -// (@collect, ($iter:expr, $body:expr, $callback:ident, $error:ident), ($($args:tt)*), ($($acc:tt)*), ($(,)*)) => { -// { -// let res = iter_patterns::destructure_iter!($iter; [$($acc)*] => { -// match_iter_typed!(@callback, $callback, $iter, $($args)*); -// $body -// }); -// res.ok_or(IterMatchError::NoMatchFound) -// } -// }; - -// // Pass the matches through the callback -// (@callback, $callback:ident, $iter:expr, $x:ident : $ty:ident $($rest:tt)*) => { -// let $x = $callback!(@type_callback, $ty, $x); -// #[allow(unused_mut)] -// let mut $x = match $x { -// Ok(x) => x, -// Err(e) => break Err(IterMatchError::Other(e)), -// }; -// match_iter_typed!(@callback, $callback, $iter $($rest)*); -// }; -// (@callback, $callback: ident, $iter:expr, $x:ident.. : $ty:ident $($rest:tt)*) => { -// let $x = $x.map(|x| $callback!(@type_callback, $ty, x)).collect(); -// let $x: Vec<_> = match $x { -// Ok(x) => x, -// Err(e) => break Err(IterMatchError::Other(e)), -// }; -// #[allow(unused_mut)] -// let mut $x = $x.into_iter(); -// match_iter_typed!(@callback, $callback, $iter $($rest)*); -// }; -// (@callback, $callback:ident, $iter:expr $(,)*) => {}; - -// ($callback:ident; $iter:expr; ($($args:tt)*) => $body:expr) => { -// { -// #[allow(unused_mut)] -// let mut iter = $iter; -// let res: Result<_, IterMatchError<_>> = loop { -// break match_iter_typed!(@collect, -// (iter, $body, $callback, last_error), -// ($($args)*), (), ($($args)*,) -// ) -// }; -// res -// } -// }; -// } - -// macro_rules! match_iter_branching { -// (@noclone, $callback:ident; $arg:expr; $( $submac:ident!($($args:tt)*) => $body:expr ),* $(,)*) => { -// { -// #[allow(unused_assignments)] -// let mut last_error = IterMatchError::NoMatchFound; -// // Not a real loop; used for error handling -// // Would use loop labels but they create warnings -// #[allow(unreachable_code)] -// loop { -// $( -// let matched: Result<_, IterMatchError<_>> = -// $callback!(@branch_callback, $submac, $arg; ($($args)*) => $body); -// #[allow(unused_assignments)] -// match matched { -// Ok(v) => break Ok(v), -// Err(e) => last_error = e, -// }; -// )* -// break Err(last_error); -// } -// } -// }; -// ($callback:ident; $iter:expr; $($args:tt)*) => { -// { -// #[allow(unused_mut)] -// let mut iter = $iter; -// match_iter_branching!(@noclone, $callback; iter.clone(); $($args)*) -// } -// }; -// } - macro_rules! match_pair { - // // (@type_callback, parse_any_fast, $x:expr) => { - // // ParseWrapped::parse_any_fast($x).map(Box::new) - // // }; - // (@type_callback, $ty:ident, $x:expr) => { - // ParseUnwrapped::$ty($x) - // // ParseWrapped::$ty($x).map(|x| x.$ty()) - // // match ParseWrapped::parse_any($x) { - // // match parse_any_fast($x.clone()) { - // // // match ParseWrapped::$ty($x.clone()) { - // // Ok(ParsedValue::$ty(x)) => Ok(x), - // // // _ => ParseUnwrapped::$ty($x), - // // _ => Err(custom_parse_error(&$x, format!("Total failure"))), - // // } - // }; - // (@branch_callback, children, $pair:expr; $($args:tt)*) => { - // { - // #[allow(unused_mut)] - // let mut pairs = $pair.clone().into_inner(); - // match_iter_typed!(match_pair; pairs; $($args)*) - // } - // }; - // (@branch_callback, raw_pair, $pair:expr; ($x:ident) => $body:expr) => { - // { - // let $x = $pair.clone(); - // Ok($body) - // } - // }; - // (@branch_callback, captured_str, $pair:expr; ($x:ident) => $body:expr) => { - // { - // let $x = $pair.as_str(); - // Ok($body) - // } - // }; - (@make_child_match, $pair:expr, ($($outer_acc:tt)*), ($($acc:tt)*), ($(,)* $x:ident : $ty:ident $($rest_of_match:tt)*) => $body:expr, $($rest:tt)*) => { match_pair!(@make_child_match, $pair, ($($outer_acc)*), ($($acc)*, ParsedValue::$ty($x)), ($($rest_of_match)*) => $body, $($rest)*) }; @@ -220,9 +90,6 @@ macro_rules! match_pair { (@make_matches, $pair:expr, ($($acc:tt)*), children!($($args:tt)*) => $body:expr, $($rest:tt)*) => { match_pair!(@make_child_match, $pair, ($($acc)*), (), ($($args)*) => $body, $($rest)*) - // (@make_matches, $pair:expr, ($($acc:tt)*), children!($($x:ident : $ty:ident),*) => $body:expr, $($rest:tt)*) => { - // match_pair!(@make_child_match, $pair, ($($acc)*), ($(, ParsedValue::$ty($x))*), () => $body, $($rest)*) - // match_pair!(@make_matches, $pair, ([$(ParsedValue::$ty($x)),*] => { $body }, $($acc)*), $($rest)*) }; (@make_matches, $pair:expr, ($($acc:tt)*), raw_pair!($x:ident) => $body:expr, $($rest:tt)*) => { match_pair!(@make_matches, $pair, ([..] => { @@ -249,27 +116,8 @@ macro_rules! match_pair { } }; - // ($pair:expr; $( children!($($x:ident : $ty:ident),*) => $body:expr ),* $(,)*) => { - // match_pair!(@make_matches, $pair, (), $( children!($($x : $ty),*) => $body ),* ,) - // ($pair:expr; $( children!($($args:tt)*) => $body:expr ),* $(,)*) => { - // match_pair!(@make_matches, $pair, (), $( children!($($args)*) => $body ),* ,) ($pair:expr; $( $submac:ident!($($args:tt)*) => $body:expr ),* $(,)*) => { match_pair!(@make_matches, $pair, (), $( $submac!($($args)*) => $body ),* ,) - // ($pair:expr; $($args:tt)*) => { - // match_pair!(@make_matches, $pair, (), $($args)*) - // { - // let pair = $pair; - // let rule = pair.as_rule(); - // let err = custom_parse_error(&pair, "No match found".to_owned()); - // let parsed: Vec<_> = pair.into_inner().map(ParseWrapped::parse_any_fast).collect::<Result<_, _>>()?; - // #[allow(unreachable_code)] - // iter_patterns::match_vec!(parsed; - // $( - // [$(ParsedValue::$ty($x)),*] => { $body }, - // )* - // [x..] => panic!("Unexpected children while parsing rule '{:?}': {:?}", rule, x.collect::<Vec<_>>()), - // ).ok_or(err) - // } }; ($pair:expr; $($args:tt)*) => { { @@ -285,11 +133,23 @@ macro_rules! match_pair { macro_rules! make_parser { (@branch_rules, $pair:expr, ($($acc:tt)*), rule!( $name:ident<$o:ty>; $($args:tt)* ); $($rest:tt)*) => ( - make_parser!(@branch_rules, $pair, ($($acc)* Rule::$name => ParseWrapped::$name($pair),), $($rest)*) + make_parser!(@branch_rules, $pair, ($($acc)* Rule::$name => { + ParseWrapped::$name($pair) + },), $($rest)*) ); - (@branch_rules, $pair:expr, ($($acc:tt)*), rule_group!( $name:ident<$o:ty>; $($ty:ident),* ); $($rest:tt)*) => ( - make_parser!(@branch_rules, $pair, ($($acc)* $( Rule::$ty => ParseUnwrapped::$ty($pair).map(ParsedValue::$name),)* ), $($rest)*) + (@branch_rules, $pair:expr, ($($acc:tt)*), rule_in_group!( $name:ident<$o:ty>; $group:ident; $($args:tt)* ); $($rest:tt)*) => ( + make_parser!(@branch_rules, $pair, ($($acc)* Rule::$name => { + ParseWrapped::$name($pair).map(|x| x.$name()).map(ParsedValue::$group) + },), $($rest)*) ); + (@branch_rules, $pair:expr, ($($acc:tt)*), binop!( $name:ident<$o:ty>; $op:ident ); $($rest:tt)*) => ( + make_parser!(@branch_rules, $pair, ($($acc)* Rule::$name => { + parse_binop($pair, BinOp::$op).map(ParsedValue::expression) + },), $($rest)*) + ); + // (@branch_rules, $pair:expr, ($($acc:tt)*), rule_group!( $name:ident<$o:ty>; $($ty:ident),* ); $($rest:tt)*) => ( + // make_parser!(@branch_rules, $pair, ($($acc)* $( Rule::$ty => ParseUnwrapped::$ty($pair).map(ParsedValue::$name),)* ), $($rest)*) + // ); (@branch_rules, $pair:expr, ($($acc:tt)*), $submac:ident!( $name:ident<$o:ty>; $($args:tt)* ); $($rest:tt)*) => ( make_parser!(@branch_rules, $pair, ($($acc)*), $($rest)*) ); @@ -298,7 +158,6 @@ macro_rules! make_parser { match $pair.as_rule() { $($acc)* r => Err(custom_parse_error(&$pair, format!("parse_any_fast: Unexpected {:?}", r))), - // [x..] => panic!("{:?}", x.collect::<Vec<_>>()), } ); ($( $submac:ident!( $name:ident<$o:ty>; $($args:tt)* ); )*) => ( @@ -330,7 +189,6 @@ macro_rules! make_parser { #[derive(Debug)] enum ParsedValue<'a> { $( $name($o), )* - // parse_any(Box<ParsedValue<'a>>), } impl<'a> ParsedValue<'a> { @@ -343,26 +201,8 @@ macro_rules! make_parser { } } )* - // #[allow(non_snake_case, dead_code)] - // fn parse_any(self) -> Box<ParsedValue<'a>> { - // match self { - // ParsedValue::parse_any(x) => x, - // x => Box::new(x), - // } - // } - // #[allow(non_snake_case, dead_code)] - // fn parse_any_fast(self) -> Box<ParsedValue<'a>> { - // self.parse_any() - // } } - // named!(parse_any<Box<ParsedValue<'a>>>; - // // self!(x: parse_any_fast) => x, - // $( - // self!(x: $name) => Box::new(ParsedValue::$name(x)), - // )* - // ); - impl ParseWrapped { #[allow(non_snake_case, dead_code)] fn parse_any_fast(pair: Pair<Rule>) -> ParseResult<ParsedValue> { @@ -412,46 +252,23 @@ macro_rules! make_pest_parse_function { ); } -// macro_rules! named { -// ($name:ident<$o:ty>; $($args:tt)*) => ( -// make_pest_parse_function!($name<$o>; match_pair!( $($args)* )); -// ); -// } - macro_rules! rule { ($name:ident<$o:ty>; $($args:tt)*) => ( make_pest_parse_function!($name<$o>; match_pair!( $($args)* )); - // make_pest_parse_function!($name<$o>; match_rule!( - // Rule::$name => match_pair!( $($args)* ), - // )); ); } -macro_rules! rule_group { - ($name:ident<$o:ty>; $($ty:ident),*) => ( - // make_pest_parse_function!($name<$o>; match_rule!( - // $( - // Rule::$ty => match_pair!(raw_pair!(p) => ParseUnwrapped::$ty(p)?), - // )* - // )); +macro_rules! rule_in_group { + ($name:ident<$o:ty>; $group:ident; $($args:tt)*) => ( + make_pest_parse_function!($name<$o>; match_pair!( $($args)* )); ); } -// macro_rules! match_rule { -// ($pair:expr; $($pat:pat => $submac:ident!( $($args:tt)* ),)*) => { -// { -// #[allow(unreachable_patterns)] -// match $pair.as_rule() { -// $( -// $pat => $submac!($pair; $($args)*), -// )* -// r => Err(custom_parse_error(&$pair, format!("Unexpected {:?}", r))), -// } -// } -// }; -// } - -// List of rules that can be shortcutted as implemented in binop!() +macro_rules! rule_group { + ($name:ident<$o:ty>; $($ty:ident),*) => (); +} + +// List of rules that can be shortcutted as implemented in parse_binop fn can_be_shortcutted(rule: Rule) -> bool { use Rule::*; match rule { @@ -474,42 +291,43 @@ fn can_be_shortcutted(rule: Rule) -> bool { } } +fn parse_binop(pair: Pair<Rule>, o: BinOp) -> ParseResult<RcExpr> { + // This all could be a trivial fold, but to avoid stack explosion + // we try to cut down on the recursion level here, by consuming + // chains of blah_expression > ... > blih_expression in one go. + let mut pair = pair; + let mut pairs = pair.into_inner(); + let first = pairs.next().unwrap(); + let rest: Vec<_> = pairs.map(ParseUnwrapped::expression).collect::<Result<_, _>>()?; + if !rest.is_empty() { + // If there is more than one subexpression, handle it normally + let first = ParseUnwrapped::expression(first)?; + Ok(rest.into_iter().fold(first, |acc, e| bx(Expr::BinOp(o, acc, e)))) + } else { + // Otherwise, consume short-cuttable rules as long as they contain only one subexpression. + // println!("short-cutting {}", debug_pair(pair.clone())); + pair = first; + while can_be_shortcutted(pair.as_rule()) { + let mut pairs = pair.clone().into_inner(); + let first = pairs.next().unwrap(); + let rest: Vec<_> = pairs.collect(); + if !rest.is_empty() { + break; + } + pair = first; + } + // println!("short-cutted {}", debug_pair(pair.clone())); + // println!(); + Ok(ParseUnwrapped::expression(pair)?) + } +} + macro_rules! binop { ($rule:ident<$ty:ty>; $op:ident) => { rule!($rule<$ty>; raw_pair!(pair) => { - // This all could be a trivial fold, but to avoid stack explosion - // we try to cut down on the recursion level here, by consuming - // chains of blah_expression > ... > blih_expression in one go. - let mut pair = pair; - let mut pairs = pair.into_inner(); - let first = pairs.next().unwrap(); - let rest: Vec<_> = pairs.map(ParseUnwrapped::expression).collect::<Result<_, _>>()?; - if !rest.is_empty() { - // If there is more than one subexpression, handle it normally - let first = ParseUnwrapped::expression(first)?; - rest.into_iter().fold(first, |acc, e| bx(Expr::BinOp(BinOp::$op, acc, e))) - } else { - // Otherwise, consume short-cuttable rules as long as they contain only one subexpression. - // println!("short-cutting {}", debug_pair(pair.clone())); - pair = first; - while can_be_shortcutted(pair.as_rule()) { - let mut pairs = pair.clone().into_inner(); - let first = pairs.next().unwrap(); - let rest: Vec<_> = pairs.collect(); - if !rest.is_empty() { - break; - } - pair = first; - } - // println!("short-cutted {}", debug_pair(pair.clone())); - // println!(); - ParseUnwrapped::expression(pair)? - } + parse_binop(pair, BinOp::$op)? } - // children!(first: expression, rest..: expression) => { - // rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::$op, acc, e))) - // } ); }; } @@ -517,12 +335,6 @@ macro_rules! binop { make_parser! { rule!(EOI<()>; children!() => ()); -// named!(str<&'a str>; captured_str!(s) => s.trim()); - -// named!(raw_str<&'a str>; captured_str!(s) => s); - -// named!(label<Label>; captured_str!(s) => Label::from(s.trim().to_owned())); - rule!(label_raw<Label>; captured_str!(s) => Label::from(s.trim().to_owned())); rule!(double_quote_literal<ParsedText>; @@ -638,26 +450,21 @@ rule!(path<PathBuf>; captured_str!(s) => (".".to_owned() + s).into() ); -rule_group!(local_raw<(FilePrefix, PathBuf)>; - parent_path, - here_path, - home_path, - absolute_path -); +rule_group!(local_raw<(FilePrefix, PathBuf)>;); -rule!(parent_path<(FilePrefix, PathBuf)>; +rule_in_group!(parent_path<(FilePrefix, PathBuf)>; local_raw; children!(p: path) => (FilePrefix::Parent, p) ); -rule!(here_path<(FilePrefix, PathBuf)>; +rule_in_group!(here_path<(FilePrefix, PathBuf)>; local_raw; children!(p: path) => (FilePrefix::Here, p) ); -rule!(home_path<(FilePrefix, PathBuf)>; +rule_in_group!(home_path<(FilePrefix, PathBuf)>; local_raw; children!(p: path) => (FilePrefix::Home, p) ); -rule!(absolute_path<(FilePrefix, PathBuf)>; +rule_in_group!(absolute_path<(FilePrefix, PathBuf)>; local_raw; children!(p: path) => (FilePrefix::Absolute, p) ); @@ -685,44 +492,9 @@ rule!(import_hashed_raw<(ImportLocation, Option<()>)>; } ); -rule_group!(expression<RcExpr>; - identifier_raw, - lambda_expression, - ifthenelse_expression, - let_expression, - forall_expression, - arrow_expression, - merge_expression, - empty_collection, - non_empty_optional, - - annotated_expression, - import_alt_expression, - or_expression, - plus_expression, - text_append_expression, - list_append_expression, - and_expression, - combine_expression, - prefer_expression, - combine_types_expression, - times_expression, - equal_expression, - not_equal_expression, - application_expression, - - import_raw, - selector_expression_raw, - literal_expression_raw, - empty_record_type, - empty_record_literal, - non_empty_record_type_or_literal, - union_type_or_literal, - non_empty_list_literal_raw, - final_expression -); - -rule!(import_raw<RcExpr>; +rule_group!(expression<RcExpr>;); + +rule_in_group!(import_raw<RcExpr>; expression; // TODO: handle "as Text" children!(import: import_hashed_raw) => { let (location, hash) = import; @@ -734,19 +506,19 @@ rule!(import_raw<RcExpr>; } ); -rule!(lambda_expression<RcExpr>; +rule_in_group!(lambda_expression<RcExpr>; expression; children!(l: label_raw, typ: expression, body: expression) => { bx(Expr::Lam(l, typ, body)) } ); -rule!(ifthenelse_expression<RcExpr>; +rule_in_group!(ifthenelse_expression<RcExpr>; expression; children!(cond: expression, left: expression, right: expression) => { bx(Expr::BoolIf(cond, left, right)) } ); -rule!(let_expression<RcExpr>; +rule_in_group!(let_expression<RcExpr>; expression; children!(bindings..: let_binding, final_expr: expression) => { bindings.fold(final_expr, |acc, x| bx(Expr::Let(x.0, x.1, x.2, acc))) } @@ -757,19 +529,19 @@ rule!(let_binding<(Label, Option<RcExpr>, RcExpr)>; children!(name: label_raw, expr: expression) => (name, None, expr), ); -rule!(forall_expression<RcExpr>; +rule_in_group!(forall_expression<RcExpr>; expression; children!(l: label_raw, typ: expression, body: expression) => { bx(Expr::Pi(l, typ, body)) } ); -rule!(arrow_expression<RcExpr>; +rule_in_group!(arrow_expression<RcExpr>; expression; children!(typ: expression, body: expression) => { bx(Expr::Pi("_".into(), typ, body)) } ); -rule!(merge_expression<RcExpr>; +rule_in_group!(merge_expression<RcExpr>; expression; children!(x: expression, y: expression, z: expression) => bx(Expr::Merge(x, y, Some(z))), children!(x: expression, y: expression) => bx(Expr::Merge(x, y, None)), ); @@ -777,7 +549,7 @@ rule!(merge_expression<RcExpr>; rule!(List<()>; children!() => ()); rule!(Optional<()>; children!() => ()); -rule!(empty_collection<RcExpr>; +rule_in_group!(empty_collection<RcExpr>; expression; children!(_x: List, y: expression) => { bx(Expr::EmptyListLit(y)) }, @@ -786,7 +558,7 @@ rule!(empty_collection<RcExpr>; }, ); -rule!(non_empty_optional<RcExpr>; +rule_in_group!(non_empty_optional<RcExpr>; expression; children!(x: expression, _y: Optional, z: expression) => { bx(Expr::OptionalLit(Some(z), Some(x))) } @@ -805,14 +577,14 @@ binop!(times_expression<RcExpr>; NaturalTimes); binop!(equal_expression<RcExpr>; BoolEQ); binop!(not_equal_expression<RcExpr>; BoolNE); -rule!(annotated_expression<RcExpr>; +rule_in_group!(annotated_expression<RcExpr>; expression; children!(e: expression, annot: expression) => { bx(Expr::Annot(e, annot)) }, children!(e: expression) => e, ); -rule!(application_expression<RcExpr>; +rule_in_group!(application_expression<RcExpr>; expression; children!(first: expression, rest..: expression) => { let rest: Vec<_> = rest.collect(); if rest.is_empty() { @@ -823,7 +595,7 @@ rule!(application_expression<RcExpr>; } ); -rule!(selector_expression_raw<RcExpr>; +rule_in_group!(selector_expression_raw<RcExpr>; expression; children!(first: expression, rest..: selector_raw) => { rest.fold(first, |acc, e| bx(Expr::Field(acc, e))) } @@ -836,7 +608,7 @@ rule!(selector_raw<Label>; } ); -rule!(literal_expression_raw<RcExpr>; +rule_in_group!(literal_expression_raw<RcExpr>; expression; children!(n: double_literal_raw) => bx(Expr::DoubleLit(n)), children!(n: minus_infinity_literal) => bx(Expr::DoubleLit(std::f64::NEG_INFINITY)), children!(n: plus_infinity_literal) => bx(Expr::DoubleLit(std::f64::INFINITY)), @@ -848,7 +620,7 @@ rule!(literal_expression_raw<RcExpr>; children!(e: expression) => e, ); -rule!(identifier_raw<RcExpr>; +rule_in_group!(identifier_raw<RcExpr>; expression; children!(l: label_raw, idx: natural_literal_raw) => { let name = String::from(l.clone()); match Builtin::parse(name.as_str()) { @@ -877,15 +649,15 @@ rule!(identifier_raw<RcExpr>; }, ); -rule!(empty_record_literal<RcExpr>; +rule_in_group!(empty_record_literal<RcExpr>; expression; children!() => bx(Expr::RecordLit(BTreeMap::new())) ); -rule!(empty_record_type<RcExpr>; +rule_in_group!(empty_record_type<RcExpr>; expression; children!() => bx(Expr::Record(BTreeMap::new())) ); -rule!(non_empty_record_type_or_literal<RcExpr>; +rule_in_group!(non_empty_record_type_or_literal<RcExpr>; expression; children!(first_label: label_raw, rest: non_empty_record_type) => { let (first_expr, mut map) = rest; map.insert(first_label, first_expr); @@ -918,7 +690,7 @@ rule!(record_literal_entry<(Label, RcExpr)>; children!(name: label_raw, expr: expression) => (name, expr) ); -rule!(union_type_or_literal<RcExpr>; +rule_in_group!(union_type_or_literal<RcExpr>; expression; children!(_e: empty_union_type) => { bx(Expr::Union(BTreeMap::new())) }, @@ -959,13 +731,13 @@ rule!(union_type_entry<(Label, RcExpr)>; children!(name: label_raw, expr: expression) => (name, expr) ); -rule!(non_empty_list_literal_raw<RcExpr>; +rule_in_group!(non_empty_list_literal_raw<RcExpr>; expression; children!(items..: expression) => { bx(Expr::NEListLit(items.collect())) } ); -rule!(final_expression<RcExpr>; +rule_in_group!(final_expression<RcExpr>; expression; children!(e: expression, _eoi: EOI) => e ); } |