From 3ce64f46a79855913a7cc8626c45781cb6b16300 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 19 Mar 2019 21:59:41 +0100
Subject: Extract the core of parser macros into a separate crate

---
 dhall_core/src/parser.rs | 176 ++++++++++++-----------------------------------
 1 file changed, 45 insertions(+), 131 deletions(-)

(limited to 'dhall_core/src')

diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs
index 6f84abe..45930d4 100644
--- a/dhall_core/src/parser.rs
+++ b/dhall_core/src/parser.rs
@@ -71,102 +71,11 @@ fn debug_pair(pair: Pair<Rule>) -> String {
     s
 }
 
-/* Macro to pattern-match iterators.
- * Returns `Result<_, IterMatchError<_>>`.
- *
- * Example:
- * ```
- * let vec = vec![1, 2, 3];
- *
- * match_iter!(vec.into_iter(); (x, y?, z) => {
- *  // x: T
- *  // y: Option<T>
- *  // z: T
- * })
- *
- * // or
- * match_iter!(vec.into_iter(); (x, y, z*) => {
- *  // x, y: T
- *  // z: impl Iterator<T>
- * })
- * ```
- *
-*/
 #[derive(Debug)]
 enum IterMatchError<T> {
-    NotEnoughItems,
-    TooManyItems,
     NoMatchFound,
     Other(T), // Allow other macros to inject their own errors
 }
