Implement more flexible matching

1 files changed, 106 insertions, 95 deletions

diff --git a/dhall/src/parser.rs b/dhall/src/parser.rs
index 8322270..d357fbc 100644
--- a/dhall/src/parser.rs
+++ b/dhall/src/parser.rs
@@ -298,10 +298,8 @@ macro_rules! match_iter_typed {
  *
 */
 macro_rules! match_iter_branching {
-    ($callback:ident; $iter:expr; $( $submac:ident!($($args:tt)*) => $body:expr ),* $(,)*) => {
+    (@noclone, $callback:ident; $arg:expr; $( $submac:ident!($($args:tt)*) => $body:expr ),* $(,)*) => {
         {
-            #[allow(unused_mut)]
-            let mut iter = $iter;
             #[allow(unused_assignments)]
             let mut last_error = IterMatchError::NoMatchFound;
             // Not a real loop; used for error handling
@@ -309,7 +307,8 @@ macro_rules! match_iter_branching {
             #[allow(unreachable_code)]
             loop {
                 $(
-                    let matched: Result<_, IterMatchError<_>> = $callback!(@branch_callback, $submac, iter.clone(); ($($args)*) => $body);
+                    let matched: Result<_, IterMatchError<_>> =
+                        $callback!(@branch_callback, $submac, $arg; ($($args)*) => $body);
                     #[allow(unused_assignments)]
                     match matched {
                         Ok(v) => break Ok(v),
@@ -320,6 +319,13 @@ macro_rules! match_iter_branching {
             }
         }
     };
+    ($callback:ident; $iter:expr; $($args:tt)*) => {
+        {
+            #[allow(unused_mut)]
+            let mut iter = $iter;
+            match_iter_branching!(@noclone, $callback; iter.clone(); $($args)*)
+        }
+    };
 }
 
 macro_rules! named {
@@ -343,16 +349,39 @@ macro_rules! match_pest {
     (@type_callback, $ty:ident, $x:expr) => {
         $ty($x)
     };
-    (@branch_callback, children, $($args:tt)*) => {
-        match_iter_typed!(match_pest; $($args)*)
+    (@branch_callback, children, $pair:expr; $($args:tt)*) => {
+        {
+            #[allow(unused_mut)]
+            let mut pairs = $pair.clone().into_inner();
+            match_iter_typed!(match_pest; pairs; $($args)*)
+        }
+    };
+    (@branch_callback, self, $pair:expr; ($x:ident : $ty:ident) => $body:expr) => {
+        {
+            let $x = match_pest!(@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) => {
+        {
+            let $x = $pair.clone();
+            Ok($body)
+        }
+    };
+    (@branch_callback, captured_str, $pair:expr; ($x:ident) => $body:expr) => {
+        {
+            let $x = $pair.as_str();
+            Ok($body)
+        }
     };
 
     ($pair:expr; $($args:tt)*) => {
         {
             let pair = $pair;
-            #[allow(unused_mut)]
-            let mut pairs = pair.clone().into_inner();
-            let result = match_iter_branching!(match_pest; pairs; $($args)*);
+            let result = match_iter_branching!(@noclone, match_pest; pair; $($args)*);
             result.map_err(|e| match e {
                 IterMatchError::Other(e) => e,
                 _ => custom_parse_error(&pair, "No match found".to_owned()),
@@ -367,35 +396,6 @@ macro_rules! match_children {
     };
 }
 
-macro_rules! with_captured_str {
-    ($pair:expr; $x:ident; $body:expr) => {{
-        #[allow(unused_mut)]
-        let mut $x = $pair.as_str();
-        Ok($body)
-    }};
-}
-
-macro_rules! with_raw_pair {
-    ($pair:expr; $x:ident; $body:expr) => {{
-        #[allow(unused_mut)]
-        let mut $x = $pair;
-        Ok($body)
-    }};
-}
-
-macro_rules! map {
-    ($pair:expr; $ty:ident; $f:expr) => {{
-        let x = $ty($pair)?;
-        Ok($f(x))
-    }};
-}
-
-macro_rules! plain_value {
-    ($_pair:expr; $body:expr) => {
-        Ok($body)
-    };
-}
-
 macro_rules! binop {
     ($pair:expr; $f:expr) => {
         {
@@ -407,16 +407,6 @@ macro_rules! binop {
     };
 }
 
-macro_rules! with_rule {
-    ($pair:expr; $x:ident; $submac:ident!( $($args:tt)* )) => {
-        {
-            #[allow(unused_mut)]
-            let mut $x = $pair.as_rule();
-            $submac!($pair; $($args)*)
-        }
-    };
-}
-
 macro_rules! match_rule {
     ($pair:expr; $($pat:pat => $submac:ident!( $($args:tt)* ),)*) => {
         {
@@ -431,14 +421,24 @@ macro_rules! match_rule {
     };
 }
 
-named!(eoi<()>; plain_value!(()));
+named!(eoi<()>; match_pest!(
+    children!() => ()
+));
 
-named!(str<&'a str>; with_captured_str!(s; { s.trim() }));
+named!(str<&'a str>; match_pest!(
+    captured_str!(s) => s.trim()
+));
 
-named!(raw_str<&'a str>; with_captured_str!(s; s));
+named!(raw_str<&'a str>; match_pest!(
+    captured_str!(s) => s
+));
 
-named_rule!(escaped_quote_pair<&'a str>; plain_value!("''"));
-named_rule!(escaped_interpolation<&'a str>; plain_value!("${"));
+named_rule!(escaped_quote_pair<&'a str>; match_pest!(
+    children!() => "''"
+));
+named_rule!(escaped_interpolation<&'a str>; match_pest!(
+    children!() => "${"
+));
 
 named_rule!(single_quote_continue<Vec<&'a str>>; match_pest!(
     // TODO: handle interpolation
@@ -460,17 +460,21 @@ named_rule!(single_quote_continue<Vec<&'a str>>; match_pest!(
     },
 ));
 
-named!(natural<usize>; with_raw_pair!(pair; {
-    pair.as_str().trim()
-        .parse()
-        .map_err(|e: std::num::ParseIntError| custom_parse_error(&pair, format!("{}", e)))?
-}));
+named!(natural<usize>; match_pest!(
+    raw_pair!(pair) => {
+        pair.as_str().trim()
+            .parse()
+            .map_err(|e: std::num::ParseIntError| custom_parse_error(&pair, format!("{}", e)))?
+    }
+));
 
-named!(integer<isize>; with_raw_pair!(pair; {
-    pair.as_str().trim()
-        .parse()
-        .map_err(|e: std::num::ParseIntError| custom_parse_error(&pair, format!("{}", e)))?
-}));
+named!(integer<isize>; match_pest!(
+    raw_pair!(pair) => {
+        pair.as_str().trim()
+            .parse()
+            .map_err(|e: std::num::ParseIntError| custom_parse_error(&pair, format!("{}", e)))?
+    }
+));
 
 named_rule!(let_binding<(&'a str, Option<BoxExpr<'a>>, BoxExpr<'a>)>;
     match_children!((name: str, annot?: expression, expr: expression) => (name, annot, expr))
@@ -480,16 +484,22 @@ named!(record_entry<(&'a str, BoxExpr<'a>)>;
     match_children!((name: str, expr: expression) => (name, expr))
 );
 
-named!(partial_record_entries<(Rule, BoxExpr<'a>, BTreeMap<&'a str, ParsedExpr<'a>>)>;
-    with_rule!(rule;
-        match_children!((expr: expression, entries*: record_entry) => {
-            let mut map: BTreeMap<&str, ParsedExpr> = BTreeMap::new();
-            for (n, e) in entries {
-                map.insert(n, *e);
-            }
-            (rule, expr, map)
-        })
-    )
+named!(partial_record_entries<(BoxExpr<'a>, BTreeMap<&'a str, ParsedExpr<'a>>)>;
+    match_children!((expr: expression, entries*: record_entry) => {
+        let mut map: BTreeMap<&str, ParsedExpr> = BTreeMap::new();
+        for (n, e) in entries {
+            map.insert(n, *e);
+        }
+        (expr, map)
+    })
+);
+
+named_rule!(non_empty_record_literal<(BoxExpr<'a>, BTreeMap<&'a str, ParsedExpr<'a>>)>;
+    match_pest!(self!(x: partial_record_entries) => x)
+);
+
+named_rule!(non_empty_record_type<(BoxExpr<'a>, BTreeMap<&'a str, ParsedExpr<'a>>)>;
+    match_pest!(self!(x: partial_record_entries) => x)
 );
 
 named_rule!(union_type_entry<(&'a str, BoxExpr<'a>)>;
@@ -541,8 +551,12 @@ named!(expression<BoxExpr<'a>>; match_rule!(
             bx(Expr::TextLit(contents.into_iter().rev().collect()))
         }),
 
-    Rule::natural_literal_raw => map!(natural; |n| bx(Expr::NaturalLit(n))),
-    Rule::integer_literal_raw => map!(integer; |n| bx(Expr::IntegerLit(n))),
+    Rule::natural_literal_raw => match_pest!(
+        self!(n: natural) => bx(Expr::NaturalLit(n))
+    ),
+    Rule::integer_literal_raw => match_pest!(
+        self!(n: integer) => bx(Expr::IntegerLit(n))
+    ),
 
     Rule::identifier_raw =>
         match_children!((name: str, idx?: natural) => {
@@ -622,18 +636,24 @@ named!(expression<BoxExpr<'a>>; match_rule!(
             rest.fold(first, |acc, e| bx(Expr::Field(acc, e)))
         }),
 
-    Rule::empty_record_type => plain_value!(bx(Expr::Record(BTreeMap::new()))),
-    Rule::empty_record_literal => plain_value!(bx(Expr::RecordLit(BTreeMap::new()))),
-    Rule::non_empty_record_type_or_literal =>
-        match_children!((first_label: str, rest: partial_record_entries) => {
-            let (rule, first_expr, mut map) = rest;
+    Rule::empty_record_type => match_pest!(
+        children!() => bx(Expr::Record(BTreeMap::new()))
+    ),
+    Rule::empty_record_literal => match_pest!(
+        children!() => bx(Expr::RecordLit(BTreeMap::new()))
+    ),
+    Rule::non_empty_record_type_or_literal => match_pest!(
+        children!(first_label: str, rest: non_empty_record_type) => {
+            let (first_expr, mut map) = rest;
             map.insert(first_label, *first_expr);
-            match rule {
-                Rule::non_empty_record_type => bx(Expr::Record(map)),
-                Rule::non_empty_record_literal => bx(Expr::RecordLit(map)),
-                _ => unreachable!()
-            }
-        }),
+            bx(Expr::Record(map))
+        },
+        children!(first_label: str, rest: non_empty_record_literal) => {
+            let (first_expr, mut map) = rest;
+            map.insert(first_label, *first_expr);
+            bx(Expr::RecordLit(map))
+        },
+    ),
 
     Rule::union_type_or_literal =>
         match_pest!(
@@ -651,15 +671,6 @@ named!(expression<BoxExpr<'a>>; match_rule!(
         match_children!((items*: expression) => {
             bx(Expr::ListLit(None, items.map(|x| *x).collect()))
         }),
-
-
-    // _ => with_rule!(rule;
-    //     match_children!((exprs*: expression) => {
-    //         let rulename = format!("{:?}", rule);
-    //         // panic!(rulename);
-    //         bx(Expr::FailedParse(rulename, exprs.map(|x| *x).collect()))
-    //     })
-    // ),
 ));
 
 named!(final_expression<BoxExpr<'a>>;