Change syntax of parser macros

1 files changed, 148 insertions, 148 deletions

diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs
index 52e8c64..34b6a13 100644
--- a/dhall_core/src/parser.rs
+++ b/dhall_core/src/parser.rs
@@ -72,10 +72,10 @@ fn debug_pair(pair: Pair<Rule>) -> String {
 }
 
 macro_rules! match_pair {
-    (@make_child_match, $pair:expr, ($($outer_acc:tt)*), ($($acc:tt)*), ($(,)* $x:ident : $ty:ident $($rest_of_match:tt)*) => $body:expr, $($rest:tt)*) => {
+    (@make_child_match, $pair:expr, ($($outer_acc:tt)*), ($($acc:tt)*), ($(,)* $ty:ident ($x: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)*)
     };
-    (@make_child_match, $pair:expr, ($($outer_acc:tt)*), ($($acc:tt)*), ($(,)* $x:ident.. : $ty:ident $($rest_of_match:tt)*) => $body:expr, $($rest:tt)*) => {
+    (@make_child_match, $pair:expr, ($($outer_acc:tt)*), ($($acc:tt)*), ($(,)* $ty:ident ($x:ident..) $($rest_of_match:tt)*) => $body:expr, $($rest:tt)*) => {
         match_pair!(@make_child_match, $pair, ($($outer_acc)*), ($($acc)*, x..), ($($rest_of_match)*) => {
             let $x = x.map(|x| x.$ty());
             $body
@@ -88,7 +88,7 @@ macro_rules! match_pair {
         match_pair!(@make_matches, $pair, ([] => { $body }, $($outer_acc)*), $($rest)*)
     };
 
-    (@make_matches, $pair:expr, ($($acc:tt)*), children!($($args:tt)*) => $body:expr, $($rest:tt)*) => {
+    (@make_matches, $pair:expr, ($($acc:tt)*), [$($args:tt)*] => $body:expr, $($rest:tt)*) => {
         match_pair!(@make_child_match, $pair, ($($acc)*), (), ($($args)*) => $body, $($rest)*)
     };
     (@make_matches, $pair:expr, ($($acc:tt)*) $(,)*) => {
@@ -104,8 +104,8 @@ macro_rules! match_pair {
         }
     };
 
-    ($pair:expr; $( $submac:ident!($($args:tt)*) => $body:expr ),* $(,)*) => {
-        match_pair!(@make_matches, $pair, (), $( $submac!($($args)*) => $body ),* ,)
+    ($pair:expr; $( [$($args:tt)*] => $body:expr ),* $(,)*) => {
+        match_pair!(@make_matches, $pair, (), $( [$($args)*] => $body ),* ,)
     };
 }
 
@@ -128,7 +128,7 @@ macro_rules! make_parser {
         let res: $o = $body;
         Ok(ParsedValue::$group(res))
     });
-    (@body, $pair:expr, rule_in_group!( $name:ident<$o:ty>; $group:ident; $($args:tt)* )) => ( {
+    (@body, $pair:expr, rule_in_group!( $name:ident<$o:ty>; $group:ident; children!( $($args:tt)* ) )) => ( {
         let res: $o = match_pair!($pair; $($args)*)?;
         Ok(ParsedValue::$group(res))
     });
@@ -254,23 +254,23 @@ rule!(EOI<()>; raw_pair!(_) => ());
 
 rule!(label_raw<Label>; captured_str!(s) => Label::from(s.trim().to_owned()));
 
-rule!(double_quote_literal<ParsedText>;
-    children!(chunks..: double_quote_chunk) => {
+rule!(double_quote_literal<ParsedText>; children!(
+    [double_quote_chunk(chunks..)] => {
         chunks.collect()
     }
-);
+));
 
-rule!(double_quote_chunk<ParsedTextContents<'a>>;
-    children!(c: interpolation) => {
+rule!(double_quote_chunk<ParsedTextContents<'a>>; children!(
+    [interpolation(c)] => {
         InterpolatedTextContents::Expr(c)
     },
-    children!(s: double_quote_escaped) => {
+    [double_quote_escaped(s)] => {
         InterpolatedTextContents::Text(s)
     },
-    children!(s: double_quote_char) => {
+    [double_quote_char(s)] => {
         InterpolatedTextContents::Text(s)
     },
-);
+));
 rule!(double_quote_escaped<&'a str>;
     // TODO: parse all escapes
     captured_str!(s) => {
@@ -295,11 +295,11 @@ rule!(double_quote_char<&'a str>;
 
 rule!(end_of_line<()>; raw_pair!(_) => ());
 
-rule!(single_quote_literal<ParsedText>;
-    children!(eol: end_of_line, contents: single_quote_continue) => {
+rule!(single_quote_literal<ParsedText>; children!(
+    [end_of_line(eol), single_quote_continue(contents)] => {
         contents.into_iter().rev().collect::<ParsedText>()
     }
-);
+));
 rule!(single_quote_char<&'a str>;
     captured_str!(s) => s
 );
@@ -309,31 +309,31 @@ rule!(escaped_quote_pair<&'a str>;
 rule!(escaped_interpolation<&'a str>;
     raw_pair!(_) => "${"
 );
-rule!(interpolation<RcExpr>;
-    children!(e: expression) => e
-);
+rule!(interpolation<RcExpr>; children!(
+    [expression(e)] => e
+));
 
-rule!(single_quote_continue<Vec<ParsedTextContents<'a>>>;
-    children!(c: interpolation, rest: single_quote_continue) => {
+rule!(single_quote_continue<Vec<ParsedTextContents<'a>>>; children!(
+    [interpolation(c), single_quote_continue(rest)] => {
         let mut rest = rest;
         rest.push(InterpolatedTextContents::Expr(c)); rest
     },
-    children!(c: escaped_quote_pair, rest: single_quote_continue) => {
+    [escaped_quote_pair(c), single_quote_continue(rest)] => {
         let mut rest = rest;
         rest.push(InterpolatedTextContents::Text(c)); rest
     },
-    children!(c: escaped_interpolation, rest: single_quote_continue) => {
+    [escaped_interpolation(c), single_quote_continue(rest)] => {
         let mut rest = rest;
         rest.push(InterpolatedTextContents::Text(c)); rest
     },
-    children!(c: single_quote_char, rest: single_quote_continue) => {
+    [single_quote_char(c), single_quote_continue(rest)] => {
         let mut rest = rest;
         rest.push(InterpolatedTextContents::Text(c)); rest
     },
-    children!() => {
+    [] => {
         vec![]
     },
-);
+));
 
 rule!(NaN_raw<()>; raw_pair!(_) => ());
 rule!(minus_infinity_literal<()>; raw_pair!(_) => ());
@@ -369,51 +369,51 @@ rule!(path<PathBuf>;
 
 rule_group!(local_raw<(FilePrefix, PathBuf)>);
 
-rule_in_group!(parent_path<(FilePrefix, PathBuf)>; local_raw;
-    children!(p: path) => (FilePrefix::Parent, p)
-);
+rule_in_group!(parent_path<(FilePrefix, PathBuf)>; local_raw; children!(
+    [path(p)] => (FilePrefix::Parent, p)
+));
 
-rule_in_group!(here_path<(FilePrefix, PathBuf)>; local_raw;
-    children!(p: path) => (FilePrefix::Here, p)
-);
+rule_in_group!(here_path<(FilePrefix, PathBuf)>; local_raw; children!(
+    [path(p)] => (FilePrefix::Here, p)
+));
 
-rule_in_group!(home_path<(FilePrefix, PathBuf)>; local_raw;
-    children!(p: path) => (FilePrefix::Home, p)
-);
+rule_in_group!(home_path<(FilePrefix, PathBuf)>; local_raw; children!(
+    [path(p)] => (FilePrefix::Home, p)
+));
 
-rule_in_group!(absolute_path<(FilePrefix, PathBuf)>; local_raw;
-    children!(p: path) => (FilePrefix::Absolute, p)
-);
+rule_in_group!(absolute_path<(FilePrefix, PathBuf)>; local_raw; children!(
+    [path(p)] => (FilePrefix::Absolute, p)
+));
 
 // TODO: other import types
-rule!(import_type_raw<ImportLocation>;
-    // children!(_e: missing_raw) => {
+rule!(import_type_raw<ImportLocation>; children!(
+    // [missing_raw(_e)] => {
     //     ImportLocation::Missing
     // }
-    // children!(e: env_raw) => {
+    // [env_raw(e)] => {
     //     ImportLocation::Env(e)
     // }
-    // children!(url: http) => {
+    // [http(url)] => {
     //     ImportLocation::Remote(url)
     // }
-    children!(import: local_raw) => {
+    [local_raw(import)] => {
         let (prefix, path) = import;
         ImportLocation::Local(prefix, path)
     }
-);
+));
 
-rule!(import_hashed_raw<(ImportLocation, Option<()>)>;
+rule!(import_hashed_raw<(ImportLocation, Option<()>)>; children!(
     // TODO: handle hash
-    children!(import: import_type_raw) => {
+    [import_type_raw(import)] => {
         (import, None)
     }
-);
+));
 
 rule_group!(expression<RcExpr>);
 
-rule_in_group!(import_raw<RcExpr>; expression;
+rule_in_group!(import_raw<RcExpr>; expression; children!(
     // TODO: handle "as Text"
-    children!(import: import_hashed_raw) => {
+    [import_hashed_raw(import)] => {
         let (location, hash) = import;
         bx(Expr::Embed(Import {
             mode: ImportMode::Code,
@@ -421,65 +421,65 @@ rule_in_group!(import_raw<RcExpr>; expression;
             location,
         }))
     }
-);
+));
 
-rule_in_group!(lambda_expression<RcExpr>; expression;
-    children!(l: label_raw, typ: expression, body: expression) => {
+rule_in_group!(lambda_expression<RcExpr>; expression; children!(
+    [label_raw(l), expression(typ), expression(body)] => {
         bx(Expr::Lam(l, typ, body))
     }
-);
+));
 
-rule_in_group!(ifthenelse_expression<RcExpr>; expression;
-    children!(cond: expression, left: expression, right: expression) => {
+rule_in_group!(ifthenelse_expression<RcExpr>; expression; children!(
+    [expression(cond), expression(left), expression(right)] => {
         bx(Expr::BoolIf(cond, left, right))
     }
-);
+));
 
-rule_in_group!(let_expression<RcExpr>; expression;
-    children!(bindings..: let_binding, final_expr: expression) => {
+rule_in_group!(let_expression<RcExpr>; expression; children!(
+    [let_binding(bindings..), expression(final_expr)] => {
         bindings.fold(final_expr, |acc, x| bx(Expr::Let(x.0, x.1, x.2, acc)))
     }
-);
+));
 
-rule!(let_binding<(Label, Option<RcExpr>, RcExpr)>;
-    children!(name: label_raw, annot: expression, expr: expression) => (name, Some(annot), expr),
-    children!(name: label_raw, expr: expression) => (name, None, expr),
-);
+rule!(let_binding<(Label, Option<RcExpr>, RcExpr)>; children!(
+    [label_raw(name), expression(annot), expression(expr)] => (name, Some(annot), expr),
+    [label_raw(name), expression(expr)] => (name, None, expr),
+));
 
-rule_in_group!(forall_expression<RcExpr>; expression;
-    children!(l: label_raw, typ: expression, body: expression) => {
+rule_in_group!(forall_expression<RcExpr>; expression; children!(
+    [label_raw(l), expression(typ), expression(body)] => {
         bx(Expr::Pi(l, typ, body))
     }
-);
+));
 
-rule_in_group!(arrow_expression<RcExpr>; expression;
-    children!(typ: expression, body: expression) => {
+rule_in_group!(arrow_expression<RcExpr>; expression; children!(
+    [expression(typ), expression(body)] => {
         bx(Expr::Pi("_".into(), typ, body))
     }
-);
+));
 
-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)),
-);
+rule_in_group!(merge_expression<RcExpr>; expression; children!(
+    [expression(x), expression(y), expression(z)] => bx(Expr::Merge(x, y, Some(z))),
+    [expression(x), expression(y)] => bx(Expr::Merge(x, y, None)),
+));
 
 rule!(List<()>; raw_pair!(_) => ());
 rule!(Optional<()>; raw_pair!(_) => ());
 
-rule_in_group!(empty_collection<RcExpr>; expression;
-    children!(_x: List, y: expression) => {
+rule_in_group!(empty_collection<RcExpr>; expression; children!(
+    [List(_x), expression(y)] => {
         bx(Expr::EmptyListLit(y))
     },
-    children!(_x: Optional, y: expression) => {
+    [Optional(_x), expression(y)] => {
         bx(Expr::OptionalLit(Some(y), None))
     },
-);
+));
 
-rule_in_group!(non_empty_optional<RcExpr>; expression;
-    children!(x: expression, _y: Optional, z: expression) => {
+rule_in_group!(non_empty_optional<RcExpr>; expression; children!(
+    [expression(x), Optional(_y), expression(z)] => {
         bx(Expr::OptionalLit(Some(z), Some(x)))
     }
-);
+));
 
 rule_in_group!(import_alt_expression<RcExpr>; expression;
     raw_pair!(p) => parse_binop(p, BinOp::ImportAlt)?
@@ -518,15 +518,15 @@ rule_in_group!(not_equal_expression<RcExpr>; expression;
     raw_pair!(p) => parse_binop(p, BinOp::BoolNE)?
 );
 
-rule_in_group!(annotated_expression<RcExpr>; expression;
-    children!(e: expression, annot: expression) => {
+rule_in_group!(annotated_expression<RcExpr>; expression; children!(
+    [expression(e), expression(annot)] => {
         bx(Expr::Annot(e, annot))
     },
-    children!(e: expression) => e,
-);
+    [expression(e)] => e,
+));
 
-rule_in_group!(application_expression<RcExpr>; expression;
-    children!(first: expression, rest..: expression) => {
+rule_in_group!(application_expression<RcExpr>; expression; children!(
+    [expression(first), expression(rest..)] => {
         let rest: Vec<_> = rest.collect();
         if rest.is_empty() {
             first
@@ -534,35 +534,35 @@ rule_in_group!(application_expression<RcExpr>; expression;
             bx(Expr::App(first, rest))
         }
     }
-);
+));
 
-rule_in_group!(selector_expression_raw<RcExpr>; expression;
-    children!(first: expression, rest..: selector_raw) => {
+rule_in_group!(selector_expression_raw<RcExpr>; expression; children!(
+    [expression(first), selector_raw(rest..)] => {
         rest.fold(first, |acc, e| bx(Expr::Field(acc, e)))
     }
-);
+));
 
 // TODO: handle record projection
-rule!(selector_raw<Label>;
-    children!(l: label_raw) => {
+rule!(selector_raw<Label>; children!(
+    [label_raw(l)] => {
         l
     }
-);
-
-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)),
-    children!(n: NaN_raw) => bx(Expr::DoubleLit(std::f64::NAN)),
-    children!(n: natural_literal_raw) => bx(Expr::NaturalLit(n)),
-    children!(n: integer_literal_raw) => bx(Expr::IntegerLit(n)),
-    children!(s: double_quote_literal) => bx(Expr::TextLit(s)),
-    children!(s: single_quote_literal) => bx(Expr::TextLit(s)),
-    children!(e: expression) => e,
-);
-
-rule_in_group!(identifier_raw<RcExpr>; expression;
-    children!(l: label_raw, idx: natural_literal_raw) => {
+));
+
+rule_in_group!(literal_expression_raw<RcExpr>; expression; children!(
+    [double_literal_raw(n)] => bx(Expr::DoubleLit(n)),
+    [minus_infinity_literal(n)] => bx(Expr::DoubleLit(std::f64::NEG_INFINITY)),
+    [plus_infinity_literal(n)] => bx(Expr::DoubleLit(std::f64::INFINITY)),
+    [NaN_raw(n)] => bx(Expr::DoubleLit(std::f64::NAN)),
+    [natural_literal_raw(n)] => bx(Expr::NaturalLit(n)),
+    [integer_literal_raw(n)] => bx(Expr::IntegerLit(n)),
+    [double_quote_literal(s)] => bx(Expr::TextLit(s)),
+    [single_quote_literal(s)] => bx(Expr::TextLit(s)),
+    [expression(e)] => e,
+));
+
+rule_in_group!(identifier_raw<RcExpr>; expression; children!(
+    [label_raw(l), natural_literal_raw(idx)] => {
         let name = String::from(l.clone());
         match Builtin::parse(name.as_str()) {
             Some(b) => bx(Expr::Builtin(b)),
@@ -575,7 +575,7 @@ rule_in_group!(identifier_raw<RcExpr>; expression;
             }
         }
     },
-    children!(l: label_raw) => {
+    [label_raw(l)] => {
         let name = String::from(l.clone());
         match Builtin::parse(name.as_str()) {
             Some(b) => bx(Expr::Builtin(b)),
@@ -588,7 +588,7 @@ rule_in_group!(identifier_raw<RcExpr>; expression;
             }
         }
     },
-);
+));
 
 rule_in_group!(empty_record_literal<RcExpr>; expression;
     raw_pair!(_) => bx(Expr::RecordLit(BTreeMap::new()))
@@ -598,89 +598,89 @@ rule_in_group!(empty_record_type<RcExpr>; expression;
     raw_pair!(_) => bx(Expr::Record(BTreeMap::new()))
 );
 
-rule_in_group!(non_empty_record_type_or_literal<RcExpr>; expression;
-    children!(first_label: label_raw, rest: non_empty_record_type) => {
+rule_in_group!(non_empty_record_type_or_literal<RcExpr>; expression; children!(
+    [label_raw(first_label), non_empty_record_type(rest)] => {
         let (first_expr, mut map) = rest;
         map.insert(first_label, first_expr);
         bx(Expr::Record(map))
     },
-    children!(first_label: label_raw, rest: non_empty_record_literal) => {
+    [label_raw(first_label), non_empty_record_literal(rest)] => {
         let (first_expr, mut map) = rest;
         map.insert(first_label, first_expr);
         bx(Expr::RecordLit(map))
     },
-);
+));
 
-rule!(non_empty_record_type<(RcExpr, BTreeMap<Label, RcExpr>)>;
-    children!(expr: expression, entries..: record_type_entry) => {
+rule!(non_empty_record_type<(RcExpr, BTreeMap<Label, RcExpr>)>; children!(
+    [expression(expr), record_type_entry(entries..)] => {
         (expr, entries.collect())
     }
-);
+));
 
-rule!(record_type_entry<(Label, RcExpr)>;
-    children!(name: label_raw, expr: expression) => (name, expr)
-);
+rule!(record_type_entry<(Label, RcExpr)>; children!(
+    [label_raw(name), expression(expr)] => (name, expr)
+));
 
-rule!(non_empty_record_literal<(RcExpr, BTreeMap<Label, RcExpr>)>;
-    children!(expr: expression, entries..: record_literal_entry) => {
+rule!(non_empty_record_literal<(RcExpr, BTreeMap<Label, RcExpr>)>; children!(
+    [expression(expr), record_literal_entry(entries..)] => {
         (expr, entries.collect())
     }
-);
+));
 
-rule!(record_literal_entry<(Label, RcExpr)>;
-    children!(name: label_raw, expr: expression) => (name, expr)
-);
+rule!(record_literal_entry<(Label, RcExpr)>; children!(
+    [label_raw(name), expression(expr)] => (name, expr)
+));
 
-rule_in_group!(union_type_or_literal<RcExpr>; expression;
-    children!(_e: empty_union_type) => {
+rule_in_group!(union_type_or_literal<RcExpr>; expression; children!(
+    [empty_union_type(_e)] => {
         bx(Expr::Union(BTreeMap::new()))
     },
-    children!(x: non_empty_union_type_or_literal) => {
+    [non_empty_union_type_or_literal(x)] => {
         match x {
             (Some((l, e)), entries) => bx(Expr::UnionLit(l, e, entries)),
             (None, entries) => bx(Expr::Union(entries)),
         }
     },
-);
+));
 
 rule!(empty_union_type<()>; raw_pair!(_) => ());
 
 rule!(non_empty_union_type_or_literal
-      <(Option<(Label, RcExpr)>, BTreeMap<Label, RcExpr>)>;
-    children!(l: label_raw, e: expression, entries: union_type_entries) => {
+      <(Option<(Label, RcExpr)>, BTreeMap<Label, RcExpr>)>; children!(
+    [label_raw(l), expression(e), union_type_entries(entries)] => {
         (Some((l, e)), entries)
     },
-    children!(l: label_raw, e: expression, rest: non_empty_union_type_or_literal) => {
+    [label_raw(l), expression(e), non_empty_union_type_or_literal(rest)] => {
         let (x, mut entries) = rest;
         entries.insert(l, e);
         (x, entries)
     },
-    children!(l: label_raw, e: expression) => {
+    [label_raw(l), expression(e)] => {
         let mut entries = BTreeMap::new();
         entries.insert(l, e);
         (None, entries)
     },
-);
+  ));
 
-rule!(union_type_entries<BTreeMap<Label, RcExpr>>;
-    children!(entries..: union_type_entry) => {
+rule!(union_type_entries<BTreeMap<Label, RcExpr>>; children!(
+    [union_type_entry(entries..)] => {
         entries.collect()
     }
-);
+));
 
-rule!(union_type_entry<(Label, RcExpr)>;
-    children!(name: label_raw, expr: expression) => (name, expr)
-);
+rule!(union_type_entry<(Label, RcExpr)>; children!(
+    [label_raw(name), expression(expr)] => (name, expr)
+));
 
-rule_in_group!(non_empty_list_literal_raw<RcExpr>; expression;
-    children!(items..: expression) => {
+rule_in_group!(non_empty_list_literal_raw<RcExpr>; expression; children!(
+    [expression(items..)] => {
         bx(Expr::NEListLit(items.collect()))
     }
-);
+));
 
-rule_in_group!(final_expression<RcExpr>; expression;
-    children!(e: expression, _eoi: EOI) => e
-);
+rule_in_group!(final_expression<RcExpr>; expression; children!(
+    [expression(e), EOI(_eoi)] => e
+));
 }
 
 pub fn parse_expr(s: &str) -> ParseResult<RcExpr> {