-macro_rules! match_iter {
-    // Everything else pattern
-    (@match 0, $iter:expr, $x:ident* $($rest:tt)*) => {
-        match_iter!(@match 2, $iter $($rest)*);
-        #[allow(unused_mut)]
-        let mut $x = $iter;
-    };
-    // Alias to use in macros
-    (@match 0, $iter:expr, $x:ident?? $($rest:tt)*) => {
-        match_iter!(@match 2, $iter $($rest)*);
-        #[allow(unused_mut)]
-        let mut $x = $iter;
-    };
-    // Optional pattern
-    (@match 0, $iter:expr, $x:ident? $($rest:tt)*) => {
-        match_iter!(@match 1, $iter $($rest)*);
-        #[allow(unused_mut)]
-        let mut $x = $iter.next();
-        if $iter.next().is_some() {
-            break Err(IterMatchError::TooManyItems);
-        }
-    };
-    // Normal pattern
-    (@match 0, $iter:expr, $x:ident $($rest:tt)*) => {
-        #[allow(unused_mut)]
-        let mut $x = match $iter.next() {
-            Some(x) => x,
-            None => break Err(IterMatchError::NotEnoughItems),
-        };
-        match_iter!(@match 0, $iter $($rest)*);
-    };
-    // Normal pattern after a variable length one: declare reversed and take from the end
-    (@match $w:expr, $iter:expr, $x:ident $($rest:tt)*) => {
-        match_iter!(@match $w, $iter $($rest)*);
-        #[allow(unused_mut)]
-        let mut $x = match $iter.next_back() {
-            Some(x) => x,
-            None => break Err(IterMatchError::NotEnoughItems),
-        };
-    };
-
-    // Check no elements remain
-    (@match 0, $iter:expr $(,)*) => {
-        if $iter.next().is_some() {
-            break Err(IterMatchError::TooManyItems);
-        }
-    };
-    (@match $_:expr, $iter:expr) => {};
-
-    (@panic; $($args:tt)*) => {
-        {
-            let ret: Result<_, IterMatchError<()>> = match_iter!($($args)*);
-            ret.unwrap()
-        }
-    };
-    ($iter:expr; ($($args:tt)*) => $body:expr) => {
-        {
-            #[allow(unused_mut)]
-            let mut iter = $iter;
-            // Not a real loop; used for error handling
-            let ret: Result<_, IterMatchError<_>> = loop {
-                match_iter!(@match 0, iter, $($args)*);
-                break Ok($body);
-            };
-            ret
-        }
-    };
-}
 
 /* Extends match_iter with typed matches. Takes a callback that determines
  * when a capture matches.
@@ -200,21 +109,21 @@ macro_rules! match_iter_typed {
     (@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)*))
-    };
-    (@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)*), ($(,)*)) => {
-        match_iter!($iter; ($($acc)*) => {
-            match_iter_typed!(@callback, $callback, $iter, $($args)*);
-            $body
-        })
+        {
+            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
@@ -227,17 +136,7 @@ macro_rules! match_iter_typed {
         };
         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));
-        #[allow(unused_mut)]
-        let mut $x = match $x {
-            Some(Ok(x)) => Some(x),
-            Some(Err(e)) => break Err(IterMatchError::Other(e)),
-            None => None,
-        };
-        match_iter_typed!(@callback, $callback, $iter $($rest)*);
-    };
-    (@callback, $callback: ident, $iter:expr, $x:ident* : $ty:ident $($rest:tt)*) => {
+    (@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,
@@ -253,10 +152,13 @@ macro_rules! match_iter_typed {
         {
             #[allow(unused_mut)]
             let mut iter = $iter;
-            match_iter_typed!(@collect,
-                (iter, $body, $callback, last_error),
-                ($($args)*), (), ($($args)*,)
-            )
+            let res: Result<_, IterMatchError<_>> = loop {
+                break match_iter_typed!(@collect,
+                    (iter, $body, $callback, last_error),
+                    ($($args)*), (), ($($args)*,)
+                )
+            };
+            res
         }
     };
 }
@@ -430,7 +332,7 @@ named!(raw_str<&'a str>; captured_str!(s) => s);
 named!(label<Label>; captured_str!(s) => Label::from(s.trim().to_owned()));
 
 rule!(double_quote_literal<ParsedText>;
-    children!(chunks*: double_quote_chunk) => {
+    children!(chunks..: double_quote_chunk) => {
         chunks.collect()
     }
 );
@@ -639,13 +541,14 @@ rule!(ifthenelse_expression<RcExpr>;
 );
 
 rule!(let_expression<RcExpr>;
-    children!(bindings*: let_binding, final_expr: expression) => {
+    children!(bindings..: let_binding, final_expr: expression) => {
         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, annot?: expression, expr: expression) => (name, annot, expr)
+    children!(name: label, annot: expression, expr: expression) => (name, Some(annot), expr),
+    children!(name: label, expr: expression) => (name, None, expr),
 );
 
 rule!(forall_expression<RcExpr>;
@@ -661,9 +564,8 @@ rule!(arrow_expression<RcExpr>;
 );
 
 rule!(merge_expression<RcExpr>;
-    children!(x: expression, y: expression, z?: expression) => {
-        bx(Expr::Merge(x, y, z))
-    }
+    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!(empty_collection<RcExpr>;
@@ -738,7 +640,7 @@ macro_rules! binop {
                     expression(pair)?
                 }
             }
-            // children!(first: expression, rest*: expression) => {
+            // children!(first: expression, rest..: expression) => {
             //     rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::$op, acc, e)))
             // }
         );
@@ -766,7 +668,7 @@ rule!(annotated_expression<RcExpr>;
 );
 
 rule!(application_expression<RcExpr>;
-    children!(first: expression, rest*: expression) => {
+    children!(first: expression, rest..: expression) => {
         let rest: Vec<_> = rest.collect();
         if rest.is_empty() {
             first
@@ -777,7 +679,7 @@ rule!(application_expression<RcExpr>;
 );
 
 rule!(selector_expression_raw<RcExpr>;
-    children!(first: expression, rest*: label) => {
+    children!(first: expression, rest..: label) => {
         rest.fold(first, |acc, e| bx(Expr::Field(acc, e)))
     }
 );
@@ -795,7 +697,7 @@ rule!(literal_expression_raw<RcExpr>;
 );
 
 rule!(identifier_raw<RcExpr>;
-    children!(name: str, idx?: natural_literal_raw) => {
+    children!(name: str, idx: natural_literal_raw) => {
         match Builtin::parse(name) {
             Some(b) => bx(Expr::Builtin(b)),
             None => match name {
@@ -803,10 +705,22 @@ rule!(identifier_raw<RcExpr>;
                 "False" => bx(Expr::BoolLit(false)),
                 "Type" => bx(Expr::Const(Const::Type)),
                 "Kind" => bx(Expr::Const(Const::Kind)),
-                name => bx(Expr::Var(V(Label::from(name.to_owned()), idx.unwrap_or(0)))),
+                name => bx(Expr::Var(V(Label::from(name.to_owned()), idx))),
             }
         }
-    }
+    },
+    children!(name: str) => {
+        match Builtin::parse(name) {
+            Some(b) => bx(Expr::Builtin(b)),
+            None => match name {
+                "True" => bx(Expr::BoolLit(true)),
+                "False" => bx(Expr::BoolLit(false)),
+                "Type" => bx(Expr::Const(Const::Type)),
+                "Kind" => bx(Expr::Const(Const::Kind)),
+                name => bx(Expr::Var(V(Label::from(name.to_owned()), 0))),
+            }
+        }
+    },
 );
 
 rule!(empty_record_literal<RcExpr>;
@@ -835,7 +749,7 @@ rule!(non_empty_record_type<(RcExpr, BTreeMap<Label, RcExpr>)>;
 );
 
 named!(partial_record_entries<(RcExpr, BTreeMap<Label, RcExpr>)>;
-    children!(expr: expression, entries*: record_entry) => {
+    children!(expr: expression, entries..: record_entry) => {
         (expr, entries.collect())
     }
 );
@@ -880,7 +794,7 @@ rule!(non_empty_union_type_or_literal
 );
 
 rule!(union_type_entries<BTreeMap<Label, RcExpr>>;
-    children!(entries*: union_type_entry) => {
+    children!(entries..: union_type_entry) => {
         entries.collect()
     }
 );
@@ -890,7 +804,7 @@ rule!(union_type_entry<(Label, RcExpr)>;
 );
 
 rule!(non_empty_list_literal_raw<RcExpr>;
-    children!(items*: expression) => {
+    children!(items..: expression) => {
         bx(Expr::NEListLit(items.collect()))
     }
 );
@@ -903,7 +817,7 @@ 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()));
-    match_iter!(@panic; pairs; (p) => expression(p))
+    iter_patterns::destructure_iter!(pairs; [p] => expression(p)).unwrap()
     // Ok(bx(Expr::BoolLit(false)))
 }
 
-- 
cgit v1.2.3


From 3a967a0eef8b69f7fc8bbc7655945edbbe2b579e Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 19 Mar 2019 22:53:48 +0100
Subject: Wrap all parsing rules into a common variant

---
 dhall_core/src/parser.rs | 236 ++++++++++++++++++++++++++++++-----------------
 1 file changed, 153 insertions(+), 83 deletions(-)

(limited to 'dhall_core/src')

diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs
index 45930d4..9a9560f 100644
--- a/dhall_core/src/parser.rs
+++ b/dhall_core/src/parser.rs
@@ -231,7 +231,8 @@ macro_rules! match_iter_branching {
 
 macro_rules! match_pair {
     (@type_callback, $ty:ident, $x:expr) => {
-        $ty($x)
+        ParseUnwrapped::$ty($x)
+        // ParseWrapped::$ty($x).map(|x| x.$ty())
     };
     (@branch_callback, children, $pair:expr; $($args:tt)*) => {
         {
@@ -274,13 +275,75 @@ macro_rules! match_pair {
     };
 }
 
+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), )*
+        //     //     }
+        //     // }
+        // }
+        struct ParseWrapped;
+        struct ParseUnwrapped;
+
+        #[allow(non_camel_case_types, dead_code)]
+        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!(),
+                    }
+                }
+            )*
+        }
+
+        // fn do_the_parse(s: &str, r: Rule, ty: ParsedType) -> ParseResult<ParsedValue>  {
+        //     let pairs = DhallParser::parse(r, s)?;
+        //     match_iter!(pairs; (e) => ty.parse(e))
+        // }
+
+        $(
+            $submac!($name<$o>; $($args)*);
+        )*
+    );
+}
+
+
 macro_rules! make_pest_parse_function {
     ($name:ident<$o:ty>; $submac:ident!( $($args:tt)* )) => (
-        #[allow(unused_variables)]
-        #[allow(non_snake_case)]
-        #[allow(clippy::all)]
-        fn $name<'a>(pair: Pair<'a, Rule>) -> ParseResult<$o> {
-            $submac!(pair; $($args)*)
+        impl ParseUnwrapped {
+            #[allow(unused_variables, non_snake_case, dead_code, clippy::all)]
+            fn $name<'a>(pair: Pair<'a, Rule>) -> ParseResult<$o> {
+                ParseWrapped::$name(pair).map(|x| x.$name())
+            }
+        }
+        impl ParseWrapped {
+            #[allow(unused_variables, non_snake_case, dead_code, clippy::all)]
+            fn $name<'a>(pair: Pair<'a, Rule>) -> ParseResult<ParsedValue<'a>> {
+                let res: ParseResult<$o> = $submac!(pair; $($args)*);
+                Ok(ParsedValue::$name(res?))
+            }
         }
     );
 }
@@ -303,7 +366,7 @@ 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) => $ty(p)?),
+                Rule::$ty => match_pair!(raw_pair!(p) => ParseUnwrapped::$ty(p)?),
             )*
         ));
     );
@@ -323,6 +386,71 @@ macro_rules! match_rule {
     };
 }
 
+// List of rules that can be shortcutted as implemented in binop!()
+fn can_be_shortcutted(rule: Rule) -> bool {
+    use Rule::*;
+    match rule {
+        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
+        | selector_expression_raw
+        | annotated_expression => true,
+        _ => false,
+    }
+}
+
+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)?
+                }
+            }
+            // children!(first: expression, rest..: expression) => {
+            //     rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::$op, acc, e)))
+            // }
+        );
+    };
+}
+
+
+make_parser!{
 rule!(EOI<()>; children!() => ());
 
 named!(str<&'a str>; captured_str!(s) => s.trim());
@@ -584,81 +712,18 @@ rule!(non_empty_optional<RcExpr>;
     }
 );
 
-// List of rules that can be shortcutted as implemented in binop!()
-fn can_be_shortcutted(rule: Rule) -> bool {
-    use Rule::*;
-    match rule {
-        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
-        | selector_expression_raw
-        | annotated_expression => true,
-        _ => false,
-    }
-}
-
-macro_rules! binop {
-    ($rule:ident, $op:ident) => {
-        rule!($rule<RcExpr>;
-            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(expression).collect::<Result<_, _>>()?;
-                if !rest.is_empty() {
-                    // If there is more than one subexpression, handle it normally
-                    let first = 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!();
-                    expression(pair)?
-                }
-            }
-            // children!(first: expression, rest..: expression) => {
-            //     rest.fold(first, |acc, e| bx(Expr::BinOp(BinOp::$op, acc, e)))
-            // }
-        );
-    };
-}
-
-binop!(import_alt_expression, ImportAlt);
-binop!(or_expression, BoolOr);
-binop!(plus_expression, NaturalPlus);
-binop!(text_append_expression, TextAppend);
-binop!(list_append_expression, ListAppend);
-binop!(and_expression, BoolAnd);
-binop!(combine_expression, Combine);
-binop!(prefer_expression, Prefer);
-binop!(combine_types_expression, CombineTypes);
-binop!(times_expression, NaturalTimes);
-binop!(equal_expression, BoolEQ);
-binop!(not_equal_expression, BoolNE);
+binop!(import_alt_expression<RcExpr>; ImportAlt);
+binop!(or_expression<RcExpr>; BoolOr);
+binop!(plus_expression<RcExpr>; NaturalPlus);
+binop!(text_append_expression<RcExpr>; TextAppend);
+binop!(list_append_expression<RcExpr>; ListAppend);
+binop!(and_expression<RcExpr>; BoolAnd);
+binop!(combine_expression<RcExpr>; Combine);
+binop!(prefer_expression<RcExpr>; Prefer);
+binop!(combine_types_expression<RcExpr>; CombineTypes);
+binop!(times_expression<RcExpr>; NaturalTimes);
+binop!(equal_expression<RcExpr>; BoolEQ);
+binop!(not_equal_expression<RcExpr>; BoolNE);
 
 rule!(annotated_expression<RcExpr>;
     children!(e: expression, annot: expression) => {
@@ -812,12 +877,17 @@ rule!(non_empty_list_literal_raw<RcExpr>;
 rule!(final_expression<RcExpr>;
     children!(e: expression, _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()));
-    iter_patterns::destructure_iter!(pairs; [p] => expression(p)).unwrap()
+    let expr = iter_patterns::destructure_iter!(pairs; [p] => ParseUnwrapped::expression(p))
+        .unwrap()?;
+    // expr.expression()
+    // Ok(expr.expression())
+    Ok(expr)
     // Ok(bx(Expr::BoolLit(false)))
 }
 
-- 
cgit v1.2.3


From 640a36906361ef5ef98fb66fd37246f084739d25 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 20 Mar 2019 00:44:27 +0100
Subject: Handle simple parsing cases with new macros

---
 dhall_core/src/core.rs   |   1 +
 dhall_core/src/lib.rs    |   2 +
 dhall_core/src/parser.rs | 234 +++++++++++++++++++++++++----------------------
 3 files changed, 127 insertions(+), 110 deletions(-)

(limited to 'dhall_core/src')

diff --git a/dhall_core/src/core.rs b/dhall_core/src/core.rs
index 32f9c85..e7c9f2a 100644
--- a/dhall_core/src/core.rs
+++ b/dhall_core/src/core.rs
@@ -199,6 +199,7 @@ impl<N, E> From<String> for InterpolatedText<N, E> {
     }
 }
 
+#[derive(Debug, Clone)]
 pub enum InterpolatedTextContents<'a, Note, Embed> {
     Text(&'a str),
     Expr(SubExpr<Note, Embed>),
diff --git a/dhall_core/src/lib.rs b/dhall_core/src/lib.rs
index c728a75..43c8d9a 100644
--- a/dhall_core/src/lib.rs
+++ b/dhall_core/src/lib.rs
@@ -1,4 +1,6 @@
 #![feature(trace_macros)]
+#![feature(slice_patterns)]
+#![recursion_limit="128"]
 #![allow(
     clippy::many_single_char_names,
     clippy::should_implement_trait,
diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs
index 9a9560f..4bbb08a 100644
--- a/dhall_core/src/parser.rs
+++ b/dhall_core/src/parser.rs
@@ -77,33 +77,6 @@ enum IterMatchError<T> {
     Other(T), // Allow other macros to inject their own errors
 }
 
-/* Extends match_iter with typed matches. Takes a callback that determines
- * when a capture matches.
- * Returns `Result<_, IterMatchError<_>>`; errors returned by the callback will
- * get propagated using IterMatchError::Other.
- *
- * Example:
- * ```
- * macro_rules! callback {
- *     (@type_callback, positive, $x:expr) => {
- *         if $x >= 0 { Ok($x) } else { Err(()) }
- *     };
- *     (@type_callback, negative, $x:expr) => {
- *         if $x <= 0 { Ok($x) } else { Err(()) }
- *     };
- *     (@type_callback, any, $x:expr) => {
- *         Ok($x)
- *     };
- * }
- *
- * let vec = vec![-1, 2, 3];
- *
- * match_iter_typed!(callback; vec.into_iter();
- *     (x: positive, y?: negative, z: any) => { ... },
- * )
- * ```
- *
-*/
 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)*)) => {
@@ -163,41 +136,6 @@ macro_rules! match_iter_typed {
     };
 }
 
