Cleanup parser

1 files changed, 64 insertions, 91 deletions

diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs
index ef7fcc9..caeebd0 100644
--- a/dhall_core/src/parser.rs
+++ b/dhall_core/src/parser.rs
@@ -72,9 +72,15 @@ fn debug_pair(pair: Pair<Rule>) -> String {
 }
 
 macro_rules! match_pair {
-    (@make_child_match, ($($vars:tt)*), ($($outer_acc:tt)*), ($($acc:tt)*), ($(,)* $ty:ident ($x:ident..) $($rest_of_match:tt)*) => $body:expr, $($rest:tt)*) => {
-        match_pair!(@make_child_match, ($($vars)*), ($($outer_acc)*), ($($acc)*, x..), ($($rest_of_match)*) => {
-            let $x = x.map(|x| x.$ty());
+    (@make_child_match, ($pair:expr, $($vars:tt)*), ($($outer_acc:tt)*), ($($acc:tt)*), ($(,)* $ty:ident ($x:ident..) $($rest_of_match:tt)*) => $body:expr, $($rest:tt)*) => {
+        match_pair!(@make_child_match, ($pair, $($vars)*), ($($outer_acc)*), ($($acc)*, xs..), ($($rest_of_match)*) => {
+            let xs = xs.map(|x| match x {
+                ParsedValue::$ty(y) => Ok(y),
+                x => Err(custom_parse_error(&$pair,
+                    format!("Unexpected child: {:?}", x)
+                )),
+            }).collect::<Result<Vec<_>, _>>()?;
+            let $x = xs.into_iter();
             $body
         }, $($rest)*)
     };
@@ -93,13 +99,16 @@ macro_rules! match_pair {
     };
     (@make_matches, ($pair:expr, $parsed:expr), ($($acc:tt)*) $(,)*) => {
         {
-            let pair = $pair;
-            let rule = pair.as_rule();
+            let pair = $pair.clone();
             #[allow(unreachable_code)]
             iter_patterns::match_vec!($parsed;
                 $($acc)*
-                [x..] => panic!("Unexpected children while parsing rule '{:?}': {:?}", rule, x.collect::<Vec<_>>()),
-            ).ok_or_else(|| custom_parse_error(&pair, "No match found".to_owned()))
+                [x..] => Err(
+                    custom_parse_error(&pair,
+                        format!("Unexpected children: {:?}", x.collect::<Vec<_>>())
+                    )
+                )?,
+            ).ok_or_else(|| unreachable!())
         }
     };
 
@@ -111,23 +120,22 @@ macro_rules! match_pair {
 macro_rules! make_parser {
     // Filter out definitions that should not be matched on (i.e. rule_group)
     (@filter, rule) => (true);
-    (@filter, rule_in_group) => (true);
     (@filter, rule_group) => (false);
 
     (@body, $pair:expr, $parsed:expr, rule!( $name:ident<$o:ty>; $($args:tt)* )) => (
-        make_parser!(@body, $pair, $parsed, rule_in_group!( $name<$o>; $name; $($args)* ))
+        make_parser!(@body, $pair, $parsed, rule!( $name<$o> as $name; $($args)* ))
     );
-    (@body, $pair:expr, $parsed:expr, rule_in_group!( $name:ident<$o:ty>; $group:ident; raw_pair!($x:pat) => $body:expr )) => ( {
-        let $x = $pair.clone();
+    (@body, $pair:expr, $parsed:expr, rule!( $name:ident<$o:ty> as $group:ident; raw_pair!($x:pat) => $body:expr )) => ( {
+        let $x = $pair;
         let res: $o = $body;
         Ok(ParsedValue::$group(res))
     });
-    (@body, $pair:expr, $parsed:expr, rule_in_group!( $name:ident<$o:ty>; $group:ident; captured_str!($x:ident) => $body:expr )) => ( {
+    (@body, $pair:expr, $parsed:expr, rule!( $name:ident<$o:ty> as $group:ident; captured_str!($x:ident) => $body:expr )) => ( {
         let $x = $pair.as_str();
         let res: $o = $body;
         Ok(ParsedValue::$group(res))
     });
-    (@body, $pair:expr, $parsed:expr, rule_in_group!( $name:ident<$o:ty>; $group:ident; children!( $($args:tt)* ) )) => ( {
+    (@body, $pair:expr, $parsed:expr, rule!( $name:ident<$o:ty> as $group:ident; children!( $($args:tt)* ) )) => ( {
         let res: $o = match_pair!(($pair, $parsed); $($args)*)?;
         Ok(ParsedValue::$group(res))
     });
@@ -137,46 +145,12 @@ macro_rules! make_parser {
 
 
     ($( $submac:ident!( $name:ident<$o:ty> $($args:tt)* ); )*) => (
-        // #[allow(non_camel_case_types, dead_code)]
-        // enum ParsedType {
-        //     $( $name, )*
-        // }
-
-        // impl ParsedType {
-        //     #[allow(dead_code)]
-        //     fn parse(self, pair: Pair<Rule>) -> ParseResult<ParsedValue> {
-        //         match self {
-        //             $( ParsedType::$name => {
-        //                 let ret = $name(pair)?;
-        //                 Ok(ParsedValue::$name(ret))
-        //             }, )*
-        //         }
-        //     }
-        //     // fn parse(self, pair: Pair<Rule>) -> ParseResult<ParsedValue> {
-        //     //     match self {
-        //     //         $( ParsedType::$name => $name(pair), )*
-        //     //     }
-        //     // }
-        // }
-
         #[allow(non_camel_case_types, dead_code)]
         #[derive(Debug)]
         enum ParsedValue<'a> {
             $( $name($o), )*
         }
 
-        impl<'a> ParsedValue<'a> {
-            $(
-                #[allow(non_snake_case, dead_code)]
-                fn $name(self) -> $o {
-                    match self {
-                        ParsedValue::$name(x) => x,
-                        _ => unreachable!(),
-                    }
-                }
-            )*
-        }
-
         // Non-recursive implementation to avoid stack overflows
         fn parse_any<'a>(initial_pair: Pair<'a, Rule>) -> ParseResult<ParsedValue<'a>> {
             enum StackFrame<'a> {
@@ -366,19 +340,19 @@ rule!(path<PathBuf>;
 
 rule_group!(local_raw<(FilePrefix, PathBuf)>);
 
-rule_in_group!(parent_path<(FilePrefix, PathBuf)>; local_raw; children!(
+rule!(parent_path<(FilePrefix, PathBuf)> as local_raw; children!(
     [path(p)] => (FilePrefix::Parent, p)
 ));
 
-rule_in_group!(here_path<(FilePrefix, PathBuf)>; local_raw; children!(
+rule!(here_path<(FilePrefix, PathBuf)> as local_raw; children!(
     [path(p)] => (FilePrefix::Here, p)
 ));
 
-rule_in_group!(home_path<(FilePrefix, PathBuf)>; local_raw; children!(
+rule!(home_path<(FilePrefix, PathBuf)> as local_raw; children!(
     [path(p)] => (FilePrefix::Home, p)
 ));
 
-rule_in_group!(absolute_path<(FilePrefix, PathBuf)>; local_raw; children!(
+rule!(absolute_path<(FilePrefix, PathBuf)> as local_raw; children!(
     [path(p)] => (FilePrefix::Absolute, p)
 ));
 
@@ -405,7 +379,7 @@ rule!(import_hashed_raw<(ImportLocation, Option<()>)>; children!(
 
 rule_group!(expression<RcExpr>);
 
-rule_in_group!(import_raw<RcExpr>; expression; children!(
+rule!(import_raw<RcExpr> as expression; children!(
     // TODO: handle "as Text"
     [import_hashed_raw((location, hash))] => {
         bx(Expr::Embed(Import {
@@ -416,19 +390,19 @@ rule_in_group!(import_raw<RcExpr>; expression; children!(
     }
 ));
 
-rule_in_group!(lambda_expression<RcExpr>; expression; children!(
+rule!(lambda_expression<RcExpr> as expression; children!(
     [label_raw(l), expression(typ), expression(body)] => {
         bx(Expr::Lam(l, typ, body))
     }
 ));
 
-rule_in_group!(ifthenelse_expression<RcExpr>; expression; children!(
+rule!(ifthenelse_expression<RcExpr> as expression; children!(
     [expression(cond), expression(left), expression(right)] => {
         bx(Expr::BoolIf(cond, left, right))
     }
 ));
 
-rule_in_group!(let_expression<RcExpr>; expression; children!(
+rule!(let_expression<RcExpr> as expression; children!(
     [let_binding(bindings..), expression(final_expr)] => {
         bindings.fold(final_expr, |acc, x| bx(Expr::Let(x.0, x.1, x.2, acc)))
     }
@@ -439,19 +413,19 @@ rule!(let_binding<(Label, Option<RcExpr>, RcExpr)>; children!(
     [label_raw(name), expression(expr)] => (name, None, expr),
 ));
 
-rule_in_group!(forall_expression<RcExpr>; expression; children!(
+rule!(forall_expression<RcExpr> as expression; children!(
     [label_raw(l), expression(typ), expression(body)] => {
         bx(Expr::Pi(l, typ, body))
     }
 ));
 
-rule_in_group!(arrow_expression<RcExpr>; expression; children!(
+rule!(arrow_expression<RcExpr> as expression; children!(
     [expression(typ), expression(body)] => {
         bx(Expr::Pi("_".into(), typ, body))
     }
 ));
 
-rule_in_group!(merge_expression<RcExpr>; expression; children!(
+rule!(merge_expression<RcExpr> as 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)),
 ));
@@ -459,7 +433,7 @@ rule_in_group!(merge_expression<RcExpr>; expression; children!(
 rule!(List<()>; raw_pair!(_) => ());
 rule!(Optional<()>; raw_pair!(_) => ());
 
-rule_in_group!(empty_collection<RcExpr>; expression; children!(
+rule!(empty_collection<RcExpr> as expression; children!(
     [List(_), expression(y)] => {
         bx(Expr::EmptyListLit(y))
     },
@@ -468,93 +442,93 @@ rule_in_group!(empty_collection<RcExpr>; expression; children!(
     },
 ));
 
-rule_in_group!(non_empty_optional<RcExpr>; expression; children!(
+rule!(non_empty_optional<RcExpr> as expression; children!(
     [expression(x), Optional(_), expression(z)] => {
         bx(Expr::OptionalLit(Some(z), Some(x)))
     }
 ));
 
-rule_in_group!(import_alt_expression<RcExpr>; expression; children!(
+rule!(import_alt_expression<RcExpr> as expression; children!(
     [expression(e)] => e,
     [expression(first), expression(rest..)] => {
         rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::ImportAlt, acc, e)))
     },
 ));
-rule_in_group!(or_expression<RcExpr>; expression; children!(
+rule!(or_expression<RcExpr> as expression; children!(
     [expression(e)] => e,
     [expression(first), expression(rest..)] => {
         rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::BoolOr, acc, e)))
     },
 ));
-rule_in_group!(plus_expression<RcExpr>; expression; children!(
+rule!(plus_expression<RcExpr> as expression; children!(
     [expression(e)] => e,
     [expression(first), expression(rest..)] => {
         rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::NaturalPlus, acc, e)))
     },
 ));
-rule_in_group!(text_append_expression<RcExpr>; expression; children!(
+rule!(text_append_expression<RcExpr> as expression; children!(
     [expression(e)] => e,
     [expression(first), expression(rest..)] => {
         rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::TextAppend, acc, e)))
     },
 ));
-rule_in_group!(list_append_expression<RcExpr>; expression; children!(
+rule!(list_append_expression<RcExpr> as expression; children!(
     [expression(e)] => e,
     [expression(first), expression(rest..)] => {
         rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::ListAppend, acc, e)))
     },
 ));
-rule_in_group!(and_expression<RcExpr>; expression; children!(
+rule!(and_expression<RcExpr> as expression; children!(
     [expression(e)] => e,
     [expression(first), expression(rest..)] => {
         rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::BoolAnd, acc, e)))
     },
 ));
-rule_in_group!(combine_expression<RcExpr>; expression; children!(
+rule!(combine_expression<RcExpr> as expression; children!(
     [expression(e)] => e,
     [expression(first), expression(rest..)] => {
         rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::Combine, acc, e)))
     },
 ));
-rule_in_group!(prefer_expression<RcExpr>; expression; children!(
+rule!(prefer_expression<RcExpr> as expression; children!(
     [expression(e)] => e,
     [expression(first), expression(rest..)] => {
         rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::Prefer, acc, e)))
     },
 ));
-rule_in_group!(combine_types_expression<RcExpr>; expression; children!(
+rule!(combine_types_expression<RcExpr> as expression; children!(
     [expression(e)] => e,
     [expression(first), expression(rest..)] => {
         rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::CombineTypes, acc, e)))
     },
 ));
-rule_in_group!(times_expression<RcExpr>; expression; children!(
+rule!(times_expression<RcExpr> as expression; children!(
     [expression(e)] => e,
     [expression(first), expression(rest..)] => {
         rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::NaturalTimes, acc, e)))
     },
 ));
-rule_in_group!(equal_expression<RcExpr>; expression; children!(
+rule!(equal_expression<RcExpr> as expression; children!(
     [expression(e)] => e,
     [expression(first), expression(rest..)] => {
         rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::BoolEQ, acc, e)))
     },
 ));
-rule_in_group!(not_equal_expression<RcExpr>; expression; children!(
+rule!(not_equal_expression<RcExpr> as expression; children!(
     [expression(e)] => e,
     [expression(first), expression(rest..)] => {
         rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::BoolNE, acc, e)))
     },
 ));
 
-rule_in_group!(annotated_expression<RcExpr>; expression; children!(
+rule!(annotated_expression<RcExpr> as expression; children!(
     [expression(e), expression(annot)] => {
         bx(Expr::Annot(e, annot))
     },
     [expression(e)] => e,
 ));
 
-rule_in_group!(application_expression<RcExpr>; expression; children!(
+rule!(application_expression<RcExpr> as expression; children!(
     [expression(first), expression(rest..)] => {
         let rest: Vec<_> = rest.collect();
         if rest.is_empty() {
@@ -565,7 +539,7 @@ rule_in_group!(application_expression<RcExpr>; expression; children!(
     }
 ));
 
-rule_in_group!(selector_expression_raw<RcExpr>; expression; children!(
+rule!(selector_expression_raw<RcExpr> as expression; children!(
     [expression(first), selector_raw(rest..)] => {
         rest.fold(first, |acc, e| bx(Expr::Field(acc, e)))
     }
@@ -576,7 +550,7 @@ rule!(selector_raw<Label>; children!(
     [label_raw(l)] => l
 ));
 
-rule_in_group!(literal_expression_raw<RcExpr>; expression; children!(
+rule!(literal_expression_raw<RcExpr> as 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)),
@@ -588,7 +562,7 @@ rule_in_group!(literal_expression_raw<RcExpr>; expression; children!(
     [expression(e)] => e,
 ));
 
-rule_in_group!(identifier_raw<RcExpr>; expression; children!(
+rule!(identifier_raw<RcExpr> as expression; children!(
     [label_raw(l), natural_literal_raw(idx)] => {
         let name = String::from(l.clone());
         match Builtin::parse(name.as_str()) {
@@ -617,15 +591,15 @@ rule_in_group!(identifier_raw<RcExpr>; expression; children!(
     },
 ));
 
-rule_in_group!(empty_record_literal<RcExpr>; expression;
+rule!(empty_record_literal<RcExpr> as expression;
     raw_pair!(_) => bx(Expr::RecordLit(BTreeMap::new()))
 );
 
-rule_in_group!(empty_record_type<RcExpr>; expression;
+rule!(empty_record_type<RcExpr> as expression;
     raw_pair!(_) => bx(Expr::Record(BTreeMap::new()))
 );
 
-rule_in_group!(non_empty_record_type_or_literal<RcExpr>; expression; children!(
+rule!(non_empty_record_type_or_literal<RcExpr> as expression; children!(
     [label_raw(first_label), non_empty_record_type(rest)] => {
         let (first_expr, mut map) = rest;
         map.insert(first_label, first_expr);
@@ -658,7 +632,7 @@ rule!(record_literal_entry<(Label, RcExpr)>; children!(
     [label_raw(name), expression(expr)] => (name, expr)
 ));
 
-rule_in_group!(union_type_or_literal<RcExpr>; expression; children!(
+rule!(union_type_or_literal<RcExpr> as expression; children!(
     [empty_union_type(_)] => {
         bx(Expr::Union(BTreeMap::new()))
     },
@@ -697,24 +671,23 @@ 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!(
+rule!(non_empty_list_literal_raw<RcExpr> as expression; children!(
     [expression(items..)] => bx(Expr::NEListLit(items.collect()))
 ));
 
-rule_in_group!(final_expression<RcExpr>; expression; children!(
+rule!(final_expression<RcExpr> as expression; children!(
     [expression(e), EOI(_eoi)] => e
 ));
 }
 
 pub fn parse_expr(s: &str) -> ParseResult<RcExpr> {
-    let pairs = DhallParser::parse(Rule::final_expression, s)?;
-    // Match the only item in the pairs iterator
-    // println!("{}", debug_pair(pairs.clone().next().unwrap()));
-    let expr = iter_patterns::destructure_iter!(pairs; [p] => parse_any(p))
-        .unwrap()?;
-    // expr.expression()
-    Ok(expr.expression())
-    // Ok(expr)
+    let mut pairs = DhallParser::parse(Rule::final_expression, s)?;
+    let expr = parse_any(pairs.next().unwrap())?;
+    assert_eq!(pairs.next(), None);
+    match expr {
+        ParsedValue::expression(e) => Ok(e),
+        _ => unreachable!(),
+    }
     // Ok(bx(Expr::BoolLit(false)))
 }