-/* Extends match_iter and match_iter_typed with branching.
- * Returns `Result<_, IterMatchError<_>>`; errors returned by the callback will
- * get propagated using IterMatchError::Other.
- * Allows multiple branches. The passed iterator must be Clone.
- * Will check the branches in order, testing each branch using the callback macro provided.
- *
- * Example:
- * ```
- * macro_rules! callback {
- *     (@type_callback, positive, $x:expr) => {
- *         if $x >= 0 { Ok($x) } else { Err(()) }
- *     };
- *     (@type_callback, negative, $x:expr) => {
- *         if $x <= 0 { Ok($x) } else { Err(()) }
- *     };
- *     (@type_callback, any, $x:expr) => {
- *         Ok($x)
- *     };
- *     (@branch_callback, typed, $($args:tt)*) => {
- *         match_iter_typed!(callback; $($args)*)
- *     };
- *     (@branch_callback, untyped, $($args:tt)*) => {
- *         match_iter!($($args)*)
- *     };
- * }
- *
- * let vec = vec![-1, 2, 3];
- *
- * match_iter_branching!(branch_callback; vec.into_iter();
- *     typed!(x: positive, y?: negative, z: any) => { ... },
- *     untyped!(x, y, z) => { ... },
- * )
- * ```
- *
-*/
 macro_rules! match_iter_branching {
     (@noclone, $callback:ident; $arg:expr; $( $submac:ident!($($args:tt)*) => $body:expr ),* $(,)*) => {
         {
@@ -263,6 +201,23 @@ macro_rules! match_pair {
         }
     };
 
+    ($pair:expr; $( children!($($x:ident : $ty:ident),*) => $body:expr ),* $(,)*) => {
+        {
+            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)*) => {
         {
             let pair = $pair;
@@ -276,6 +231,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)*)
+    );
+    (@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)*)
+    );
+    (@branch_rules, $pair:expr, ($($acc:tt)*),) => (
+        #[allow(unreachable_patterns)]
+        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)* ); )*) => (
         // #[allow(non_camel_case_types, dead_code)]
         // enum ParsedType {
@@ -302,8 +274,10 @@ macro_rules! make_parser {
         struct ParseUnwrapped;
 
         #[allow(non_camel_case_types, dead_code)]
+        #[derive(Debug)]
         enum ParsedValue<'a> {
             $( $name($o), )*
+            parse_any(Box<ParsedValue<'a>>),
         }
 
         impl<'a> ParsedValue<'a> {
@@ -316,6 +290,31 @@ 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> {
+                make_parser!(@branch_rules, pair, (), $( $submac!( $name<$o>; $($args)* ); )*)
+            }
         }
 
         // fn do_the_parse(s: &str, r: Rule, ty: ParsedType) -> ParseResult<ParsedValue>  {
@@ -459,6 +458,8 @@ 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>;
     children!(chunks..: double_quote_chunk) => {
         chunks.collect()
@@ -495,11 +496,16 @@ rule!(double_quote_escaped<&'a str>;
     }
 );
 
+rule!(end_of_line<()>; children!() => ());
+
 rule!(single_quote_literal<ParsedText>;
-    children!(eol: raw_str, contents: single_quote_continue) => {
+    children!(eol: end_of_line, contents: single_quote_continue) => {
         contents.into_iter().rev().collect::<ParsedText>()
     }
 );
+rule!(single_quote_char<&'a str>;
+    captured_str!(s) => s
+);
 rule!(escaped_quote_pair<&'a str>;
     children!() => "''"
 );
@@ -512,15 +518,19 @@ rule!(interpolation<RcExpr>;
 
 rule!(single_quote_continue<Vec<ParsedTextContents<'a>>>;
     children!(c: interpolation, rest: single_quote_continue) => {
+        let mut rest = rest;
         rest.push(InterpolatedTextContents::Expr(c)); rest
     },
     children!(c: escaped_quote_pair, rest: single_quote_continue) => {
+        let mut rest = rest;
         rest.push(InterpolatedTextContents::Text(c)); rest
     },
     children!(c: escaped_interpolation, rest: single_quote_continue) => {
+        let mut rest = rest;
         rest.push(InterpolatedTextContents::Text(c)); rest
     },
-    children!(c: raw_str, rest: single_quote_continue) => {
+    children!(c: single_quote_char, rest: single_quote_continue) => {
+        let mut rest = rest;
         rest.push(InterpolatedTextContents::Text(c)); rest
     },
     children!() => {
@@ -560,6 +570,13 @@ 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!(parent_path<(FilePrefix, PathBuf)>;
     children!(p: path) => (FilePrefix::Parent, p)
 );
@@ -576,13 +593,6 @@ rule!(absolute_path<(FilePrefix, PathBuf)>;
     children!(p: path) => (FilePrefix::Absolute, p)
 );
 
-rule_group!(local_raw<(FilePrefix, PathBuf)>;
-    parent_path,
-    here_path,
-    home_path,
-    absolute_path
-);
-
 // TODO: other import types
 rule!(import_type_raw<ImportLocation>;
     // children!(_e: missing_raw) => {
@@ -607,18 +617,6 @@ rule!(import_hashed_raw<(ImportLocation, Option<()>)>;
     }
 );
 
-rule!(import_raw<RcExpr>;
-    // TODO: handle "as Text"
-    children!(import: import_hashed_raw) => {
-        let (location, hash) = import;
-        bx(Expr::Embed(Import {
-            mode: ImportMode::Code,
-            hash,
-            location,
-        }))
-    }
-);
-
 rule_group!(expression<RcExpr>;
     identifier_raw,
     lambda_expression,
@@ -656,8 +654,20 @@ rule_group!(expression<RcExpr>;
     final_expression
 );
 
+rule!(import_raw<RcExpr>;
+    // TODO: handle "as Text"
+    children!(import: import_hashed_raw) => {
+        let (location, hash) = import;
+        bx(Expr::Embed(Import {
+            mode: ImportMode::Code,
+            hash,
+            location,
+        }))
+    }
+);
+
 rule!(lambda_expression<RcExpr>;
-    children!(l: label, typ: expression, body: expression) => {
+    children!(l: label_raw, typ: expression, body: expression) => {
         bx(Expr::Lam(l, typ, body))
     }
 );
@@ -675,12 +685,12 @@ rule!(let_expression<RcExpr>;
 );
 
 rule!(let_binding<(Label, Option<RcExpr>, RcExpr)>;
-    children!(name: label, annot: expression, expr: expression) => (name, Some(annot), expr),
-    children!(name: label, expr: expression) => (name, None, expr),
+    children!(name: label_raw, annot: expression, expr: expression) => (name, Some(annot), expr),
+    children!(name: label_raw, expr: expression) => (name, None, expr),
 );
 
 rule!(forall_expression<RcExpr>;
-    children!(l: label, typ: expression, body: expression) => {
+    children!(l: label_raw, typ: expression, body: expression) => {
         bx(Expr::Pi(l, typ, body))
     }
 );
@@ -696,18 +706,20 @@ rule!(merge_expression<RcExpr>;
     children!(x: expression, y: expression) => bx(Expr::Merge(x, y, None)),
 );
 
+rule!(List<()>; children!() => ());
+rule!(Optional<()>; children!() => ());
+
 rule!(empty_collection<RcExpr>;
-    children!(x: str, y: expression) => {
-       match x {
-          "Optional" => bx(Expr::OptionalLit(Some(y), None)),
-          "List" => bx(Expr::EmptyListLit(y)),
-          _ => unreachable!(),
-       }
-    }
+    children!(_x: List, y: expression) => {
+        bx(Expr::EmptyListLit(y))
+    },
+    children!(_x: Optional, y: expression) => {
+        bx(Expr::OptionalLit(Some(y), None))
+    },
 );
 
 rule!(non_empty_optional<RcExpr>;
-    children!(x: expression, _y: str, z: expression) => {
+    children!(x: expression, _y: Optional, z: expression) => {
         bx(Expr::OptionalLit(Some(z), Some(x)))
     }
 );
@@ -762,27 +774,29 @@ rule!(literal_expression_raw<RcExpr>;
 );
 
 rule!(identifier_raw<RcExpr>;
-    children!(name: str, idx: natural_literal_raw) => {
-        match Builtin::parse(name) {
+    children!(l: label_raw, idx: natural_literal_raw) => {
+        let name = String::from(l.clone());
+        match Builtin::parse(name.as_str()) {
             Some(b) => bx(Expr::Builtin(b)),
-            None => match name {
+            None => match name.as_str() {
                 "True" => bx(Expr::BoolLit(true)),
                 "False" => bx(Expr::BoolLit(false)),
                 "Type" => bx(Expr::Const(Const::Type)),
                 "Kind" => bx(Expr::Const(Const::Kind)),
-                name => bx(Expr::Var(V(Label::from(name.to_owned()), idx))),
+                _ => bx(Expr::Var(V(l, idx))),
             }
         }
     },
-    children!(name: str) => {
-        match Builtin::parse(name) {
+    children!(l: label_raw) => {
+        let name = String::from(l.clone());
+        match Builtin::parse(name.as_str()) {
             Some(b) => bx(Expr::Builtin(b)),
-            None => match name {
+            None => match name.as_str() {
                 "True" => bx(Expr::BoolLit(true)),
                 "False" => bx(Expr::BoolLit(false)),
                 "Type" => bx(Expr::Const(Const::Type)),
                 "Kind" => bx(Expr::Const(Const::Kind)),
-                name => bx(Expr::Var(V(Label::from(name.to_owned()), 0))),
+                _ => bx(Expr::Var(V(l, 0))),
             }
         }
     },
@@ -797,12 +811,12 @@ rule!(empty_record_type<RcExpr>;
 );
 
 rule!(non_empty_record_type_or_literal<RcExpr>;
-    children!(first_label: label, rest: non_empty_record_type) => {
+    children!(first_label: label_raw, rest: non_empty_record_type) => {
         let (first_expr, mut map) = rest;
         map.insert(first_label, first_expr);
         bx(Expr::Record(map))
     },
-    children!(first_label: label, rest: non_empty_record_literal) => {
+    children!(first_label: label_raw, rest: non_empty_record_literal) => {
         let (first_expr, mut map) = rest;
         map.insert(first_label, first_expr);
         bx(Expr::RecordLit(map))
@@ -820,7 +834,7 @@ named!(partial_record_entries<(RcExpr, BTreeMap<Label, RcExpr>)>;
 );
 
 named!(record_entry<(Label, RcExpr)>;
-    children!(name: label, expr: expression) => (name, expr)
+    children!(name: label_raw, expr: expression) => (name, expr)
 );
 
 rule!(non_empty_record_literal<(RcExpr, BTreeMap<Label, RcExpr>)>;
@@ -843,15 +857,15 @@ rule!(empty_union_type<()>; children!() => ());
 
 rule!(non_empty_union_type_or_literal
       <(Option<(Label, RcExpr)>, BTreeMap<Label, RcExpr>)>;
-    children!(l: label, e: expression, entries: union_type_entries) => {
+    children!(l: label_raw, e: expression, entries: union_type_entries) => {
         (Some((l, e)), entries)
     },
-    children!(l: label, e: expression, rest: non_empty_union_type_or_literal) => {
+    children!(l: label_raw, e: expression, rest: non_empty_union_type_or_literal) => {
         let (x, mut entries) = rest;
         entries.insert(l, e);
         (x, entries)
     },
-    children!(l: label, e: expression) => {
+    children!(l: label_raw, e: expression) => {
         let mut entries = BTreeMap::new();
         entries.insert(l, e);
         (None, entries)
@@ -865,7 +879,7 @@ rule!(union_type_entries<BTreeMap<Label, RcExpr>>;
 );
 
 rule!(union_type_entry<(Label, RcExpr)>;
-    children!(name: label, expr: expression) => (name, expr)
+    children!(name: label_raw, expr: expression) => (name, expr)
 );
 
 rule!(non_empty_list_literal_raw<RcExpr>;
-- 
cgit v1.2.3


From 4cf23db82c37f4d24ea093e268bb96a1ae1afe3d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 20 Mar 2019 18:59:25 +0100
Subject: Obsolete old parser macros; performance is now dead

---
 dhall_core/src/lib.rs    |   2 +-
 dhall_core/src/parser.rs | 453 +++++++++++++++++++++++++++--------------------
 2 files changed, 266 insertions(+), 189 deletions(-)

(limited to 'dhall_core/src')

diff --git a/dhall_core/src/lib.rs b/dhall_core/src/lib.rs
index 43c8d9a..508ad3a 100644
--- a/dhall_core/src/lib.rs
+++ b/dhall_core/src/lib.rs
@@ -1,6 +1,6 @@
 #![feature(trace_macros)]
 #![feature(slice_patterns)]
-#![recursion_limit="128"]
+#![recursion_limit = "128"]
 #![allow(
     clippy::many_single_char_names,
     clippy::should_implement_trait,
diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs
index 4bbb08a..6718c00 100644
--- a/dhall_core/src/parser.rs
+++ b/dhall_core/src/parser.rs
@@ -71,153 +71,206 @@ fn debug_pair(pair: Pair<Rule>) -> String {
     s
 }
 
-#[derive(Debug)]
-enum IterMatchError<T> {
-    NoMatchFound,
-    Other(T), // Allow other macros to inject their own errors
-}
+// #[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_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)
-        }
+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)*)
     };
-
-    // 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)*);
+    (@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)*, x..), ($($rest_of_match)*) => {
+            let $x = x.map(|x| x.$ty());
+            $body
+        }, $($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)*);
+    (@make_child_match, $pair:expr, ($($outer_acc:tt)*), (, $($acc:tt)*), ($(,)*) => $body:expr, $($rest:tt)*) => {
+        match_pair!(@make_matches, $pair, ([$($acc)*] => { $body }, $($outer_acc)*), $($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
-        }
+    (@make_child_match, $pair:expr, ($($outer_acc:tt)*), (), ($(,)*) => $body:expr, $($rest:tt)*) => {
+        match_pair!(@make_matches, $pair, ([] => { $body }, $($outer_acc)*), $($rest)*)
     };
-}
 
-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);
-            }
-        }
+    (@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)*)
     };
-    ($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, $ty:ident, $x:expr) => {
-        ParseUnwrapped::$ty($x)
-        // ParseWrapped::$ty($x).map(|x| x.$ty())
-    };
-    (@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, self, $pair:expr; ($x:ident : $ty:ident) => $body:expr) => {
-        {
-            let $x = match_pair!(@type_callback, $ty, $pair.clone());
-            match $x {
-                Ok($x) => Ok($body),
-                Err(e) => Err(IterMatchError::Other(e)),
-            }
-        }
-    };
-    (@branch_callback, raw_pair, $pair:expr; ($x:ident) => $body:expr) => {
-        {
+    (@make_matches, $pair:expr, ($($acc:tt)*), raw_pair!($x:ident) => $body:expr, $($rest:tt)*) => {
+        match_pair!(@make_matches, $pair, ([..] => {
             let $x = $pair.clone();
-            Ok($body)
-        }
+            $body
+        }, $($acc)*), $($rest)*)
     };
-    (@branch_callback, captured_str, $pair:expr; ($x:ident) => $body:expr) => {
-        {
+    (@make_matches, $pair:expr, ($($acc:tt)*), captured_str!($x:ident) => $body:expr, $($rest:tt)*) => {
+        match_pair!(@make_matches, $pair, ([..] => {
             let $x = $pair.as_str();
-            Ok($body)
-        }
+            $body
+        }, $($acc)*), $($rest)*)
     };
-
-    ($pair:expr; $( children!($($x:ident : $ty:ident),*) => $body:expr ),* $(,)*) => {
+    (@make_matches, $pair:expr, ($($acc:tt)*) $(,)*) => {
         {
-            let pair = $pair;
+            let pair = $pair.clone();
             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<_, _>>()?;
+            let parsed: Vec<_> = pair.clone().into_inner().map(ParseWrapped::parse_any_fast).collect::<Result<_, _>>()?;
             #[allow(unreachable_code)]
             iter_patterns::match_vec!(parsed;
-                $(
-                    [$(ParsedValue::$ty($x)),*] => {
-                        $body
-                    },
-                )*
+                $($acc)*
                 [x..] => panic!("Unexpected children while parsing rule '{:?}': {:?}", rule, x.collect::<Vec<_>>()),
-            ).ok_or(err)
+            ).ok_or_else(|| custom_parse_error(&pair, "No match found".to_owned()))
         }
     };
+
+    // ($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)*) => {
         {
             let pair = $pair;
@@ -277,7 +330,7 @@ macro_rules! make_parser {
         #[derive(Debug)]
         enum ParsedValue<'a> {
             $( $name($o), )*
-            parse_any(Box<ParsedValue<'a>>),
+            // parse_any(Box<ParsedValue<'a>>),
         }
 
         impl<'a> ParsedValue<'a> {
@@ -290,25 +343,25 @@ 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()
-            }
+            // #[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)),
-            )*
-        );
+        // 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)]
@@ -317,6 +370,19 @@ macro_rules! make_parser {
             }
         }
 
+        impl ParseUnwrapped {
+            #[allow(unused_variables, non_snake_case, dead_code, clippy::all)]
+            fn expression<'a>(pair: Pair<'a, Rule>) -> ParseResult<RcExpr> {
+                ParseWrapped::expression(pair).map(|x| x.expression())
+            }
+        }
+        impl ParseWrapped {
+            #[allow(unused_variables, non_snake_case, dead_code, clippy::all)]
+            fn expression<'a>(pair: Pair<'a, Rule>) -> ParseResult<ParsedValue<'a>> {
+                ParseWrapped::parse_any_fast(pair)
+            }
+        }
+
         // fn do_the_parse(s: &str, r: Rule, ty: ParsedType) -> ParseResult<ParsedValue>  {
         //     let pairs = DhallParser::parse(r, s)?;
         //     match_iter!(pairs; (e) => ty.parse(e))
@@ -328,7 +394,6 @@ macro_rules! make_parser {
     );
 }
 
-
 macro_rules! make_pest_parse_function {
     ($name:ident<$o:ty>; $submac:ident!( $($args:tt)* )) => (
         impl ParseUnwrapped {
@@ -347,43 +412,44 @@ 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! 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_rule!(
-            Rule::$name => match_pair!( $($args)* ),
-        ));
+        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)?),
-            )*
-        ));
+        // make_pest_parse_function!($name<$o>; match_rule!(
+        //     $(
+        //         Rule::$ty => match_pair!(raw_pair!(p) => ParseUnwrapped::$ty(p)?),
+        //     )*
+        // ));
     );
 }
 
-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))),
-            }
-        }
-    };
-}
+// 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!()
 fn can_be_shortcutted(rule: Rule) -> bool {
@@ -448,15 +514,14 @@ macro_rules! binop {
     };
 }
 
-
-make_parser!{
+make_parser! {
 rule!(EOI<()>; children!() => ());
 
-named!(str<&'a str>; captured_str!(s) => s.trim());
+// named!(str<&'a str>; captured_str!(s) => s.trim());
 
-named!(raw_str<&'a str>; captured_str!(s) => s);
+// named!(raw_str<&'a str>; captured_str!(s) => s);
 
-named!(label<Label>; captured_str!(s) => Label::from(s.trim().to_owned()));
+// 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()));
 
@@ -473,7 +538,7 @@ rule!(double_quote_chunk<ParsedTextContents<'a>>;
     children!(s: double_quote_escaped) => {
         InterpolatedTextContents::Text(s)
     },
-    captured_str!(s) => {
+    children!(s: double_quote_char) => {
         InterpolatedTextContents::Text(s)
     },
 );
@@ -495,6 +560,9 @@ rule!(double_quote_escaped<&'a str>;
         }
     }
 );
+rule!(double_quote_char<&'a str>;
+    captured_str!(s) => s
+);
 
 rule!(end_of_line<()>; children!() => ());
 
@@ -756,11 +824,18 @@ rule!(application_expression<RcExpr>;
 );
 
 rule!(selector_expression_raw<RcExpr>;
-    children!(first: expression, rest..: label) => {
+    children!(first: expression, rest..: selector_raw) => {
         rest.fold(first, |acc, e| bx(Expr::Field(acc, e)))
     }
 );
 
+// TODO: handle record projection
+rule!(selector_raw<Label>;
+    children!(l: label_raw) => {
+        l
+    }
+);
+
 rule!(literal_expression_raw<RcExpr>;
     children!(n: double_literal_raw) => bx(Expr::DoubleLit(n)),
     children!(n: minus_infinity_literal) => bx(Expr::DoubleLit(std::f64::NEG_INFINITY)),
@@ -824,21 +899,23 @@ rule!(non_empty_record_type_or_literal<RcExpr>;
 );
 
 rule!(non_empty_record_type<(RcExpr, BTreeMap<Label, RcExpr>)>;
-    self!(x: partial_record_entries) => x
-);
-
-named!(partial_record_entries<(RcExpr, BTreeMap<Label, RcExpr>)>;
-    children!(expr: expression, entries..: record_entry) => {
+    children!(expr: expression, entries..: record_type_entry) => {
         (expr, entries.collect())
     }
 );
 
-named!(record_entry<(Label, RcExpr)>;
+rule!(record_type_entry<(Label, RcExpr)>;
     children!(name: label_raw, expr: expression) => (name, expr)
 );
 
 rule!(non_empty_record_literal<(RcExpr, BTreeMap<Label, RcExpr>)>;
-    self!(x: partial_record_entries) => x
+    children!(expr: expression, entries..: record_literal_entry) => {
+        (expr, entries.collect())
+    }
+);
+
+rule!(record_literal_entry<(Label, RcExpr)>;
+    children!(name: label_raw, expr: expression) => (name, expr)
 );
 
 rule!(union_type_or_literal<RcExpr>;
-- 
cgit v1.2.3


From 186eda565954f4b5a155374b9ba00c96cede439f Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 20 Mar 2019 19:32:27 +0100
Subject: Restore parser performance

---
 dhall_core/src/parser.rs | 392 ++++++++++-------------------------------------
 1 file changed, 82 insertions(+), 310 deletions(-)

(limited to 'dhall_core/src')

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
 );
 }
-- 
cgit v1.2.3


From 5745299a328462f0a60e56a9d11cbc60a0e4380d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 20 Mar 2019 20:24:58 +0100
Subject: Cleanup parser code

---
 dhall_core/src/lib.rs    |   1 -
 dhall_core/src/parser.rs | 173 ++++++++++++++---------------------------------
 2 files changed, 49 insertions(+), 125 deletions(-)

(limited to 'dhall_core/src')

diff --git a/dhall_core/src/lib.rs b/dhall_core/src/lib.rs
index 508ad3a..6215456 100644
--- a/dhall_core/src/lib.rs
+++ b/dhall_core/src/lib.rs
@@ -1,6 +1,5 @@
 #![feature(trace_macros)]
 #![feature(slice_patterns)]
-#![recursion_limit = "128"]
 #![allow(
     clippy::many_single_char_names,
     clippy::should_implement_trait,
diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs
index 30e3367..cbba8ca 100644
--- a/dhall_core/src/parser.rs
+++ b/dhall_core/src/parser.rs
@@ -107,7 +107,7 @@ macro_rules! match_pair {
         {
             let pair = $pair.clone();
             let rule = pair.as_rule();
-            let parsed: Vec<_> = pair.clone().into_inner().map(ParseWrapped::parse_any_fast).collect::<Result<_, _>>()?;
+            let parsed: Vec<_> = pair.clone().into_inner().map(parse_any).collect::<Result<_, _>>()?;
             #[allow(unreachable_code)]
             iter_patterns::match_vec!(parsed;
                 $($acc)*
@@ -119,48 +119,32 @@ macro_rules! match_pair {
     ($pair:expr; $( $submac:ident!($($args:tt)*) => $body:expr ),* $(,)*) => {
         match_pair!(@make_matches, $pair, (), $( $submac!($($args)*) => $body ),* ,)
     };
-    ($pair:expr; $($args:tt)*) => {
-        {
-            let pair = $pair;
-            let result = match_iter_branching!(@noclone, match_pair; pair; $($args)*);
-            result.map_err(|e| match e {
-                IterMatchError::Other(e) => e,
-                _ => custom_parse_error(&pair, "No match found".to_owned()),
-            })
-        }
-    };
 }
 
 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)*)
-    );
-    (@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)*)
+    // Filter out definitions that should not be matched on
+    (@filter, rule) => (true);
+    (@filter, rule_in_group) => (true);
+    (@filter, binop) => (true);
+    (@filter, rule_group) => (false);
+
+    (@body, $pair:expr, rule!( $name:ident<$o:ty>; $($args:tt)* )) => ( {
+        let res: $o = match_pair!($pair; $($args)*)?;
+        Ok(ParsedValue::$name(res))
+    });
+    (@body, $pair:expr, rule_in_group!( $name:ident<$o:ty>; $group:ident; $($args:tt)* )) => ( {
+        let res: $o = match_pair!($pair; $($args)*)?;
+        Ok(ParsedValue::$group(res))
+    });
+    (@body, $pair:expr, binop!( $name:ident<$o:ty>; $op:ident )) => ( {
+        parse_binop($pair, BinOp::$op)
+    });
+    (@body, $pair:expr, rule_group!( $name:ident<$o:ty> )) => (
+        unreachable!()
     );
-    // (@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)*)
-    );
-    (@branch_rules, $pair:expr, ($($acc:tt)*),) => (
-        #[allow(unreachable_patterns)]
-        match $pair.as_rule() {
-            $($acc)*
-            r => Err(custom_parse_error(&$pair, format!("parse_any_fast: Unexpected {:?}", r))),
-        }
-    );
-    ($( $submac:ident!( $name:ident<$o:ty>; $($args:tt)* ); )*) => (
+
+
+    ($( $submac:ident!( $name:ident<$o:ty> $($args:tt)* ); )*) => (
         // #[allow(non_camel_case_types, dead_code)]
         // enum ParsedType {
         //     $( $name, )*
@@ -182,8 +166,6 @@ macro_rules! make_parser {
         //     //     }
         //     // }
         // }
-        struct ParseWrapped;
-        struct ParseUnwrapped;
 
         #[allow(non_camel_case_types, dead_code)]
         #[derive(Debug)]
@@ -203,71 +185,22 @@ macro_rules! make_parser {
             )*
         }
 
-        impl ParseWrapped {
-            #[allow(non_snake_case, dead_code)]
-            fn parse_any_fast(pair: Pair<Rule>) -> ParseResult<ParsedValue> {
-                make_parser!(@branch_rules, pair, (), $( $submac!( $name<$o>; $($args)* ); )*)
+        #[allow(non_snake_case, dead_code)]
+        fn parse_any<'a>(pair: Pair<'a, Rule>) -> ParseResult<ParsedValue<'a>> {
+            #[allow(unreachable_patterns)]
+            match pair.as_rule() {
+                $(
+                    Rule::$name if make_parser!(@filter, $submac)
+                    =>
+                    make_parser!(@body, pair, $submac!( $name<$o> $($args)* ))
+                    ,
+                )*
+                r => Err(custom_parse_error(&pair, format!("parse_any: Unexpected {:?}", r))),
             }
         }
-
-        impl ParseUnwrapped {
-            #[allow(unused_variables, non_snake_case, dead_code, clippy::all)]
-            fn expression<'a>(pair: Pair<'a, Rule>) -> ParseResult<RcExpr> {
-                ParseWrapped::expression(pair).map(|x| x.expression())
-            }
-        }
-        impl ParseWrapped {
-            #[allow(unused_variables, non_snake_case, dead_code, clippy::all)]
-            fn expression<'a>(pair: Pair<'a, Rule>) -> ParseResult<ParsedValue<'a>> {
-                ParseWrapped::parse_any_fast(pair)
-            }
-        }
-
-        // fn do_the_parse(s: &str, r: Rule, ty: ParsedType) -> ParseResult<ParsedValue>  {
-        //     let pairs = DhallParser::parse(r, s)?;
-        //     match_iter!(pairs; (e) => ty.parse(e))
-        // }
-
-        $(
-            $submac!($name<$o>; $($args)*);
-        )*
     );
 }
 
-macro_rules! make_pest_parse_function {
-    ($name:ident<$o:ty>; $submac:ident!( $($args:tt)* )) => (
-        impl ParseUnwrapped {
-            #[allow(unused_variables, non_snake_case, dead_code, clippy::all)]
-            fn $name<'a>(pair: Pair<'a, Rule>) -> ParseResult<$o> {
-                ParseWrapped::$name(pair).map(|x| x.$name())
-            }
-        }
-        impl ParseWrapped {
-            #[allow(unused_variables, non_snake_case, dead_code, clippy::all)]
-            fn $name<'a>(pair: Pair<'a, Rule>) -> ParseResult<ParsedValue<'a>> {
-                let res: ParseResult<$o> = $submac!(pair; $($args)*);
-                Ok(ParsedValue::$name(res?))
-            }
-        }
-    );
-}
-
-macro_rules! rule {
-    ($name:ident<$o:ty>; $($args:tt)*) => (
-        make_pest_parse_function!($name<$o>; match_pair!( $($args)* ));
-    );
-}
-
-macro_rules! rule_in_group {
-    ($name:ident<$o:ty>; $group:ident; $($args:tt)*) => (
-        make_pest_parse_function!($name<$o>; match_pair!( $($args)* ));
-    );
-}
-
-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::*;
@@ -291,21 +224,25 @@ fn can_be_shortcutted(rule: Rule) -> bool {
     }
 }
 
-fn parse_binop(pair: Pair<Rule>, o: BinOp) -> ParseResult<RcExpr> {
+fn parse_binop(pair: Pair<Rule>, o: BinOp) -> ParseResult<ParsedValue> {
     // 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<_, _>>()?;
+    let rest: Vec<_> = pairs
+        .map(|p| parse_any(p).map(|x| x.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))))
+        let first = parse_any(first)?.expression();
+        Ok(ParsedValue::expression(
+            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();
@@ -316,22 +253,10 @@ fn parse_binop(pair: Pair<Rule>, o: BinOp) -> ParseResult<RcExpr> {
             }
             pair = first;
         }
-        // println!("short-cutted {}", debug_pair(pair.clone()));
-        // println!();
-        Ok(ParseUnwrapped::expression(pair)?)
+        parse_any(pair)
     }
 }
 
-macro_rules! binop {
-    ($rule:ident<$ty:ty>; $op:ident) => {
-        rule!($rule<$ty>;
-            raw_pair!(pair) => {
-                parse_binop(pair, BinOp::$op)?
-            }
-        );
-    };
-}
-
 make_parser! {
 rule!(EOI<()>; children!() => ());
 
@@ -450,7 +375,7 @@ rule!(path<PathBuf>;
     captured_str!(s) => (".".to_owned() + s).into()
 );
 
-rule_group!(local_raw<(FilePrefix, PathBuf)>;);
+rule_group!(local_raw<(FilePrefix, PathBuf)>);
 
 rule_in_group!(parent_path<(FilePrefix, PathBuf)>; local_raw;
     children!(p: path) => (FilePrefix::Parent, p)
@@ -492,7 +417,7 @@ rule!(import_hashed_raw<(ImportLocation, Option<()>)>;
     }
 );
 
-rule_group!(expression<RcExpr>;);
+rule_group!(expression<RcExpr>);
 
 rule_in_group!(import_raw<RcExpr>; expression;
     // TODO: handle "as Text"
@@ -746,11 +671,11 @@ 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] => ParseUnwrapped::expression(p))
+    let expr = iter_patterns::destructure_iter!(pairs; [p] => parse_any(p))
         .unwrap()?;
     // expr.expression()
-    // Ok(expr.expression())
-    Ok(expr)
+    Ok(expr.expression())
+    // Ok(expr)
     // Ok(bx(Expr::BoolLit(false)))
 }
 
-- 
cgit v1.2.3


From f71a73d996fa16a3b1c58f9c0bd87824ac11f14c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 20 Mar 2019 21:15:04 +0100
Subject: Remove binop special case in parser; cleanup

---
 dhall_core/src/parser.rs | 116 +++++++++++++++++++++++++++--------------------
 1 file changed, 66 insertions(+), 50 deletions(-)

(limited to 'dhall_core/src')

diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs
index cbba8ca..52e8c64 100644
--- a/dhall_core/src/parser.rs
+++ b/dhall_core/src/parser.rs
@@ -91,18 +91,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)*), raw_pair!($x:ident) => $body:expr, $($rest:tt)*) => {
-        match_pair!(@make_matches, $pair, ([..] => {
-            let $x = $pair.clone();
-            $body
-        }, $($acc)*), $($rest)*)
-    };
-    (@make_matches, $pair:expr, ($($acc:tt)*), captured_str!($x:ident) => $body:expr, $($rest:tt)*) => {
-        match_pair!(@make_matches, $pair, ([..] => {
-            let $x = $pair.as_str();
-            $body
-        }, $($acc)*), $($rest)*)
-    };
     (@make_matches, $pair:expr, ($($acc:tt)*) $(,)*) => {
         {
             let pair = $pair.clone();
@@ -122,23 +110,28 @@ macro_rules! match_pair {
 }
 
 macro_rules! make_parser {
-    // Filter out definitions that should not be matched on
+    // Filter out definitions that should not be matched on (i.e. rule_group)
     (@filter, rule) => (true);
     (@filter, rule_in_group) => (true);
-    (@filter, binop) => (true);
     (@filter, rule_group) => (false);
 
-    (@body, $pair:expr, rule!( $name:ident<$o:ty>; $($args:tt)* )) => ( {
-        let res: $o = match_pair!($pair; $($args)*)?;
-        Ok(ParsedValue::$name(res))
+    (@body, $pair:expr, rule!( $name:ident<$o:ty>; $($args:tt)* )) => (
+        make_parser!(@body, $pair, rule_in_group!( $name<$o>; $name; $($args)* ))
+    );
+    (@body, $pair:expr, rule_in_group!( $name:ident<$o:ty>; $group:ident; raw_pair!($x:pat) => $body:expr )) => ( {
+        let $x = $pair.clone();
+        let res: $o = $body;
+        Ok(ParsedValue::$group(res))
+    });
+    (@body, $pair:expr, rule_in_group!( $name:ident<$o:ty>; $group:ident; captured_str!($x:ident) => $body:expr )) => ( {
+        let $x = $pair.as_str();
+        let res: $o = $body;
+        Ok(ParsedValue::$group(res))
     });
     (@body, $pair:expr, rule_in_group!( $name:ident<$o:ty>; $group:ident; $($args:tt)* )) => ( {
         let res: $o = match_pair!($pair; $($args)*)?;
         Ok(ParsedValue::$group(res))
     });
-    (@body, $pair:expr, binop!( $name:ident<$o:ty>; $op:ident )) => ( {
-        parse_binop($pair, BinOp::$op)
-    });
     (@body, $pair:expr, rule_group!( $name:ident<$o:ty> )) => (
         unreachable!()
     );
@@ -224,7 +217,7 @@ fn can_be_shortcutted(rule: Rule) -> bool {
     }
 }
 
-fn parse_binop(pair: Pair<Rule>, o: BinOp) -> ParseResult<ParsedValue> {
+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.
@@ -237,10 +230,9 @@ fn parse_binop(pair: Pair<Rule>, o: BinOp) -> ParseResult<ParsedValue> {
     if !rest.is_empty() {
         // If there is more than one subexpression, handle it normally
         let first = parse_any(first)?.expression();
-        Ok(ParsedValue::expression(
-            rest.into_iter()
-                .fold(first, |acc, e| bx(Expr::BinOp(o, acc, e))),
-        ))
+        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.
         pair = first;
@@ -253,12 +245,12 @@ fn parse_binop(pair: Pair<Rule>, o: BinOp) -> ParseResult<ParsedValue> {
             }
             pair = first;
         }
-        parse_any(pair)
+        Ok(parse_any(pair)?.expression())
     }
 }
 
 make_parser! {
-rule!(EOI<()>; children!() => ());
+rule!(EOI<()>; raw_pair!(_) => ());
 
 rule!(label_raw<Label>; captured_str!(s) => Label::from(s.trim().to_owned()));
 
@@ -301,7 +293,7 @@ rule!(double_quote_char<&'a str>;
     captured_str!(s) => s
 );
 
-rule!(end_of_line<()>; children!() => ());
+rule!(end_of_line<()>; raw_pair!(_) => ());
 
 rule!(single_quote_literal<ParsedText>;
     children!(eol: end_of_line, contents: single_quote_continue) => {
@@ -312,10 +304,10 @@ rule!(single_quote_char<&'a str>;
     captured_str!(s) => s
 );
 rule!(escaped_quote_pair<&'a str>;
-    children!() => "''"
+    raw_pair!(_) => "''"
 );
 rule!(escaped_interpolation<&'a str>;
-    children!() => "${"
+    raw_pair!(_) => "${"
 );
 rule!(interpolation<RcExpr>;
     children!(e: expression) => e
@@ -343,9 +335,9 @@ rule!(single_quote_continue<Vec<ParsedTextContents<'a>>>;
     },
 );
 
-rule!(NaN_raw<()>; children!() => ());
-rule!(minus_infinity_literal<()>; children!() => ());
-rule!(plus_infinity_literal<()>; children!() => ());
+rule!(NaN_raw<()>; raw_pair!(_) => ());
+rule!(minus_infinity_literal<()>; raw_pair!(_) => ());
+rule!(plus_infinity_literal<()>; raw_pair!(_) => ());
 
 rule!(double_literal_raw<core::Double>;
     raw_pair!(pair) => {
@@ -471,8 +463,8 @@ rule_in_group!(merge_expression<RcExpr>; expression;
     children!(x: expression, y: expression) => bx(Expr::Merge(x, y, None)),
 );
 
-rule!(List<()>; children!() => ());
-rule!(Optional<()>; children!() => ());
+rule!(List<()>; raw_pair!(_) => ());
+rule!(Optional<()>; raw_pair!(_) => ());
 
 rule_in_group!(empty_collection<RcExpr>; expression;
     children!(_x: List, y: expression) => {
@@ -489,18 +481,42 @@ rule_in_group!(non_empty_optional<RcExpr>; expression;
     }
 );
 
-binop!(import_alt_expression<RcExpr>; ImportAlt);
-binop!(or_expression<RcExpr>; BoolOr);
-binop!(plus_expression<RcExpr>; NaturalPlus);
-binop!(text_append_expression<RcExpr>; TextAppend);
-binop!(list_append_expression<RcExpr>; ListAppend);
-binop!(and_expression<RcExpr>; BoolAnd);
-binop!(combine_expression<RcExpr>; Combine);
-binop!(prefer_expression<RcExpr>; Prefer);
-binop!(combine_types_expression<RcExpr>; CombineTypes);
-binop!(times_expression<RcExpr>; NaturalTimes);
-binop!(equal_expression<RcExpr>; BoolEQ);
-binop!(not_equal_expression<RcExpr>; BoolNE);
+rule_in_group!(import_alt_expression<RcExpr>; expression;
+    raw_pair!(p) => parse_binop(p, BinOp::ImportAlt)?
+);
+rule_in_group!(or_expression<RcExpr>; expression;
+    raw_pair!(p) => parse_binop(p, BinOp::BoolOr)?
+);
+rule_in_group!(plus_expression<RcExpr>; expression;
+    raw_pair!(p) => parse_binop(p, BinOp::NaturalPlus)?
+);
+rule_in_group!(text_append_expression<RcExpr>; expression;
+    raw_pair!(p) => parse_binop(p, BinOp::TextAppend)?
+);
+rule_in_group!(list_append_expression<RcExpr>; expression;
+    raw_pair!(p) => parse_binop(p, BinOp::ListAppend)?
+);
+rule_in_group!(and_expression<RcExpr>; expression;
+    raw_pair!(p) => parse_binop(p, BinOp::BoolAnd)?
+);
+rule_in_group!(combine_expression<RcExpr>; expression;
+    raw_pair!(p) => parse_binop(p, BinOp::Combine)?
+);
+rule_in_group!(prefer_expression<RcExpr>; expression;
+    raw_pair!(p) => parse_binop(p, BinOp::Prefer)?
+);
+rule_in_group!(combine_types_expression<RcExpr>; expression;
+    raw_pair!(p) => parse_binop(p, BinOp::CombineTypes)?
+);
+rule_in_group!(times_expression<RcExpr>; expression;
+    raw_pair!(p) => parse_binop(p, BinOp::NaturalTimes)?
+);
+rule_in_group!(equal_expression<RcExpr>; expression;
+    raw_pair!(p) => parse_binop(p, BinOp::BoolEQ)?
+);
+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) => {
@@ -575,11 +591,11 @@ rule_in_group!(identifier_raw<RcExpr>; expression;
 );
 
 rule_in_group!(empty_record_literal<RcExpr>; expression;
-    children!() => bx(Expr::RecordLit(BTreeMap::new()))
+    raw_pair!(_) => bx(Expr::RecordLit(BTreeMap::new()))
 );
 
 rule_in_group!(empty_record_type<RcExpr>; expression;
-    children!() => bx(Expr::Record(BTreeMap::new()))
+    raw_pair!(_) => bx(Expr::Record(BTreeMap::new()))
 );
 
 rule_in_group!(non_empty_record_type_or_literal<RcExpr>; expression;
@@ -627,7 +643,7 @@ rule_in_group!(union_type_or_literal<RcExpr>; expression;
     },
 );
 
-rule!(empty_union_type<()>; children!() => ());
+rule!(empty_union_type<()>; raw_pair!(_) => ());
 
 rule!(non_empty_union_type_or_literal
       <(Option<(Label, RcExpr)>, BTreeMap<Label, RcExpr>)>;
-- 
cgit v1.2.3


From 193b8956ba2b8373ffbd34046ae57e42eca82387 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 20 Mar 2019 21:33:46 +0100
Subject: Change syntax of parser macros

---
 dhall_core/src/parser.rs | 296 +++++++++++++++++++++++------------------------
 1 file changed, 148 insertions(+), 148 deletions(-)

(limited to 'dhall_core/src')

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> {
-- 
cgit v1.2.3


From 775b26ee3e6dba4173d71ab5c15a0f11aceeef69 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 20 Mar 2019 21:42:32 +0100
Subject: Allow patterns in parser macros

---
 dhall_core/src/parser.rs | 52 +++++++++++++++++++-----------------------------
 1 file changed, 21 insertions(+), 31 deletions(-)

(limited to 'dhall_core/src')

diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs
index 34b6a13..8b14da0 100644
--- a/dhall_core/src/parser.rs
+++ b/dhall_core/src/parser.rs
@@ -72,15 +72,15 @@ fn debug_pair(pair: Pair<Rule>) -> String {
 }
 
 macro_rules! match_pair {
-    (@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)*), ($(,)* $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
         }, $($rest)*)
     };
+    (@make_child_match, $pair:expr, ($($outer_acc:tt)*), ($($acc:tt)*), ($(,)* $ty:ident ($x:pat)  $($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)*), ($(,)*) => $body:expr, $($rest:tt)*) => {
         match_pair!(@make_matches, $pair, ([$($acc)*] => { $body }, $($outer_acc)*), $($rest)*)
     };
@@ -261,8 +261,8 @@ rule!(double_quote_literal<ParsedText>; children!(
 ));
 
 rule!(double_quote_chunk<ParsedTextContents<'a>>; children!(
-    [interpolation(c)] => {
-        InterpolatedTextContents::Expr(c)
+    [interpolation(e)] => {
+        InterpolatedTextContents::Expr(e)
     },
     [double_quote_escaped(s)] => {
         InterpolatedTextContents::Text(s)
@@ -396,25 +396,21 @@ rule!(import_type_raw<ImportLocation>; children!(
     // [http(url)] => {
     //     ImportLocation::Remote(url)
     // }
-    [local_raw(import)] => {
-        let (prefix, path) = import;
+    [local_raw((prefix, path))] => {
         ImportLocation::Local(prefix, path)
     }
 ));
 
 rule!(import_hashed_raw<(ImportLocation, Option<()>)>; children!(
     // TODO: handle hash
-    [import_type_raw(import)] => {
-        (import, None)
-    }
+    [import_type_raw(import)] => (import, None)
 ));
 
 rule_group!(expression<RcExpr>);
 
 rule_in_group!(import_raw<RcExpr>; expression; children!(
     // TODO: handle "as Text"
-    [import_hashed_raw(import)] => {
-        let (location, hash) = import;
+    [import_hashed_raw((location, hash))] => {
         bx(Expr::Embed(Import {
             mode: ImportMode::Code,
             hash,
@@ -467,16 +463,16 @@ rule!(List<()>; raw_pair!(_) => ());
 rule!(Optional<()>; raw_pair!(_) => ());
 
 rule_in_group!(empty_collection<RcExpr>; expression; children!(
-    [List(_x), expression(y)] => {
+    [List(_), expression(y)] => {
         bx(Expr::EmptyListLit(y))
     },
-    [Optional(_x), expression(y)] => {
+    [Optional(_), expression(y)] => {
         bx(Expr::OptionalLit(Some(y), None))
     },
 ));
 
 rule_in_group!(non_empty_optional<RcExpr>; expression; children!(
-    [expression(x), Optional(_y), expression(z)] => {
+    [expression(x), Optional(_), expression(z)] => {
         bx(Expr::OptionalLit(Some(z), Some(x)))
     }
 ));
@@ -544,9 +540,7 @@ rule_in_group!(selector_expression_raw<RcExpr>; expression; children!(
 
 // TODO: handle record projection
 rule!(selector_raw<Label>; children!(
-    [label_raw(l)] => {
-        l
-    }
+    [label_raw(l)] => l
 ));
 
 rule_in_group!(literal_expression_raw<RcExpr>; expression; children!(
@@ -632,14 +626,14 @@ rule!(record_literal_entry<(Label, RcExpr)>; children!(
 ));
 
 rule_in_group!(union_type_or_literal<RcExpr>; expression; children!(
-    [empty_union_type(_e)] => {
+    [empty_union_type(_)] => {
         bx(Expr::Union(BTreeMap::new()))
     },
-    [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)),
-        }
+    [non_empty_union_type_or_literal((Some((l, e)), entries))] => {
+        bx(Expr::UnionLit(l, e, entries))
+    },
+    [non_empty_union_type_or_literal((None, entries))] => {
+        bx(Expr::Union(entries))
     },
 ));
 
@@ -660,12 +654,10 @@ rule!(non_empty_union_type_or_literal
         entries.insert(l, e);
         (None, entries)
     },
-  ));
+));
 
 rule!(union_type_entries<BTreeMap<Label, RcExpr>>; children!(
-    [union_type_entry(entries..)] => {
-        entries.collect()
-    }
+    [union_type_entry(entries..)] => entries.collect()
 ));
 
 rule!(union_type_entry<(Label, RcExpr)>; children!(
@@ -673,9 +665,7 @@ rule!(union_type_entry<(Label, RcExpr)>; children!(
 ));
 
 rule_in_group!(non_empty_list_literal_raw<RcExpr>; expression; children!(
-    [expression(items..)] => {
-        bx(Expr::NEListLit(items.collect()))
-    }
+    [expression(items..)] => bx(Expr::NEListLit(items.collect()))
 ));
 
 rule_in_group!(final_expression<RcExpr>; expression; children!(
-- 
cgit v1.2.3


From d6cbee16586be9013bebfa8dc9e7aa0a31c8c55f Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 20 Mar 2019 22:46:07 +0100
Subject: Make parser implementation non-recursive

---
 dhall_core/src/parser.rs | 231 ++++++++++++++++++++++++++---------------------
 1 file changed, 128 insertions(+), 103 deletions(-)

(limited to 'dhall_core/src')

diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs
index 8b14da0..34809b5 100644
--- a/dhall_core/src/parser.rs
+++ b/dhall_core/src/parser.rs
@@ -72,40 +72,39 @@ fn debug_pair(pair: Pair<Rule>) -> String {
 }
 
 macro_rules! match_pair {
-    (@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)*) => {
+    (@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());
             $body
         }, $($rest)*)
     };
-    (@make_child_match, $pair:expr, ($($outer_acc:tt)*), ($($acc:tt)*), ($(,)* $ty:ident ($x:pat)  $($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, ($($vars:tt)*), ($($outer_acc:tt)*), ($($acc:tt)*), ($(,)* $ty:ident ($x:pat)  $($rest_of_match:tt)*) => $body:expr, $($rest:tt)*) => {
+        match_pair!(@make_child_match, ($($vars)*), ($($outer_acc)*), ($($acc)*, ParsedValue::$ty($x)), ($($rest_of_match)*) => $body, $($rest)*)
     };
-    (@make_child_match, $pair:expr, ($($outer_acc:tt)*), (, $($acc:tt)*), ($(,)*) => $body:expr, $($rest:tt)*) => {
-        match_pair!(@make_matches, $pair, ([$($acc)*] => { $body }, $($outer_acc)*), $($rest)*)
+    (@make_child_match, ($($vars:tt)*), ($($outer_acc:tt)*), (, $($acc:tt)*), ($(,)*) => $body:expr, $($rest:tt)*) => {
+        match_pair!(@make_matches, ($($vars)*), ([$($acc)*] => { $body }, $($outer_acc)*), $($rest)*)
     };
-    (@make_child_match, $pair:expr, ($($outer_acc:tt)*), (), ($(,)*) => $body:expr, $($rest:tt)*) => {
-        match_pair!(@make_matches, $pair, ([] => { $body }, $($outer_acc)*), $($rest)*)
+    (@make_child_match, ($($vars:tt)*), ($($outer_acc:tt)*), (), ($(,)*) => $body:expr, $($rest:tt)*) => {
+        match_pair!(@make_matches, ($($vars)*), ([] => { $body }, $($outer_acc)*), $($rest)*)
     };
 
-    (@make_matches, $pair:expr, ($($acc:tt)*), [$($args:tt)*] => $body:expr, $($rest:tt)*) => {
-        match_pair!(@make_child_match, $pair, ($($acc)*), (), ($($args)*) => $body, $($rest)*)
+    (@make_matches, ($($vars:tt)*), ($($acc:tt)*), [$($args:tt)*] => $body:expr, $($rest:tt)*) => {
+        match_pair!(@make_child_match, ($($vars)*), ($($acc)*), (), ($($args)*) => $body, $($rest)*)
     };
-    (@make_matches, $pair:expr, ($($acc:tt)*) $(,)*) => {
+    (@make_matches, ($pair:expr, $parsed:expr), ($($acc:tt)*) $(,)*) => {
         {
-            let pair = $pair.clone();
+            let pair = $pair;
             let rule = pair.as_rule();
-            let parsed: Vec<_> = pair.clone().into_inner().map(parse_any).collect::<Result<_, _>>()?;
             #[allow(unreachable_code)]
-            iter_patterns::match_vec!(parsed;
+            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()))
         }
     };
 
-    ($pair:expr; $( [$($args:tt)*] => $body:expr ),* $(,)*) => {
-        match_pair!(@make_matches, $pair, (), $( [$($args)*] => $body ),* ,)
+    (($($vars:tt)*); $( [$($args:tt)*] => $body:expr ),* $(,)*) => {
+        match_pair!(@make_matches, ($($vars)*), (), $( [$($args)*] => $body ),* ,)
     };
 }
 
@@ -115,24 +114,24 @@ macro_rules! make_parser {
     (@filter, rule_in_group) => (true);
     (@filter, rule_group) => (false);
 
-    (@body, $pair:expr, rule!( $name:ident<$o:ty>; $($args:tt)* )) => (
-        make_parser!(@body, $pair, rule_in_group!( $name<$o>; $name; $($args)* ))
+    (@body, $pair:expr, $parsed:expr, rule!( $name:ident<$o:ty>; $($args:tt)* )) => (
+        make_parser!(@body, $pair, $parsed, rule_in_group!( $name<$o>; $name; $($args)* ))
     );
-    (@body, $pair:expr, rule_in_group!( $name:ident<$o:ty>; $group:ident; raw_pair!($x:pat) => $body:expr )) => ( {
+    (@body, $pair:expr, $parsed:expr, rule_in_group!( $name:ident<$o:ty>; $group:ident; raw_pair!($x:pat) => $body:expr )) => ( {
         let $x = $pair.clone();
         let res: $o = $body;
         Ok(ParsedValue::$group(res))
     });
-    (@body, $pair:expr, rule_in_group!( $name:ident<$o:ty>; $group:ident; captured_str!($x:ident) => $body:expr )) => ( {
+    (@body, $pair:expr, $parsed:expr, rule_in_group!( $name:ident<$o:ty>; $group:ident; captured_str!($x:ident) => $body:expr )) => ( {
         let $x = $pair.as_str();
         let res: $o = $body;
         Ok(ParsedValue::$group(res))
     });
-    (@body, $pair:expr, rule_in_group!( $name:ident<$o:ty>; $group:ident; children!( $($args:tt)* ) )) => ( {
-        let res: $o = match_pair!($pair; $($args)*)?;
+    (@body, $pair:expr, $parsed:expr, rule_in_group!( $name:ident<$o:ty>; $group:ident; children!( $($args:tt)* ) )) => ( {
+        let res: $o = match_pair!(($pair, $parsed); $($args)*)?;
         Ok(ParsedValue::$group(res))
     });
-    (@body, $pair:expr, rule_group!( $name:ident<$o:ty> )) => (
+    (@body, $pair:expr, $parsed:expr, rule_group!( $name:ident<$o:ty> )) => (
         unreachable!()
     );
 
@@ -178,23 +177,45 @@ macro_rules! make_parser {
             )*
         }
 
-        #[allow(non_snake_case, dead_code)]
-        fn parse_any<'a>(pair: Pair<'a, Rule>) -> ParseResult<ParsedValue<'a>> {
-            #[allow(unreachable_patterns)]
-            match pair.as_rule() {
-                $(
-                    Rule::$name if make_parser!(@filter, $submac)
-                    =>
-                    make_parser!(@body, pair, $submac!( $name<$o> $($args)* ))
-                    ,
-                )*
-                r => Err(custom_parse_error(&pair, format!("parse_any: Unexpected {:?}", r))),
+        // Non-recursive implementation to avoid stack overflows
+        fn parse_any<'a>(initial_pair: Pair<'a, Rule>) -> ParseResult<ParsedValue<'a>> {
+            enum StackFrame<'a> {
+                Unprocessed(Pair<'a, Rule>),
+                Processed(Pair<'a, Rule>, usize),
             }
+            use StackFrame::*;
+            let mut pairs_stack: Vec<StackFrame> = vec![Unprocessed(initial_pair.clone())];
+            let mut values_stack: Vec<ParsedValue> = vec![];
+            while let Some(p) = pairs_stack.pop() {
+                match p {
+                    Unprocessed(pair) => {
+                        let mut pairs: Vec<_> = pair.clone().into_inner().map(StackFrame::Unprocessed).collect();
+                        let n_children = pairs.len();
+                        pairs_stack.push(Processed(pair, n_children));
+                        pairs_stack.append(&mut pairs);
+                    }
+                    Processed(pair, n) => {
+                        let mut parsed: Vec<_> = values_stack.split_off(values_stack.len() - n);
+                        parsed.reverse();
+                        let val = match pair.as_rule() {
+                            $(
+                                Rule::$name if make_parser!(@filter, $submac)
+                                =>
+                                make_parser!(@body, pair, parsed, $submac!( $name<$o> $($args)* ))
+                                ,
+                            )*
+                            r => Err(custom_parse_error(&pair, format!("parse_any: Unexpected {:?}", r))),
+                        }?;
+                        values_stack.push(val);
+                    }
+                }
+            }
+            Ok(values_stack.pop().unwrap())
         }
     );
 }
 
-// List of rules that can be shortcutted as implemented in parse_binop
+// List of rules that can be shortcutted if they have a single child
 fn can_be_shortcutted(rule: Rule) -> bool {
     use Rule::*;
     match rule {
@@ -217,38 +238,6 @@ 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(|p| parse_any(p).map(|x| x.expression()))
-        .collect::<Result<_, _>>()?;
-    if !rest.is_empty() {
-        // If there is more than one subexpression, handle it normally
-        let first = parse_any(first)?.expression();
-        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.
-        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;
-        }
-        Ok(parse_any(pair)?.expression())
-    }
-}
-
 make_parser! {
 rule!(EOI<()>; raw_pair!(_) => ());
 
@@ -477,42 +466,78 @@ rule_in_group!(non_empty_optional<RcExpr>; expression; children!(
     }
 ));
 
-rule_in_group!(import_alt_expression<RcExpr>; expression;
-    raw_pair!(p) => parse_binop(p, BinOp::ImportAlt)?
-);
-rule_in_group!(or_expression<RcExpr>; expression;
-    raw_pair!(p) => parse_binop(p, BinOp::BoolOr)?
-);
-rule_in_group!(plus_expression<RcExpr>; expression;
-    raw_pair!(p) => parse_binop(p, BinOp::NaturalPlus)?
-);
-rule_in_group!(text_append_expression<RcExpr>; expression;
-    raw_pair!(p) => parse_binop(p, BinOp::TextAppend)?
-);
-rule_in_group!(list_append_expression<RcExpr>; expression;
-    raw_pair!(p) => parse_binop(p, BinOp::ListAppend)?
-);
-rule_in_group!(and_expression<RcExpr>; expression;
-    raw_pair!(p) => parse_binop(p, BinOp::BoolAnd)?
-);
-rule_in_group!(combine_expression<RcExpr>; expression;
-    raw_pair!(p) => parse_binop(p, BinOp::Combine)?
-);
-rule_in_group!(prefer_expression<RcExpr>; expression;
-    raw_pair!(p) => parse_binop(p, BinOp::Prefer)?
-);
-rule_in_group!(combine_types_expression<RcExpr>; expression;
-    raw_pair!(p) => parse_binop(p, BinOp::CombineTypes)?
-);
-rule_in_group!(times_expression<RcExpr>; expression;
-    raw_pair!(p) => parse_binop(p, BinOp::NaturalTimes)?
-);
-rule_in_group!(equal_expression<RcExpr>; expression;
-    raw_pair!(p) => parse_binop(p, BinOp::BoolEQ)?
-);
-rule_in_group!(not_equal_expression<RcExpr>; expression;
-    raw_pair!(p) => parse_binop(p, BinOp::BoolNE)?
-);
+rule_in_group!(import_alt_expression<RcExpr>; 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!(
+    [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!(
+    [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!(
+    [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!(
+    [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!(
+    [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!(
+    [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!(
+    [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!(
+    [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!(
+    [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!(
+    [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!(
+    [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!(
     [expression(e), expression(annot)] => {
-- 
cgit v1.2.3


From 5935839881b5437eec4ea3915acbe887782d68d3 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 20 Mar 2019 22:53:18 +0100
Subject: Reimplement shortcutting

---
 dhall_core/src/parser.rs | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

(limited to 'dhall_core/src')

diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs
index 34809b5..ef7fcc9 100644
--- a/dhall_core/src/parser.rs
+++ b/dhall_core/src/parser.rs
@@ -188,11 +188,19 @@ macro_rules! make_parser {
             let mut values_stack: Vec<ParsedValue> = vec![];
             while let Some(p) = pairs_stack.pop() {
                 match p {
-                    Unprocessed(pair) => {
-                        let mut pairs: Vec<_> = pair.clone().into_inner().map(StackFrame::Unprocessed).collect();
-                        let n_children = pairs.len();
-                        pairs_stack.push(Processed(pair, n_children));
-                        pairs_stack.append(&mut pairs);
+                    Unprocessed(mut pair) => {
+                        loop {
+                            let mut pairs: Vec<_> = pair.clone().into_inner().collect();
+                            let n_children = pairs.len();
+                            if n_children == 1 && can_be_shortcutted(pair.as_rule()) {
+                                pair = pairs.pop().unwrap();
+                                continue
+                            } else {
+                                pairs_stack.push(Processed(pair, n_children));
+                                pairs_stack.extend(pairs.into_iter().map(StackFrame::Unprocessed));
+                                break
+                            }
+                        }
                     }
                     Processed(pair, n) => {
                         let mut parsed: Vec<_> = values_stack.split_off(values_stack.len() - n);
-- 
cgit v1.2.3


From 4d616450d6883e68672a91f447999660fa17636c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 20 Mar 2019 23:11:06 +0100
Subject: Cleanup parser

---
 dhall_core/src/parser.rs | 155 +++++++++++++++++++----------------------------
 1 file changed, 64 insertions(+), 91 deletions(-)

(limited to 'dhall_core/src')

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)))
 }
 
-- 
cgit v1.2.3