From 2f6f21c52e60c560eb4c5fff9441b7d20c8c1d9a Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 3 Sep 2019 23:01:55 +0200
Subject: Store Spans at every node when parsing

---
 dhall_syntax/src/core/expr.rs | 18 ++++++++++++----
 dhall_syntax/src/parser.rs    | 50 ++++++++++++++++++++++++++++++++-----------
 2 files changed, 51 insertions(+), 17 deletions(-)

diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index 2cb23c9..455e42a 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -37,6 +37,16 @@ impl Span {
             end: sp.end(),
         }
     }
+    /// Takes the union of the two spans. Assumes that the spans come from the same input.
+    /// This will also capture any input between the spans.
+    pub fn union(&self, other: &Span) -> Self {
+        use std::cmp::{max, min};
+        Span {
+            input: self.input.clone(),
+            start: min(self.start, other.start),
+            end: max(self.start, other.start),
+        }
+    }
 }
 
 /// Double with bitwise equality
@@ -324,8 +334,11 @@ impl<E> Expr<E> {
     pub fn as_mut(&mut self) -> &mut RawExpr<E> {
         &mut self.0.as_mut().0
     }
+    pub fn span(&self) -> Option<&Span> {
+        self.0.as_ref().1.as_ref()
+    }
 
-    pub fn new(x: RawExpr<E>, n: Span) -> Self {
+    pub(crate) fn new(x: RawExpr<E>, n: Span) -> Self {
         Expr(Box::new((x, Some(n))))
     }
 
@@ -387,9 +400,6 @@ pub fn rc<E>(x: RawExpr<E>) -> Expr<E> {
 pub(crate) fn spanned<E>(span: Span, x: RawExpr<E>) -> Expr<E> {
     Expr::new(x, span)
 }
-pub(crate) fn unspanned<E>(x: RawExpr<E>) -> Expr<E> {
-    Expr::from_expr_no_span(x)
-}
 
 /// Add an isize to an usize
 /// Panics on over/underflow
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 3f961e8..4cce5ed 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -783,7 +783,12 @@ impl Parsers {
             [let_binding(bindings).., expression(final_expr)] => {
                 bindings.rev().fold(
                     final_expr,
-                    |acc, x| unspanned(Let(x.0, x.1, x.2, acc))
+                    |acc, x| {
+                        spanned(
+                            acc.span().unwrap().union(&x.3),
+                            Let(x.0, x.1, x.2, acc)
+                        )
+                    }
                 )
             },
             [forall(()), label(l), expression(typ),
@@ -811,12 +816,12 @@ impl Parsers {
 
     fn let_binding<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<(Label, Option<Expr<E>>, Expr<E>)> {
+    ) -> ParseResult<(Label, Option<Expr<E>>, Expr<E>, Span)> {
         Ok(parse_children!(input;
             [label(name), expression(annot), expression(expr)] =>
-                (name, Some(annot), expr),
+                (name, Some(annot), expr, input.as_span()),
             [label(name), expression(expr)] =>
-                (name, None, expr),
+                (name, None, expr, input.as_span()),
         ))
     }
 
@@ -847,7 +852,10 @@ impl Parsers {
             r => Err(input.error(format!("Rule {:?} isn't an operator", r)))?,
         };
 
-        Ok(unspanned(BinOp(op, l, r)))
+        Ok(spanned(
+            l.span().unwrap().union(r.span().unwrap()),
+            BinOp(op, l, r),
+        ))
     }
 
     fn Some_(_input: ParseInput<Rule>) -> ParseResult<()> {
@@ -861,7 +869,15 @@ impl Parsers {
         Ok(parse_children!(input;
             [expression(e)] => e,
             [expression(first), expression(rest)..] => {
-                rest.fold(first, |acc, e| unspanned(App(acc, e)))
+                rest.fold(
+                    first,
+                    |acc, e| {
+                        spanned(
+                            acc.span().unwrap().union(e.span().unwrap()),
+                            App(acc, e)
+                        )
+                    }
+                )
             },
         ))
     }
@@ -892,20 +908,28 @@ impl Parsers {
         Ok(parse_children!(input;
             [expression(e)] => e,
             [expression(first), selector(rest)..] => {
-                rest.fold(first, |acc, e| unspanned(match e {
-                    Either::Left(l) => Field(acc, l),
-                    Either::Right(ls) => Projection(acc, ls),
-                }))
+                rest.fold(
+                    first,
+                    |acc, e| {
+                        spanned(
+                            acc.span().unwrap().union(&e.1),
+                            match e.0 {
+                                Either::Left(l) => Field(acc, l),
+                                Either::Right(ls) => Projection(acc, ls),
+                            }
+                        )
+                    }
+                )
             },
         ))
     }
 
     fn selector(
         input: ParseInput<Rule>,
-    ) -> ParseResult<Either<Label, DupTreeSet<Label>>> {
+    ) -> ParseResult<(Either<Label, DupTreeSet<Label>>, Span)> {
         Ok(parse_children!(input;
-            [label(l)] => Either::Left(l),
-            [labels(ls)] => Either::Right(ls),
+            [label(l)] => (Either::Left(l), input.as_span()),
+            [labels(ls)] => (Either::Right(ls), input.as_span()),
             // [expression(_e)] => unimplemented!("selection by expression"), // TODO
         ))
     }
-- 
cgit v1.2.3


From 0388d9858627693bab2433f134eb4ed1d6e9b164 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 6 Sep 2019 18:17:36 +0200
Subject: Make ParseInput independent from dhall-specific types

---
 dhall_proc_macros/src/make_parser.rs    |   8 +-
 dhall_proc_macros/src/parse_children.rs |   6 +-
 dhall_syntax/src/core/expr.rs           |   8 +-
 dhall_syntax/src/parser.rs              | 508 ++++++++++++++++----------------
 4 files changed, 268 insertions(+), 262 deletions(-)

diff --git a/dhall_proc_macros/src/make_parser.rs b/dhall_proc_macros/src/make_parser.rs
index a17ab61..c0594a5 100644
--- a/dhall_proc_macros/src/make_parser.rs
+++ b/dhall_proc_macros/src/make_parser.rs
@@ -179,7 +179,7 @@ fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Ident) -> Result<()> {
             #function
 
             #climber.climb(
-                #input_arg.pair.clone().into_inner(),
+                #input_arg.as_pair().clone().into_inner(),
                 |p| Self::#child_rule(#input_arg.with_pair(p)),
                 |l, op, r| {
                     #fn_name(#input_arg.clone(), l?, op, r?)
@@ -207,9 +207,9 @@ fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Ident) -> Result<()> {
             let mut #input_arg = #input_arg;
             // While the current rule allows shortcutting, and there is a single child, and the
             // child can still be parsed by the current function, then skip to that child.
-            while <Self as PestConsumer>::allows_shortcut(#input_arg.as_rule()) {
+            while <Self as pest_consume::PestConsumer>::allows_shortcut(#input_arg.as_rule()) {
                 if let Some(child) = #input_arg.single_child() {
-                    if &<Self as PestConsumer>::rule_alias(child.as_rule())
+                    if &<Self as pest_consume::PestConsumer>::rule_alias(child.as_rule())
                             == stringify!(#fn_name) {
                         #input_arg = child;
                         continue;
@@ -313,7 +313,7 @@ pub fn make_parser(
     let ty = &imp.self_ty;
     let (impl_generics, _, where_clause) = imp.generics.split_for_impl();
     Ok(quote!(
-        impl #impl_generics PestConsumer for #ty #where_clause {
+        impl #impl_generics pest_consume::PestConsumer for #ty #where_clause {
             type Rule = #rule_enum;
             fn rule_alias(rule: Self::Rule) -> String {
                 match rule {
diff --git a/dhall_proc_macros/src/parse_children.rs b/dhall_proc_macros/src/parse_children.rs
index a35c03f..d6474a7 100644
--- a/dhall_proc_macros/src/parse_children.rs
+++ b/dhall_proc_macros/src/parse_children.rs
@@ -186,11 +186,11 @@ pub fn parse_children(
         .collect::<Result<Vec<_>>>()?;
 
     Ok(quote!({
-        let #i_children_rules: Vec<_> = #input_expr.pair
+        let #i_children_rules: Vec<_> = #input_expr.as_pair()
             .clone()
             .into_inner()
             .map(|p| p.as_rule())
-            .map(<Self as PestConsumer>::rule_alias)
+            .map(<Self as pest_consume::PestConsumer>::rule_alias)
             .collect();
         let #i_children_rules: Vec<&str> = #i_children_rules
             .iter()
@@ -199,7 +199,7 @@ pub fn parse_children(
 
         #[allow(unused_mut)]
         let mut #i_inputs = #input_expr
-            .pair
+            .as_pair()
             .clone()
             .into_inner()
             .map(|p| #input_expr.with_pair(p));
diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index 455e42a..74b481f 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -334,8 +334,8 @@ impl<E> Expr<E> {
     pub fn as_mut(&mut self) -> &mut RawExpr<E> {
         &mut self.0.as_mut().0
     }
-    pub fn span(&self) -> Option<&Span> {
-        self.0.as_ref().1.as_ref()
+    pub fn span(&self) -> Option<Span> {
+        self.0.as_ref().1.clone()
     }
 
     pub(crate) fn new(x: RawExpr<E>, n: Span) -> Self {
@@ -397,10 +397,6 @@ pub fn rc<E>(x: RawExpr<E>) -> Expr<E> {
     Expr::from_expr_no_span(x)
 }
 
-pub(crate) fn spanned<E>(span: Span, x: RawExpr<E>) -> Expr<E> {
-    Expr::new(x, span)
-}
-
 /// Add an isize to an usize
 /// Panics on over/underflow
 fn add_ui(u: usize, i: isize) -> Option<usize> {
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 4cce5ed..c8b3fe6 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -3,7 +3,6 @@ use pest::iterators::Pair;
 use pest::prec_climber as pcl;
 use pest::prec_climber::PrecClimber;
 use pest::Parser;
-use std::borrow::Cow;
 use std::rc::Rc;
 
 use dhall_generated_parser::{DhallParser, Rule};
@@ -25,110 +24,133 @@ pub type ParseError = pest::error::Error<Rule>;
 
 pub type ParseResult<T> = Result<T, ParseError>;
 
-#[derive(Debug, Clone)]
-struct ParseInput<'input, Rule>
-where
-    Rule: pest::RuleType,
-{
-    pair: Pair<'input, Rule>,
-    original_input_str: Rc<str>,
-}
-
-impl<'input> ParseInput<'input, Rule> {
-    fn error(&self, message: String) -> ParseError {
-        let message = format!(
-            "{} while matching on:\n{}",
-            message,
-            debug_pair(self.pair.clone())
-        );
-        let e = pest::error::ErrorVariant::CustomError { message };
-        pest::error::Error::new_from_span(e, self.pair.as_span())
-    }
-    fn parse(input_str: &'input str, rule: Rule) -> ParseResult<Self> {
-        let mut pairs = DhallParser::parse(rule, input_str)?;
-        // TODO: proper errors
-        let pair = pairs.next().unwrap();
-        assert_eq!(pairs.next(), None);
-        Ok(ParseInput {
-            original_input_str: input_str.to_string().into(),
-            pair,
-        })
-    }
-    fn with_pair(&self, new_pair: Pair<'input, Rule>) -> Self {
-        ParseInput {
-            pair: new_pair,
-            original_input_str: self.original_input_str.clone(),
+pub mod pest_consume {
+    use pest::error::{Error, ErrorVariant};
+    use pest::iterators::Pair;
+    use pest::Span;
+
+    /// Carries a pest Pair alongside custom user data.
+    #[derive(Debug, Clone)]
+    pub struct ParseInput<'input, 'data, Rule, Data>
+    where
+        Rule: pest::RuleType,
+    {
+        pair: Pair<'input, Rule>,
+        user_data: &'data Data,
+    }
+
+    impl<'input, 'data, Rule, Data> ParseInput<'input, 'data, Rule, Data>
+    where
+        Rule: pest::RuleType,
+    {
+        pub fn new(pair: Pair<'input, Rule>, user_data: &'data Data) -> Self {
+            ParseInput { pair, user_data }
         }
-    }
-    /// If the contained pair has exactly one child, return a new Self containing it.
-    fn single_child(&self) -> Option<Self> {
-        let mut children = self.pair.clone().into_inner();
-        if let Some(child) = children.next() {
-            if children.next().is_none() {
-                return Some(self.with_pair(child));
+        /// Create an error that points to the span of the input.
+        pub fn error(&self, message: String) -> Error<Rule> {
+            let message = format!(
+                "{} while matching on:\n{}",
+                message,
+                debug_pair(self.pair.clone())
+            );
+            Error::new_from_span(
+                ErrorVariant::CustomError { message },
+                self.as_span(),
+            )
+        }
+        /// Reconstruct the input with a new pair, passing the user data along.
+        pub fn with_pair(&self, new_pair: Pair<'input, Rule>) -> Self {
+            ParseInput {
+                pair: new_pair,
+                user_data: self.user_data,
             }
         }
-        None
-    }
-    fn as_span(&self) -> Span {
-        Span::make(self.original_input_str.clone(), self.pair.as_span())
-    }
-    fn as_str(&self) -> &'input str {
-        self.pair.as_str()
-    }
-    fn as_rule(&self) -> Rule {
-        self.pair.as_rule()
-    }
-}
+        /// If the contained pair has exactly one child, return a new Self containing it.
+        pub fn single_child(&self) -> Option<Self> {
+            let mut children = self.pair.clone().into_inner();
+            if let Some(child) = children.next() {
+                if children.next().is_none() {
+                    return Some(self.with_pair(child));
+                }
+            }
+            None
+        }
 
-// Used by the macros.
-trait PestConsumer {
-    type Rule: pest::RuleType;
-    fn rule_alias(rule: Self::Rule) -> String;
-    fn allows_shortcut(rule: Self::Rule) -> bool;
-}
+        pub fn user_data(&self) -> &'data Data {
+            self.user_data
+        }
+        pub fn as_pair(&self) -> &Pair<'input, Rule> {
+            &self.pair
+        }
+        pub fn as_span(&self) -> Span<'input> {
+            self.pair.as_span()
+        }
+        pub fn as_str(&self) -> &'input str {
+            self.pair.as_str()
+        }
+        pub fn as_rule(&self) -> Rule {
+            self.pair.as_rule()
+        }
+    }
 
-fn debug_pair(pair: Pair<Rule>) -> String {
-    use std::fmt::Write;
-    let mut s = String::new();
-    fn aux(s: &mut String, indent: usize, prefix: String, pair: Pair<Rule>) {
-        let indent_str = "| ".repeat(indent);
-        let rule = pair.as_rule();
-        let contents = pair.as_str();
-        let mut inner = pair.into_inner();
-        let mut first = true;
-        while let Some(p) = inner.next() {
-            if first {
-                first = false;
-                let last = inner.peek().is_none();
-                if last && p.as_str() == contents {
-                    let prefix = format!("{}{:?} > ", prefix, rule);
-                    aux(s, indent, prefix, p);
-                    continue;
-                } else {
-                    writeln!(
-                        s,
-                        r#"{}{}{:?}: "{}""#,
-                        indent_str, prefix, rule, contents
-                    )
-                    .unwrap();
+    /// Used by the macros.
+    pub trait PestConsumer {
+        type Rule: pest::RuleType;
+        fn rule_alias(rule: Self::Rule) -> String;
+        fn allows_shortcut(rule: Self::Rule) -> bool;
+    }
+
+    /// Pretty-print a pair and its nested children.
+    fn debug_pair<Rule: pest::RuleType>(pair: Pair<Rule>) -> String {
+        use std::fmt::Write;
+        let mut s = String::new();
+        fn aux<Rule: pest::RuleType>(
+            s: &mut String,
+            indent: usize,
+            prefix: String,
+            pair: Pair<Rule>,
+        ) {
+            let indent_str = "| ".repeat(indent);
+            let rule = pair.as_rule();
+            let contents = pair.as_str();
+            let mut inner = pair.into_inner();
+            let mut first = true;
+            while let Some(p) = inner.next() {
+                if first {
+                    first = false;
+                    let last = inner.peek().is_none();
+                    if last && p.as_str() == contents {
+                        let prefix = format!("{}{:?} > ", prefix, rule);
+                        aux(s, indent, prefix, p);
+                        continue;
+                    } else {
+                        writeln!(
+                            s,
+                            r#"{}{}{:?}: "{}""#,
+                            indent_str, prefix, rule, contents
+                        )
+                        .unwrap();
+                    }
                 }
+                aux(s, indent + 1, "".into(), p);
+            }
+            if first {
+                writeln!(
+                    s,
+                    r#"{}{}{:?}: "{}""#,
+                    indent_str, prefix, rule, contents
+                )
+                .unwrap();
             }
-            aux(s, indent + 1, "".into(), p);
-        }
-        if first {
-            writeln!(
-                s,
-                r#"{}{}{:?}: "{}""#,
-                indent_str, prefix, rule, contents
-            )
-            .unwrap();
         }
+        aux(&mut s, 0, "".into(), pair);
+        s
     }
-    aux(&mut s, 0, "".into(), pair);
-    s
 }
 
+type ParseInput<'input, 'data> =
+    pest_consume::ParseInput<'input, 'data, Rule, Rc<str>>;
+
 #[derive(Debug)]
 enum Either<A, B> {
     Left(A),
@@ -173,6 +195,16 @@ impl crate::Builtin {
     }
 }
 
+fn input_to_span(input: ParseInput) -> Span {
+    Span::make(input.user_data().clone(), input.as_pair().as_span())
+}
+fn spanned<E>(input: ParseInput, x: RawExpr<E>) -> Expr<E> {
+    Expr::new(x, input_to_span(input))
+}
+fn spanned_union<E>(span1: Span, span2: Span, x: RawExpr<E>) -> Expr<E> {
+    Expr::new(x, span1.union(&span2))
+}
+
 // Trim the shared indent off of a vec of lines, as defined by the Dhall semantics of multiline
 // literals.
 fn trim_indent<E: Clone>(lines: &mut Vec<ParsedText<E>>) {
@@ -246,21 +278,21 @@ struct Parsers;
 
 #[make_parser(Rule)]
 impl Parsers {
-    fn EOI(_input: ParseInput<Rule>) -> ParseResult<()> {
+    fn EOI(_input: ParseInput) -> ParseResult<()> {
         Ok(())
     }
 
     #[alias(label)]
-    fn simple_label(input: ParseInput<Rule>) -> ParseResult<Label> {
+    fn simple_label(input: ParseInput) -> ParseResult<Label> {
         Ok(Label::from(input.as_str()))
     }
     #[alias(label)]
-    fn quoted_label(input: ParseInput<Rule>) -> ParseResult<Label> {
+    fn quoted_label(input: ParseInput) -> ParseResult<Label> {
         Ok(Label::from(input.as_str()))
     }
 
     fn double_quote_literal<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<ParsedText<E>> {
         Ok(parse_children!(input;
             [double_quote_chunk(chunks)..] => {
@@ -270,7 +302,7 @@ impl Parsers {
     }
 
     fn double_quote_chunk<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<ParsedTextContents<E>> {
         Ok(parse_children!(input;
             [expression(e)] => {
@@ -282,7 +314,7 @@ impl Parsers {
         ))
     }
     #[alias(double_quote_char)]
-    fn double_quote_escaped(input: ParseInput<Rule>) -> ParseResult<String> {
+    fn double_quote_escaped(input: ParseInput) -> ParseResult<String> {
         Ok(match input.as_str() {
             "\"" => "\"".to_owned(),
             "$" => "$".to_owned(),
@@ -352,14 +384,12 @@ impl Parsers {
             }
         })
     }
-    fn double_quote_char<'a>(
-        input: ParseInput<'a, Rule>,
-    ) -> ParseResult<String> {
+    fn double_quote_char(input: ParseInput) -> ParseResult<String> {
         Ok(input.as_str().to_owned())
     }
 
     fn single_quote_literal<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<ParsedText<E>> {
         Ok(parse_children!(input;
             [single_quote_continue(lines)] => {
@@ -383,26 +413,26 @@ impl Parsers {
         ))
     }
     fn single_quote_char<'a>(
-        input: ParseInput<'a, Rule>,
+        input: ParseInput<'a, '_>,
     ) -> ParseResult<&'a str> {
         Ok(input.as_str())
     }
     #[alias(single_quote_char)]
     fn escaped_quote_pair<'a>(
-        _input: ParseInput<'a, Rule>,
+        _input: ParseInput<'a, '_>,
     ) -> ParseResult<&'a str> {
         Ok("''")
     }
     #[alias(single_quote_char)]
     fn escaped_interpolation<'a>(
-        _input: ParseInput<'a, Rule>,
+        _input: ParseInput<'a, '_>,
     ) -> ParseResult<&'a str> {
         Ok("${")
     }
 
     // Returns a vec of lines in reversed order, where each line is also in reversed order.
     fn single_quote_continue<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<Vec<Vec<ParsedTextContents<E>>>> {
         Ok(parse_children!(input;
             [expression(e), single_quote_continue(lines)] => {
@@ -429,7 +459,7 @@ impl Parsers {
     }
 
     #[alias(expression)]
-    fn builtin<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
+    fn builtin<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
         let s = input.as_str();
         let e = match crate::Builtin::parse(s) {
             Some(b) => Builtin(b),
@@ -442,30 +472,24 @@ impl Parsers {
                 _ => Err(input.error(format!("Unrecognized builtin: '{}'", s)))?,
             },
         };
-        Ok(spanned(input.as_span(), e))
+        Ok(spanned(input, e))
     }
 
     #[alias(double_literal)]
-    fn NaN(_input: ParseInput<Rule>) -> ParseResult<core::Double> {
+    fn NaN(_input: ParseInput) -> ParseResult<core::Double> {
         Ok(std::f64::NAN.into())
     }
     #[alias(double_literal)]
-    fn minus_infinity_literal(
-        _input: ParseInput<Rule>,
-    ) -> ParseResult<core::Double> {
+    fn minus_infinity_literal(_input: ParseInput) -> ParseResult<core::Double> {
         Ok(std::f64::NEG_INFINITY.into())
     }
     #[alias(double_literal)]
-    fn plus_infinity_literal(
-        _input: ParseInput<Rule>,
-    ) -> ParseResult<core::Double> {
+    fn plus_infinity_literal(_input: ParseInput) -> ParseResult<core::Double> {
         Ok(std::f64::INFINITY.into())
     }
 
     #[alias(double_literal)]
-    fn numeric_double_literal(
-        input: ParseInput<Rule>,
-    ) -> ParseResult<core::Double> {
+    fn numeric_double_literal(input: ParseInput) -> ParseResult<core::Double> {
         let s = input.as_str().trim();
         match s.parse::<f64>() {
             Ok(x) if x.is_infinite() => Err(input.error(format!(
@@ -477,7 +501,7 @@ impl Parsers {
         }
     }
 
-    fn natural_literal(input: ParseInput<Rule>) -> ParseResult<core::Natural> {
+    fn natural_literal(input: ParseInput) -> ParseResult<core::Natural> {
         input
             .as_str()
             .trim()
@@ -485,7 +509,7 @@ impl Parsers {
             .map_err(|e| input.error(format!("{}", e)))
     }
 
-    fn integer_literal(input: ParseInput<Rule>) -> ParseResult<core::Integer> {
+    fn integer_literal(input: ParseInput) -> ParseResult<core::Integer> {
         input
             .as_str()
             .trim()
@@ -494,16 +518,16 @@ impl Parsers {
     }
 
     #[alias(expression, shortcut = true)]
-    fn identifier<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
+    fn identifier<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
         Ok(parse_children!(input;
             [variable(v)] => {
-                spanned(input.as_span(), Var(v))
+                spanned(input, Var(v))
             },
             [expression(e)] => e,
         ))
     }
 
-    fn variable(input: ParseInput<Rule>) -> ParseResult<V<Label>> {
+    fn variable(input: ParseInput) -> ParseResult<V<Label>> {
         Ok(parse_children!(input;
             [label(l), natural_literal(idx)] => {
                 V(l, idx)
@@ -515,15 +539,11 @@ impl Parsers {
     }
 
     #[alias(path_component)]
-    fn unquoted_path_component<'a>(
-        input: ParseInput<'a, Rule>,
-    ) -> ParseResult<String> {
+    fn unquoted_path_component(input: ParseInput) -> ParseResult<String> {
         Ok(input.as_str().to_string())
     }
     #[alias(path_component)]
-    fn quoted_path_component<'a>(
-        input: ParseInput<'a, Rule>,
-    ) -> ParseResult<String> {
+    fn quoted_path_component(input: ParseInput) -> ParseResult<String> {
         #[rustfmt::skip]
         const RESERVED: &percent_encoding::AsciiSet =
             &percent_encoding::CONTROLS
@@ -549,7 +569,7 @@ impl Parsers {
             })
             .collect())
     }
-    fn path(input: ParseInput<Rule>) -> ParseResult<Vec<String>> {
+    fn path(input: ParseInput) -> ParseResult<Vec<String>> {
         Ok(parse_children!(input;
             [path_component(components)..] => {
                 components.collect()
@@ -559,7 +579,7 @@ impl Parsers {
 
     #[alias(import_type)]
     fn local<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
         Ok(parse_children!(input;
             [local_path((prefix, p))] => ImportLocation::Local(prefix, p),
@@ -568,38 +588,34 @@ impl Parsers {
 
     #[alias(local_path)]
     fn parent_path(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<(FilePrefix, Vec<String>)> {
         Ok(parse_children!(input;
             [path(p)] => (FilePrefix::Parent, p)
         ))
     }
     #[alias(local_path)]
-    fn here_path(
-        input: ParseInput<Rule>,
-    ) -> ParseResult<(FilePrefix, Vec<String>)> {
+    fn here_path(input: ParseInput) -> ParseResult<(FilePrefix, Vec<String>)> {
         Ok(parse_children!(input;
             [path(p)] => (FilePrefix::Here, p)
         ))
     }
     #[alias(local_path)]
-    fn home_path(
-        input: ParseInput<Rule>,
-    ) -> ParseResult<(FilePrefix, Vec<String>)> {
+    fn home_path(input: ParseInput) -> ParseResult<(FilePrefix, Vec<String>)> {
         Ok(parse_children!(input;
             [path(p)] => (FilePrefix::Home, p)
         ))
     }
     #[alias(local_path)]
     fn absolute_path(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<(FilePrefix, Vec<String>)> {
         Ok(parse_children!(input;
             [path(p)] => (FilePrefix::Absolute, p)
         ))
     }
 
-    fn scheme(input: ParseInput<Rule>) -> ParseResult<Scheme> {
+    fn scheme(input: ParseInput) -> ParseResult<Scheme> {
         Ok(match input.as_str() {
             "http" => Scheme::HTTP,
             "https" => Scheme::HTTPS,
@@ -607,9 +623,7 @@ impl Parsers {
         })
     }
 
-    fn http_raw<E: Clone>(
-        input: ParseInput<Rule>,
-    ) -> ParseResult<URL<Expr<E>>> {
+    fn http_raw<E: Clone>(input: ParseInput) -> ParseResult<URL<Expr<E>>> {
         Ok(parse_children!(input;
             [scheme(sch), authority(auth), path(p)] => URL {
                 scheme: sch,
@@ -628,17 +642,17 @@ impl Parsers {
         ))
     }
 
-    fn authority(input: ParseInput<Rule>) -> ParseResult<String> {
+    fn authority(input: ParseInput) -> ParseResult<String> {
         Ok(input.as_str().to_owned())
     }
 
-    fn query(input: ParseInput<Rule>) -> ParseResult<String> {
+    fn query(input: ParseInput) -> ParseResult<String> {
         Ok(input.as_str().to_owned())
     }
 
     #[alias(import_type)]
     fn http<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
         Ok(ImportLocation::Remote(parse_children!(input;
             [http_raw(url)] => url,
@@ -648,22 +662,18 @@ impl Parsers {
 
     #[alias(import_type)]
     fn env<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
         Ok(parse_children!(input;
             [environment_variable(v)] => ImportLocation::Env(v),
         ))
     }
     #[alias(environment_variable)]
-    fn bash_environment_variable(
-        input: ParseInput<Rule>,
-    ) -> ParseResult<String> {
+    fn bash_environment_variable(input: ParseInput) -> ParseResult<String> {
         Ok(input.as_str().to_owned())
     }
     #[alias(environment_variable)]
-    fn posix_environment_variable(
-        input: ParseInput<Rule>,
-    ) -> ParseResult<String> {
+    fn posix_environment_variable(input: ParseInput) -> ParseResult<String> {
         Ok(parse_children!(input;
             [posix_environment_variable_character(chars)..] => {
                 chars.collect()
@@ -671,30 +681,30 @@ impl Parsers {
         ))
     }
     fn posix_environment_variable_character<'a>(
-        input: ParseInput<'a, Rule>,
-    ) -> ParseResult<Cow<'a, str>> {
+        input: ParseInput<'a, '_>,
+    ) -> ParseResult<&'a str> {
         Ok(match input.as_str() {
-            "\\\"" => Cow::Owned("\"".to_owned()),
-            "\\\\" => Cow::Owned("\\".to_owned()),
-            "\\a" => Cow::Owned("\u{0007}".to_owned()),
-            "\\b" => Cow::Owned("\u{0008}".to_owned()),
-            "\\f" => Cow::Owned("\u{000C}".to_owned()),
-            "\\n" => Cow::Owned("\n".to_owned()),
-            "\\r" => Cow::Owned("\r".to_owned()),
-            "\\t" => Cow::Owned("\t".to_owned()),
-            "\\v" => Cow::Owned("\u{000B}".to_owned()),
-            s => Cow::Borrowed(s),
+            "\\\"" => "\"",
+            "\\\\" => "\\",
+            "\\a" => "\u{0007}",
+            "\\b" => "\u{0008}",
+            "\\f" => "\u{000C}",
+            "\\n" => "\n",
+            "\\r" => "\r",
+            "\\t" => "\t",
+            "\\v" => "\u{000B}",
+            s => s,
         })
     }
 
     #[alias(import_type)]
     fn missing<E: Clone>(
-        _input: ParseInput<Rule>,
+        _input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
         Ok(ImportLocation::Missing)
     }
 
-    fn hash(input: ParseInput<Rule>) -> ParseResult<Hash> {
+    fn hash(input: ParseInput) -> ParseResult<Hash> {
         let s = input.as_str().trim();
         let protocol = &s[..6];
         let hash = &s[7..];
@@ -705,7 +715,7 @@ impl Parsers {
     }
 
     fn import_hashed<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<crate::Import<Expr<E>>> {
         use crate::Import;
         let mode = ImportMode::Code;
@@ -716,16 +726,16 @@ impl Parsers {
     }
 
     #[alias(import_mode)]
-    fn Text(_input: ParseInput<Rule>) -> ParseResult<ImportMode> {
+    fn Text(_input: ParseInput) -> ParseResult<ImportMode> {
         Ok(ImportMode::RawText)
     }
     #[alias(import_mode)]
-    fn Location(_input: ParseInput<Rule>) -> ParseResult<ImportMode> {
+    fn Location(_input: ParseInput) -> ParseResult<ImportMode> {
         Ok(ImportMode::Location)
     }
 
     #[alias(expression)]
-    fn import<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
+    fn import<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
         use crate::Import;
         let import = parse_children!(input;
             [import_hashed(imp)] => {
@@ -735,57 +745,55 @@ impl Parsers {
                 Import { mode, ..imp }
             },
         );
-        Ok(spanned(input.as_span(), Import(import)))
+        Ok(spanned(input, Import(import)))
     }
 
-    fn lambda(_input: ParseInput<Rule>) -> ParseResult<()> {
+    fn lambda(_input: ParseInput) -> ParseResult<()> {
         Ok(())
     }
-    fn forall(_input: ParseInput<Rule>) -> ParseResult<()> {
+    fn forall(_input: ParseInput) -> ParseResult<()> {
         Ok(())
     }
-    fn arrow(_input: ParseInput<Rule>) -> ParseResult<()> {
+    fn arrow(_input: ParseInput) -> ParseResult<()> {
         Ok(())
     }
-    fn merge(_input: ParseInput<Rule>) -> ParseResult<()> {
+    fn merge(_input: ParseInput) -> ParseResult<()> {
         Ok(())
     }
-    fn assert(_input: ParseInput<Rule>) -> ParseResult<()> {
+    fn assert(_input: ParseInput) -> ParseResult<()> {
         Ok(())
     }
-    fn if_(_input: ParseInput<Rule>) -> ParseResult<()> {
+    fn if_(_input: ParseInput) -> ParseResult<()> {
         Ok(())
     }
-    fn toMap(_input: ParseInput<Rule>) -> ParseResult<()> {
+    fn toMap(_input: ParseInput) -> ParseResult<()> {
         Ok(())
     }
 
     #[alias(expression)]
-    fn empty_list_literal<E: Clone>(
-        input: ParseInput<Rule>,
-    ) -> ParseResult<Expr<E>> {
+    fn empty_list_literal<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
         Ok(parse_children!(input;
-            [expression(e)] => spanned(input.as_span(), EmptyListLit(e)),
+            [expression(e)] => spanned(input, EmptyListLit(e)),
         ))
     }
 
-    fn expression<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
-        let span = input.as_span();
+    fn expression<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
         Ok(parse_children!(input;
             [lambda(()), label(l), expression(typ),
                     arrow(()), expression(body)] => {
-                spanned(span, Lam(l, typ, body))
+                spanned(input, Lam(l, typ, body))
             },
             [if_(()), expression(cond), expression(left),
                     expression(right)] => {
-                spanned(span, BoolIf(cond, left, right))
+                spanned(input, BoolIf(cond, left, right))
             },
             [let_binding(bindings).., expression(final_expr)] => {
                 bindings.rev().fold(
                     final_expr,
                     |acc, x| {
-                        spanned(
-                            acc.span().unwrap().union(&x.3),
+                        spanned_union(
+                            acc.span().unwrap(),
+                            x.3,
                             Let(x.0, x.1, x.2, acc)
                         )
                     }
@@ -793,42 +801,42 @@ impl Parsers {
             },
             [forall(()), label(l), expression(typ),
                     arrow(()), expression(body)] => {
-                spanned(span, Pi(l, typ, body))
+                spanned(input, Pi(l, typ, body))
             },
             [expression(typ), arrow(()), expression(body)] => {
-                spanned(span, Pi("_".into(), typ, body))
+                spanned(input, Pi("_".into(), typ, body))
             },
             [merge(()), expression(x), expression(y), expression(z)] => {
-                spanned(span, Merge(x, y, Some(z)))
+                spanned(input, Merge(x, y, Some(z)))
             },
             [assert(()), expression(x)] => {
-                spanned(span, Assert(x))
+                spanned(input, Assert(x))
             },
             [toMap(()), expression(x), expression(y)] => {
-                spanned(span, ToMap(x, Some(y)))
+                spanned(input, ToMap(x, Some(y)))
             },
             [expression(e), expression(annot)] => {
-                spanned(span, Annot(e, annot))
+                spanned(input, Annot(e, annot))
             },
             [expression(e)] => e,
         ))
     }
 
     fn let_binding<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<(Label, Option<Expr<E>>, Expr<E>, Span)> {
         Ok(parse_children!(input;
             [label(name), expression(annot), expression(expr)] =>
-                (name, Some(annot), expr, input.as_span()),
+                (name, Some(annot), expr, input_to_span(input)),
             [label(name), expression(expr)] =>
-                (name, None, expr, input.as_span()),
+                (name, None, expr, input_to_span(input)),
         ))
     }
 
     #[alias(expression, shortcut = true)]
     #[prec_climb(expression, PRECCLIMBER)]
     fn operator_expression<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
         l: Expr<E>,
         op: Pair<Rule>,
         r: Expr<E>,
@@ -852,19 +860,20 @@ impl Parsers {
             r => Err(input.error(format!("Rule {:?} isn't an operator", r)))?,
         };
 
-        Ok(spanned(
-            l.span().unwrap().union(r.span().unwrap()),
+        Ok(spanned_union(
+            l.span().unwrap(),
+            r.span().unwrap(),
             BinOp(op, l, r),
         ))
     }
 
-    fn Some_(_input: ParseInput<Rule>) -> ParseResult<()> {
+    fn Some_(_input: ParseInput) -> ParseResult<()> {
         Ok(())
     }
 
     #[alias(expression, shortcut = true)]
     fn application_expression<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<Expr<E>> {
         Ok(parse_children!(input;
             [expression(e)] => e,
@@ -872,8 +881,9 @@ impl Parsers {
                 rest.fold(
                     first,
                     |acc, e| {
-                        spanned(
-                            acc.span().unwrap().union(e.span().unwrap()),
+                        spanned_union(
+                            acc.span().unwrap(),
+                            e.span().unwrap(),
                             App(acc, e)
                         )
                     }
@@ -884,18 +894,17 @@ impl Parsers {
 
     #[alias(expression, shortcut = true)]
     fn first_application_expression<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        let span = input.as_span();
         Ok(parse_children!(input;
             [Some_(()), expression(e)] => {
-                spanned(span, SomeLit(e))
+                spanned(input, SomeLit(e))
             },
             [merge(()), expression(x), expression(y)] => {
-                spanned(span, Merge(x, y, None))
+                spanned(input, Merge(x, y, None))
             },
             [toMap(()), expression(x)] => {
-                spanned(span, ToMap(x, None))
+                spanned(input, ToMap(x, None))
             },
             [expression(e)] => e,
         ))
@@ -903,7 +912,7 @@ impl Parsers {
 
     #[alias(expression, shortcut = true)]
     fn selector_expression<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<Expr<E>> {
         Ok(parse_children!(input;
             [expression(e)] => e,
@@ -911,8 +920,9 @@ impl Parsers {
                 rest.fold(
                     first,
                     |acc, e| {
-                        spanned(
-                            acc.span().unwrap().union(&e.1),
+                        spanned_union(
+                            acc.span().unwrap(),
+                            e.1,
                             match e.0 {
                                 Either::Left(l) => Field(acc, l),
                                 Either::Right(ls) => Projection(acc, ls),
@@ -925,16 +935,16 @@ impl Parsers {
     }
 
     fn selector(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<(Either<Label, DupTreeSet<Label>>, Span)> {
         Ok(parse_children!(input;
-            [label(l)] => (Either::Left(l), input.as_span()),
-            [labels(ls)] => (Either::Right(ls), input.as_span()),
+            [label(l)] => (Either::Left(l), input_to_span(input)),
+            [labels(ls)] => (Either::Right(ls), input_to_span(input)),
             // [expression(_e)] => unimplemented!("selection by expression"), // TODO
         ))
     }
 
-    fn labels(input: ParseInput<Rule>) -> ParseResult<DupTreeSet<Label>> {
+    fn labels(input: ParseInput) -> ParseResult<DupTreeSet<Label>> {
         Ok(parse_children!(input;
             [label(ls)..] => ls.collect(),
         ))
@@ -942,36 +952,33 @@ impl Parsers {
 
     #[alias(expression, shortcut = true)]
     fn primitive_expression<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        let span = input.as_span();
         Ok(parse_children!(input;
-            [double_literal(n)] => spanned(span, DoubleLit(n)),
-            [natural_literal(n)] => spanned(span, NaturalLit(n)),
-            [integer_literal(n)] => spanned(span, IntegerLit(n)),
-            [double_quote_literal(s)] => spanned(span, TextLit(s)),
-            [single_quote_literal(s)] => spanned(span, TextLit(s)),
+            [double_literal(n)] => spanned(input, DoubleLit(n)),
+            [natural_literal(n)] => spanned(input, NaturalLit(n)),
+            [integer_literal(n)] => spanned(input, IntegerLit(n)),
+            [double_quote_literal(s)] => spanned(input, TextLit(s)),
+            [single_quote_literal(s)] => spanned(input, TextLit(s)),
             [expression(e)] => e,
         ))
     }
 
     #[alias(expression)]
     fn empty_record_literal<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(spanned(input.as_span(), RecordLit(Default::default())))
+        Ok(spanned(input, RecordLit(Default::default())))
     }
 
     #[alias(expression)]
-    fn empty_record_type<E: Clone>(
-        input: ParseInput<Rule>,
-    ) -> ParseResult<Expr<E>> {
-        Ok(spanned(input.as_span(), RecordType(Default::default())))
+    fn empty_record_type<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
+        Ok(spanned(input, RecordType(Default::default())))
     }
 
     #[alias(expression)]
     fn non_empty_record_type_or_literal<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<Expr<E>> {
         let e = parse_children!(input;
             [label(first_label), non_empty_record_type(rest)] => {
@@ -985,11 +992,11 @@ impl Parsers {
                 RecordLit(map)
             },
         );
-        Ok(spanned(input.as_span(), e))
+        Ok(spanned(input, e))
     }
 
     fn non_empty_record_type<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<(Expr<E>, DupTreeMap<Label, Expr<E>>)> {
         Ok(parse_children!(input;
             [expression(expr), record_type_entry(entries)..] => {
@@ -999,7 +1006,7 @@ impl Parsers {
     }
 
     fn record_type_entry<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<(Label, Expr<E>)> {
         Ok(parse_children!(input;
             [label(name), expression(expr)] => (name, expr)
@@ -1007,7 +1014,7 @@ impl Parsers {
     }
 
     fn non_empty_record_literal<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<(Expr<E>, DupTreeMap<Label, Expr<E>>)> {
         Ok(parse_children!(input;
             [expression(expr), record_literal_entry(entries)..] => {
@@ -1017,7 +1024,7 @@ impl Parsers {
     }
 
     fn record_literal_entry<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<(Label, Expr<E>)> {
         Ok(parse_children!(input;
             [label(name), expression(expr)] => (name, expr)
@@ -1025,20 +1032,20 @@ impl Parsers {
     }
 
     #[alias(expression)]
-    fn union_type<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
+    fn union_type<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
         let map = parse_children!(input;
             [empty_union_type(_)] => Default::default(),
             [union_type_entry(entries)..] => entries.collect(),
         );
-        Ok(spanned(input.as_span(), UnionType(map)))
+        Ok(spanned(input, UnionType(map)))
     }
 
-    fn empty_union_type(_input: ParseInput<Rule>) -> ParseResult<()> {
+    fn empty_union_type(_input: ParseInput) -> ParseResult<()> {
         Ok(())
     }
 
     fn union_type_entry<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<(Label, Option<Expr<E>>)> {
         Ok(parse_children!(input;
             [label(name), expression(expr)] => (name, Some(expr)),
@@ -1048,26 +1055,29 @@ impl Parsers {
 
     #[alias(expression)]
     fn non_empty_list_literal<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<Expr<E>> {
         Ok(parse_children!(input;
             [expression(items)..] => spanned(
-                input.as_span(),
+                input,
                 NEListLit(items.collect())
             )
         ))
     }
 
-    fn final_expression<E: Clone>(
-        input: ParseInput<Rule>,
-    ) -> ParseResult<Expr<E>> {
+    fn final_expression<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
         Ok(parse_children!(input;
             [expression(e), EOI(_)] => e
         ))
     }
 }
 
-pub fn parse_expr<E: Clone>(s: &str) -> ParseResult<Expr<E>> {
-    let input = ParseInput::parse(s, Rule::final_expression)?;
+pub fn parse_expr<E: Clone>(input_str: &str) -> ParseResult<Expr<E>> {
+    let mut pairs = DhallParser::parse(Rule::final_expression, input_str)?;
+    // TODO: proper errors
+    let pair = pairs.next().unwrap();
+    assert_eq!(pairs.next(), None);
+    let rc_input_str = input_str.to_string().into();
+    let input = ParseInput::new(pair, &rc_input_str);
     Parsers::final_expression(input)
 }
-- 
cgit v1.2.3


From 595a52018e31126ecbf1be49794750f1a59a66b1 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 9 Sep 2019 22:24:27 +0200
Subject: Move pest_consume into its own crate

---
 Cargo.lock                 |   9 ++++
 Cargo.toml                 |   1 +
 dhall_syntax/Cargo.toml    |   1 +
 dhall_syntax/src/parser.rs | 132 ++-------------------------------------------
 pest_consume/Cargo.toml    |  13 +++++
 pest_consume/src/lib.rs    | 123 ++++++++++++++++++++++++++++++++++++++++++
 6 files changed, 150 insertions(+), 129 deletions(-)
 create mode 100644 pest_consume/Cargo.toml
 create mode 100644 pest_consume/src/lib.rs

diff --git a/Cargo.lock b/Cargo.lock
index d5ce864..b9ca159 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -117,6 +117,7 @@ dependencies = [
  "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "percent-encoding 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "pest 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pest_consume 0.1.0",
  "take_mut 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
@@ -237,6 +238,14 @@ dependencies = [
  "ucd-trie 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "pest_consume"
+version = "0.1.0"
+dependencies = [
+ "dhall_proc_macros 0.1.0",
+ "pest 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "pest_generator"
 version = "2.1.1"
diff --git a/Cargo.toml b/Cargo.toml
index 1e40748..b26b5c2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,6 +8,7 @@ members = [
     "dhall_syntax",
     "dhall_proc_macros",
     "improved_slice_patterns",
+    "pest_consume",
     "serde_dhall"
 ]
 
diff --git a/dhall_syntax/Cargo.toml b/dhall_syntax/Cargo.toml
index eb492d0..450175c 100644
--- a/dhall_syntax/Cargo.toml
+++ b/dhall_syntax/Cargo.toml
@@ -18,3 +18,4 @@ hex = "0.3.2"
 lazy_static = "1.4.0"
 dhall_generated_parser = { path = "../dhall_generated_parser" }
 dhall_proc_macros = { path = "../dhall_proc_macros" }
+pest_consume = { path = "../pest_consume" }
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index c8b3fe6..6c47de4 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -6,7 +6,7 @@ use pest::Parser;
 use std::rc::Rc;
 
 use dhall_generated_parser::{DhallParser, Rule};
-use dhall_proc_macros::{make_parser, parse_children};
+use pest_consume::{make_parser, parse_children};
 
 use crate::map::{DupTreeMap, DupTreeSet};
 use crate::ExprF::*;
@@ -19,138 +19,12 @@ use crate::*;
 
 type ParsedText<E> = InterpolatedText<Expr<E>>;
 type ParsedTextContents<E> = InterpolatedTextContents<Expr<E>>;
+type ParseInput<'input, 'data> =
+    pest_consume::ParseInput<'input, 'data, Rule, Rc<str>>;
 
 pub type ParseError = pest::error::Error<Rule>;
-
 pub type ParseResult<T> = Result<T, ParseError>;
 
-pub mod pest_consume {
-    use pest::error::{Error, ErrorVariant};
-    use pest::iterators::Pair;
-    use pest::Span;
-
-    /// Carries a pest Pair alongside custom user data.
-    #[derive(Debug, Clone)]
-    pub struct ParseInput<'input, 'data, Rule, Data>
-    where
-        Rule: pest::RuleType,
-    {
-        pair: Pair<'input, Rule>,
-        user_data: &'data Data,
-    }
-
-    impl<'input, 'data, Rule, Data> ParseInput<'input, 'data, Rule, Data>
-    where
-        Rule: pest::RuleType,
-    {
-        pub fn new(pair: Pair<'input, Rule>, user_data: &'data Data) -> Self {
-            ParseInput { pair, user_data }
-        }
-        /// Create an error that points to the span of the input.
-        pub fn error(&self, message: String) -> Error<Rule> {
-            let message = format!(
-                "{} while matching on:\n{}",
-                message,
-                debug_pair(self.pair.clone())
-            );
-            Error::new_from_span(
-                ErrorVariant::CustomError { message },
-                self.as_span(),
-            )
-        }
-        /// Reconstruct the input with a new pair, passing the user data along.
-        pub fn with_pair(&self, new_pair: Pair<'input, Rule>) -> Self {
-            ParseInput {
-                pair: new_pair,
-                user_data: self.user_data,
-            }
-        }
-        /// If the contained pair has exactly one child, return a new Self containing it.
-        pub fn single_child(&self) -> Option<Self> {
-            let mut children = self.pair.clone().into_inner();
-            if let Some(child) = children.next() {
-                if children.next().is_none() {
-                    return Some(self.with_pair(child));
-                }
-            }
-            None
-        }
-
-        pub fn user_data(&self) -> &'data Data {
-            self.user_data
-        }
-        pub fn as_pair(&self) -> &Pair<'input, Rule> {
-            &self.pair
-        }
-        pub fn as_span(&self) -> Span<'input> {
-            self.pair.as_span()
-        }
-        pub fn as_str(&self) -> &'input str {
-            self.pair.as_str()
-        }
-        pub fn as_rule(&self) -> Rule {
-            self.pair.as_rule()
-        }
-    }
-
-    /// Used by the macros.
-    pub trait PestConsumer {
-        type Rule: pest::RuleType;
-        fn rule_alias(rule: Self::Rule) -> String;
-        fn allows_shortcut(rule: Self::Rule) -> bool;
-    }
-
-    /// Pretty-print a pair and its nested children.
-    fn debug_pair<Rule: pest::RuleType>(pair: Pair<Rule>) -> String {
-        use std::fmt::Write;
-        let mut s = String::new();
-        fn aux<Rule: pest::RuleType>(
-            s: &mut String,
-            indent: usize,
-            prefix: String,
-            pair: Pair<Rule>,
-        ) {
-            let indent_str = "| ".repeat(indent);
-            let rule = pair.as_rule();
-            let contents = pair.as_str();
-            let mut inner = pair.into_inner();
-            let mut first = true;
-            while let Some(p) = inner.next() {
-                if first {
-                    first = false;
-                    let last = inner.peek().is_none();
-                    if last && p.as_str() == contents {
-                        let prefix = format!("{}{:?} > ", prefix, rule);
-                        aux(s, indent, prefix, p);
-                        continue;
-                    } else {
-                        writeln!(
-                            s,
-                            r#"{}{}{:?}: "{}""#,
-                            indent_str, prefix, rule, contents
-                        )
-                        .unwrap();
-                    }
-                }
-                aux(s, indent + 1, "".into(), p);
-            }
-            if first {
-                writeln!(
-                    s,
-                    r#"{}{}{:?}: "{}""#,
-                    indent_str, prefix, rule, contents
-                )
-                .unwrap();
-            }
-        }
-        aux(&mut s, 0, "".into(), pair);
-        s
-    }
-}
-
-type ParseInput<'input, 'data> =
-    pest_consume::ParseInput<'input, 'data, Rule, Rc<str>>;
-
 #[derive(Debug)]
 enum Either<A, B> {
     Left(A),
diff --git a/pest_consume/Cargo.toml b/pest_consume/Cargo.toml
new file mode 100644
index 0000000..b3f1db7
--- /dev/null
+++ b/pest_consume/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "pest_consume"
+version = "0.1.0"  # remember to update html_root_url
+authors = ["Nadrieril <nadrieril@users.noreply.github.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2018"
+description = "A framework for processing the output of a pest-generated parser"
+readme = "README.md"
+repository = "https://github.com/Nadrieril/dhall-rust"
+
+[dependencies]
+pest = "2.1"
+dhall_proc_macros = { path = "../dhall_proc_macros" }
diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
new file mode 100644
index 0000000..1cedc74
--- /dev/null
+++ b/pest_consume/src/lib.rs
@@ -0,0 +1,123 @@
+use pest::error::{Error, ErrorVariant};
+use pest::iterators::Pair;
+use pest::Span;
+
+pub use dhall_proc_macros::{make_parser, parse_children};
+
+/// Carries a pest Pair alongside custom user data.
+#[derive(Debug, Clone)]
+pub struct ParseInput<'input, 'data, Rule, Data>
+where
+    Rule: pest::RuleType,
+{
+    pair: Pair<'input, Rule>,
+    user_data: &'data Data,
+}
+
+impl<'input, 'data, Rule, Data> ParseInput<'input, 'data, Rule, Data>
+where
+    Rule: pest::RuleType,
+{
+    pub fn new(pair: Pair<'input, Rule>, user_data: &'data Data) -> Self {
+        ParseInput { pair, user_data }
+    }
+    /// Create an error that points to the span of the input.
+    pub fn error(&self, message: String) -> Error<Rule> {
+        let message = format!(
+            "{} while matching on:\n{}",
+            message,
+            debug_pair(self.pair.clone())
+        );
+        Error::new_from_span(
+            ErrorVariant::CustomError { message },
+            self.as_span(),
+        )
+    }
+    /// Reconstruct the input with a new pair, passing the user data along.
+    pub fn with_pair(&self, new_pair: Pair<'input, Rule>) -> Self {
+        ParseInput {
+            pair: new_pair,
+            user_data: self.user_data,
+        }
+    }
+    /// If the contained pair has exactly one child, return a new Self containing it.
+    pub fn single_child(&self) -> Option<Self> {
+        let mut children = self.pair.clone().into_inner();
+        if let Some(child) = children.next() {
+            if children.next().is_none() {
+                return Some(self.with_pair(child));
+            }
+        }
+        None
+    }
+
+    pub fn user_data(&self) -> &'data Data {
+        self.user_data
+    }
+    pub fn as_pair(&self) -> &Pair<'input, Rule> {
+        &self.pair
+    }
+    pub fn as_span(&self) -> Span<'input> {
+        self.pair.as_span()
+    }
+    pub fn as_str(&self) -> &'input str {
+        self.pair.as_str()
+    }
+    pub fn as_rule(&self) -> Rule {
+        self.pair.as_rule()
+    }
+}
+
+/// Used by the macros.
+pub trait PestConsumer {
+    type Rule: pest::RuleType;
+    fn rule_alias(rule: Self::Rule) -> String;
+    fn allows_shortcut(rule: Self::Rule) -> bool;
+}
+
+/// Pretty-print a pair and its nested children.
+fn debug_pair<Rule: pest::RuleType>(pair: Pair<Rule>) -> String {
+    use std::fmt::Write;
+    let mut s = String::new();
+    fn aux<Rule: pest::RuleType>(
+        s: &mut String,
+        indent: usize,
+        prefix: String,
+        pair: Pair<Rule>,
+    ) {
+        let indent_str = "| ".repeat(indent);
+        let rule = pair.as_rule();
+        let contents = pair.as_str();
+        let mut inner = pair.into_inner();
+        let mut first = true;
+        while let Some(p) = inner.next() {
+            if first {
+                first = false;
+                let last = inner.peek().is_none();
+                if last && p.as_str() == contents {
+                    let prefix = format!("{}{:?} > ", prefix, rule);
+                    aux(s, indent, prefix, p);
+                    continue;
+                } else {
+                    writeln!(
+                        s,
+                        r#"{}{}{:?}: "{}""#,
+                        indent_str, prefix, rule, contents
+                    )
+                    .unwrap();
+                }
+            }
+            aux(s, indent + 1, "".into(), p);
+        }
+        if first {
+            writeln!(
+                s,
+                r#"{}{}{:?}: "{}""#,
+                indent_str, prefix, rule, contents
+            )
+            .unwrap();
+        }
+    }
+    aux(&mut s, 0, "".into(), pair);
+    s
+}
-- 
cgit v1.2.3


From accaf45aa77099654f94319ed1fb12855dd568b4 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 9 Sep 2019 22:42:46 +0200
Subject: Move pest_consume macros into their own crate

---
 Cargo.lock                                |  11 +-
 Cargo.toml                                |   1 +
 dhall_proc_macros/src/lib.rs              |  19 --
 dhall_proc_macros/src/make_parser.rs      | 334 ------------------------------
 dhall_proc_macros/src/parse_children.rs   | 215 -------------------
 pest_consume/Cargo.toml                   |   2 +-
 pest_consume/src/lib.rs                   |   2 +-
 pest_consume_macros/Cargo.toml            |  18 ++
 pest_consume_macros/src/lib.rs            |  28 +++
 pest_consume_macros/src/make_parser.rs    | 334 ++++++++++++++++++++++++++++++
 pest_consume_macros/src/parse_children.rs | 215 +++++++++++++++++++
 11 files changed, 608 insertions(+), 571 deletions(-)
 delete mode 100644 dhall_proc_macros/src/make_parser.rs
 delete mode 100644 dhall_proc_macros/src/parse_children.rs
 create mode 100644 pest_consume_macros/Cargo.toml
 create mode 100644 pest_consume_macros/src/lib.rs
 create mode 100644 pest_consume_macros/src/make_parser.rs
 create mode 100644 pest_consume_macros/src/parse_children.rs

diff --git a/Cargo.lock b/Cargo.lock
index b9ca159..dd650ff 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -242,8 +242,17 @@ dependencies = [
 name = "pest_consume"
 version = "0.1.0"
 dependencies = [
- "dhall_proc_macros 0.1.0",
  "pest 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pest_consume_macros 0.1.0",
+]
+
+[[package]]
+name = "pest_consume_macros"
+version = "0.1.0"
+dependencies = [
+ "proc-macro2 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index b26b5c2..ec6a760 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,6 +9,7 @@ members = [
     "dhall_proc_macros",
     "improved_slice_patterns",
     "pest_consume",
+    "pest_consume_macros",
     "serde_dhall"
 ]
 
diff --git a/dhall_proc_macros/src/lib.rs b/dhall_proc_macros/src/lib.rs
index 37e8f9f..5304429 100644
--- a/dhall_proc_macros/src/lib.rs
+++ b/dhall_proc_macros/src/lib.rs
@@ -1,4 +1,3 @@
-#![feature(drain_filter)]
 //! This crate contains the code-generation primitives for the [dhall-rust][dhall-rust] crate.
 //! This is highly unstable and breaks regularly; use at your own risk.
 //!
@@ -7,8 +6,6 @@
 extern crate proc_macro;
 
 mod derive;
-mod make_parser;
-mod parse_children;
 
 use proc_macro::TokenStream;
 
@@ -16,19 +13,3 @@ use proc_macro::TokenStream;
 pub fn derive_static_type(input: TokenStream) -> TokenStream {
     derive::derive_static_type(input)
 }
-
-#[proc_macro_attribute]
-pub fn make_parser(attrs: TokenStream, input: TokenStream) -> TokenStream {
-    TokenStream::from(match make_parser::make_parser(attrs, input) {
-        Ok(tokens) => tokens,
-        Err(err) => err.to_compile_error(),
-    })
-}
-
-#[proc_macro]
-pub fn parse_children(input: TokenStream) -> TokenStream {
-    TokenStream::from(match parse_children::parse_children(input) {
-        Ok(tokens) => tokens,
-        Err(err) => err.to_compile_error(),
-    })
-}
diff --git a/dhall_proc_macros/src/make_parser.rs b/dhall_proc_macros/src/make_parser.rs
deleted file mode 100644
index c0594a5..0000000
--- a/dhall_proc_macros/src/make_parser.rs
+++ /dev/null
@@ -1,334 +0,0 @@
-use std::collections::HashMap;
-use std::iter;
-
-use quote::quote;
-use syn::parse::{Parse, ParseStream, Result};
-use syn::spanned::Spanned;
-use syn::{
-    parse_quote, Error, Expr, FnArg, Ident, ImplItem, ImplItemMethod, ItemImpl,
-    LitBool, Pat, Token,
-};
-
-mod kw {
-    syn::custom_keyword!(shortcut);
-}
-
-struct AliasArgs {
-    target: Ident,
-    is_shortcut: bool,
-}
-
-struct PrecClimbArgs {
-    child_rule: Ident,
-    climber: Expr,
-}
-
-struct AliasSrc {
-    ident: Ident,
-    is_shortcut: bool,
-}
-
-struct ParsedFn<'a> {
-    // Body of the function
-    function: &'a mut ImplItemMethod,
-    // Name of the function.
-    fn_name: Ident,
-    // Name of the first argument of the function, which should be of type `ParseInput`.
-    input_arg: Ident,
-    // List of aliases pointing to this function
-    alias_srcs: Vec<AliasSrc>,
-}
-
-impl Parse for AliasArgs {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let target = input.parse()?;
-        let is_shortcut = if input.peek(Token![,]) {
-            // #[alias(rule, shortcut = true)]
-            let _: Token![,] = input.parse()?;
-            let _: kw::shortcut = input.parse()?;
-            let _: Token![=] = input.parse()?;
-            let b: LitBool = input.parse()?;
-            b.value
-        } else {
-            // #[alias(rule)]
-            false
-        };
-        Ok(AliasArgs {
-            target,
-            is_shortcut,
-        })
-    }
-}
-
-impl Parse for PrecClimbArgs {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let child_rule = input.parse()?;
-        let _: Token![,] = input.parse()?;
-        let climber = input.parse()?;
-        Ok(PrecClimbArgs {
-            child_rule,
-            climber,
-        })
-    }
-}
-
-fn collect_aliases(
-    imp: &mut ItemImpl,
-) -> Result<HashMap<Ident, Vec<AliasSrc>>> {
-    let functions = imp.items.iter_mut().flat_map(|item| match item {
-        ImplItem::Method(m) => Some(m),
-        _ => None,
-    });
-
-    let mut alias_map = HashMap::new();
-    for function in functions {
-        let fn_name = function.sig.ident.clone();
-        let mut alias_attrs = function
-            .attrs
-            .drain_filter(|attr| attr.path.is_ident("alias"))
-            .collect::<Vec<_>>()
-            .into_iter();
-
-        if let Some(attr) = alias_attrs.next() {
-            let args: AliasArgs = attr.parse_args()?;
-            alias_map.entry(args.target).or_insert_with(Vec::new).push(
-                AliasSrc {
-                    ident: fn_name,
-                    is_shortcut: args.is_shortcut,
-                },
-            );
-        }
-        if let Some(attr) = alias_attrs.next() {
-            return Err(Error::new(
-                attr.span(),
-                "expected at most one alias attribute",
-            ));
-        }
-    }
-
-    Ok(alias_map)
-}
-
-fn parse_fn<'a>(
-    function: &'a mut ImplItemMethod,
-    alias_map: &mut HashMap<Ident, Vec<AliasSrc>>,
-) -> Result<ParsedFn<'a>> {
-    let fn_name = function.sig.ident.clone();
-    // Get the name of the first (`input`) function argument
-    let input_arg = function.sig.inputs.first().ok_or_else(|| {
-        Error::new(
-            function.sig.inputs.span(),
-            "a rule function needs an `input` argument",
-        )
-    })?;
-    let input_arg = match &input_arg {
-        FnArg::Receiver(_) => return Err(Error::new(
-            input_arg.span(),
-            "a rule function should not have a `self` argument",
-        )),
-        FnArg::Typed(input_arg) => match &*input_arg.pat{
-            Pat::Ident(ident) => ident.ident.clone(),
-            _ => return Err(Error::new(
-                input_arg.span(),
-                "this argument should be a plain identifier instead of a pattern",
-            )),
-        }
-    };
-
-    let alias_srcs = alias_map.remove(&fn_name).unwrap_or_else(Vec::new);
-
-    Ok(ParsedFn {
-        function,
-        fn_name,
-        input_arg,
-        alias_srcs,
-    })
-}
-
-fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Ident) -> Result<()> {
-    let function = &mut *f.function;
-    let fn_name = &f.fn_name;
-    let input_arg = &f.input_arg;
-
-    *function = parse_quote!(
-        #[allow(non_snake_case)]
-        #function
-    );
-
-    // `prec_climb` attr
-    let prec_climb_attrs: Vec<_> = function
-        .attrs
-        .drain_filter(|attr| attr.path.is_ident("prec_climb"))
-        .collect();
-
-    if prec_climb_attrs.len() > 1 {
-        return Err(Error::new(
-            prec_climb_attrs[1].span(),
-            "expected at most one prec_climb attribute",
-        ));
-    } else if prec_climb_attrs.is_empty() {
-        // do nothing
-    } else {
-        let attr = prec_climb_attrs.into_iter().next().unwrap();
-        let PrecClimbArgs {
-            child_rule,
-            climber,
-        } = attr.parse_args()?;
-
-        function.block = parse_quote!({
-            #function
-
-            #climber.climb(
-                #input_arg.as_pair().clone().into_inner(),
-                |p| Self::#child_rule(#input_arg.with_pair(p)),
-                |l, op, r| {
-                    #fn_name(#input_arg.clone(), l?, op, r?)
-                },
-            )
-        });
-        // Remove the 3 last arguments to keep only the `input` one
-        function.sig.inputs.pop();
-        function.sig.inputs.pop();
-        function.sig.inputs.pop();
-        // Check that an argument remains
-        function.sig.inputs.first().ok_or_else(|| {
-            Error::new(
-                function.sig.inputs.span(),
-                "a prec_climb function needs 4 arguments",
-            )
-        })?;
-    }
-
-    // `alias` attr
-    if !f.alias_srcs.is_empty() {
-        let aliases = f.alias_srcs.iter().map(|src| &src.ident);
-        let block = &function.block;
-        function.block = parse_quote!({
-            let mut #input_arg = #input_arg;
-            // While the current rule allows shortcutting, and there is a single child, and the
-            // child can still be parsed by the current function, then skip to that child.
-            while <Self as pest_consume::PestConsumer>::allows_shortcut(#input_arg.as_rule()) {
-                if let Some(child) = #input_arg.single_child() {
-                    if &<Self as pest_consume::PestConsumer>::rule_alias(child.as_rule())
-                            == stringify!(#fn_name) {
-                        #input_arg = child;
-                        continue;
-                    }
-                }
-                break
-            }
-
-            match #input_arg.as_rule() {
-                #(#rule_enum::#aliases => Self::#aliases(#input_arg),)*
-                #rule_enum::#fn_name => #block,
-                r => unreachable!(
-                    "make_parser: called {} on {:?}",
-                    stringify!(#fn_name),
-                    r
-                )
-            }
-        });
-    }
-
-    Ok(())
-}
-
-pub fn make_parser(
-    attrs: proc_macro::TokenStream,
-    input: proc_macro::TokenStream,
-) -> Result<proc_macro2::TokenStream> {
-    let rule_enum: Ident = syn::parse(attrs)?;
-    let mut imp: ItemImpl = syn::parse(input)?;
-
-    let mut alias_map = collect_aliases(&mut imp)?;
-    let rule_alias_branches: Vec<_> = alias_map
-        .iter()
-        .flat_map(|(tgt, srcs)| iter::repeat(tgt).zip(srcs))
-        .map(|(tgt, src)| {
-            let ident = &src.ident;
-            quote!(
-                #rule_enum::#ident => stringify!(#tgt).to_string(),
-            )
-        })
-        .collect();
-    let shortcut_branches: Vec<_> = alias_map
-        .iter()
-        .flat_map(|(_tgt, srcs)| srcs)
-        .map(|AliasSrc { ident, is_shortcut }| {
-            quote!(
-                #rule_enum::#ident => #is_shortcut,
-            )
-        })
-        .collect();
-
-    let fn_map: HashMap<Ident, ParsedFn> = imp
-        .items
-        .iter_mut()
-        .flat_map(|item| match item {
-            ImplItem::Method(m) => Some(m),
-            _ => None,
-        })
-        .map(|method| {
-            let mut f = parse_fn(method, &mut alias_map)?;
-            apply_special_attrs(&mut f, &rule_enum)?;
-            Ok((f.fn_name.clone(), f))
-        })
-        .collect::<Result<_>>()?;
-
-    // Entries that remain in the alias map don't have a matching method, so we create one.
-    let extra_fns: Vec<_> = alias_map
-        .iter()
-        .map(|(tgt, srcs)| {
-            // Get the signature of one of the functions that has this alias. They should all have
-            // essentially the same signature anyways.
-            let f = fn_map.get(&srcs.first().unwrap().ident).unwrap();
-            let input_arg = f.input_arg.clone();
-            let mut sig = f.function.sig.clone();
-            sig.ident = tgt.clone();
-            let srcs = srcs.iter().map(|src| &src.ident);
-
-            Ok(parse_quote!(
-                #sig {
-                    match #input_arg.as_rule() {
-                        #(#rule_enum::#srcs => Self::#srcs(#input_arg),)*
-                        // We can't match on #rule_enum::#tgt since `tgt` might be an arbitrary
-                        // identifier.
-                        r if &format!("{:?}", r) == stringify!(#tgt) =>
-                            return Err(#input_arg.error(format!(
-                                "make_parser: missing method for rule {}",
-                                stringify!(#tgt),
-                            ))),
-                        r => unreachable!(
-                            "make_parser: called {} on {:?}",
-                            stringify!(#tgt),
-                            r
-                        )
-                    }
-                }
-            ))
-        })
-        .collect::<Result<_>>()?;
-    imp.items.extend(extra_fns);
-
-    let ty = &imp.self_ty;
-    let (impl_generics, _, where_clause) = imp.generics.split_for_impl();
-    Ok(quote!(
-        impl #impl_generics pest_consume::PestConsumer for #ty #where_clause {
-            type Rule = #rule_enum;
-            fn rule_alias(rule: Self::Rule) -> String {
-                match rule {
-                    #(#rule_alias_branches)*
-                    r => format!("{:?}", r),
-                }
-            }
-            fn allows_shortcut(rule: Self::Rule) -> bool {
-                match rule {
-                    #(#shortcut_branches)*
-                    _ => false,
-                }
-            }
-        }
-
-        #imp
-    ))
-}
diff --git a/dhall_proc_macros/src/parse_children.rs b/dhall_proc_macros/src/parse_children.rs
deleted file mode 100644
index d6474a7..0000000
--- a/dhall_proc_macros/src/parse_children.rs
+++ /dev/null
@@ -1,215 +0,0 @@
-use proc_macro2::{Span, TokenStream};
-use quote::quote;
-use syn::parse::{Parse, ParseStream, Result};
-use syn::punctuated::Punctuated;
-use syn::spanned::Spanned;
-use syn::{bracketed, parenthesized, token, Error, Expr, Ident, Pat, Token};
-
-#[derive(Debug, Clone)]
-struct ChildrenBranch {
-    pattern_span: Span,
-    pattern: Punctuated<ChildrenBranchPatternItem, Token![,]>,
-    body: Expr,
-}
-
-#[derive(Debug, Clone)]
-enum ChildrenBranchPatternItem {
-    Single { rule_name: Ident, binder: Pat },
-    Multiple { rule_name: Ident, binder: Ident },
-}
-
-#[derive(Debug, Clone)]
-struct ParseChildrenInput {
-    input_expr: Expr,
-    branches: Punctuated<ChildrenBranch, Token![,]>,
-}
-
-impl Parse for ChildrenBranch {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let contents;
-        let _: token::Bracket = bracketed!(contents in input);
-        let pattern_unparsed: TokenStream = contents.fork().parse()?;
-        let pattern_span = pattern_unparsed.span();
-        let pattern = Punctuated::parse_terminated(&contents)?;
-        let _: Token![=>] = input.parse()?;
-        let body = input.parse()?;
-
-        Ok(ChildrenBranch {
-            pattern_span,
-            pattern,
-            body,
-        })
-    }
-}
-
-impl Parse for ChildrenBranchPatternItem {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let contents;
-        let rule_name = input.parse()?;
-        parenthesized!(contents in input);
-        if input.peek(Token![..]) {
-            let binder = contents.parse()?;
-            let _: Token![..] = input.parse()?;
-            Ok(ChildrenBranchPatternItem::Multiple { rule_name, binder })
-        } else if input.is_empty() || input.peek(Token![,]) {
-            let binder = contents.parse()?;
-            Ok(ChildrenBranchPatternItem::Single { rule_name, binder })
-        } else {
-            Err(input.error("expected `..` or nothing"))
-        }
-    }
-}
-
-impl Parse for ParseChildrenInput {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let input_expr = input.parse()?;
-        let _: Token![;] = input.parse()?;
-        let branches = Punctuated::parse_terminated(input)?;
-
-        Ok(ParseChildrenInput {
-            input_expr,
-            branches,
-        })
-    }
-}
-
-fn make_parser_branch(
-    branch: &ChildrenBranch,
-    i_inputs: &Ident,
-) -> Result<TokenStream> {
-    use ChildrenBranchPatternItem::{Multiple, Single};
-
-    let body = &branch.body;
-
-    // Convert the input pattern into a pattern-match on the Rules of the children. This uses
-    // slice_patterns.
-    // A single pattern just checks that the rule matches; a variable-length pattern binds the
-    // subslice and checks, in the if-guard, that its elements all match the chosen Rule.
-    let i_variable_pattern =
-        Ident::new("___variable_pattern", Span::call_site());
-    let match_pat = branch.pattern.iter().map(|item| match item {
-        Single { rule_name, .. } => quote!(stringify!(#rule_name)),
-        Multiple { .. } => quote!(#i_variable_pattern @ ..),
-    });
-    let match_filter = branch.pattern.iter().map(|item| match item {
-        Single { .. } => quote!(),
-        Multiple { rule_name, .. } => quote!(
-            {
-                // We can't use .all() directly in the pattern guard; see
-                // https://github.com/rust-lang/rust/issues/59803.
-                let all_match = |slice: &[_]| {
-                    slice.iter().all(|r|
-                        *r == stringify!(#rule_name)
-                    )
-                };
-                all_match(#i_variable_pattern)
-            } &&
-        ),
-    });
-
-    // Once we have found a branch that matches, we need to parse the children.
-    let mut singles_before_multiple = Vec::new();
-    let mut multiple = None;
-    let mut singles_after_multiple = Vec::new();
-    for item in &branch.pattern {
-        match item {
-            Single {
-                rule_name, binder, ..
-            } => {
-                if multiple.is_none() {
-                    singles_before_multiple.push((rule_name, binder))
-                } else {
-                    singles_after_multiple.push((rule_name, binder))
-                }
-            }
-            Multiple {
-                rule_name, binder, ..
-            } => {
-                if multiple.is_none() {
-                    multiple = Some((rule_name, binder))
-                } else {
-                    return Err(Error::new(
-                        branch.pattern_span.clone(),
-                        "multiple variable-length patterns are not allowed",
-                    ));
-                }
-            }
-        }
-    }
-    let mut parses = Vec::new();
-    for (rule_name, binder) in singles_before_multiple.into_iter() {
-        parses.push(quote!(
-            let #binder = Self::#rule_name(
-                #i_inputs.next().unwrap()
-            )?;
-        ))
-    }
-    // Note the `rev()`: we are taking inputs from the end of the iterator in reverse order, so that
-    // only the unmatched inputs are left for the variable-length pattern, if any.
-    for (rule_name, binder) in singles_after_multiple.into_iter().rev() {
-        parses.push(quote!(
-            let #binder = Self::#rule_name(
-                #i_inputs.next_back().unwrap()
-            )?;
-        ))
-    }
-    if let Some((rule_name, binder)) = multiple {
-        parses.push(quote!(
-            let #binder = #i_inputs
-                .map(|i| Self::#rule_name(i))
-                .collect::<Result<Vec<_>, _>>()?
-                .into_iter();
-        ))
-    }
-
-    Ok(quote!(
-        [#(#match_pat),*] if #(#match_filter)* true => {
-            #(#parses)*
-            #body
-        }
-    ))
-}
-
-pub fn parse_children(
-    input: proc_macro::TokenStream,
-) -> Result<proc_macro2::TokenStream> {
-    let input: ParseChildrenInput = syn::parse(input)?;
-
-    let i_children_rules = Ident::new("___children_rules", Span::call_site());
-    let i_inputs = Ident::new("___inputs", Span::call_site());
-
-    let input_expr = &input.input_expr;
-    let branches = input
-        .branches
-        .iter()
-        .map(|br| make_parser_branch(br, &i_inputs))
-        .collect::<Result<Vec<_>>>()?;
-
-    Ok(quote!({
-        let #i_children_rules: Vec<_> = #input_expr.as_pair()
-            .clone()
-            .into_inner()
-            .map(|p| p.as_rule())
-            .map(<Self as pest_consume::PestConsumer>::rule_alias)
-            .collect();
-        let #i_children_rules: Vec<&str> = #i_children_rules
-            .iter()
-            .map(String::as_str)
-            .collect();
-
-        #[allow(unused_mut)]
-        let mut #i_inputs = #input_expr
-            .as_pair()
-            .clone()
-            .into_inner()
-            .map(|p| #input_expr.with_pair(p));
-
-        #[allow(unreachable_code)]
-        match #i_children_rules.as_slice() {
-            #(#branches,)*
-            [..] => return Err(#input_expr.error(
-                format!("Unexpected children: {:?}", #i_children_rules)
-            )),
-        }
-    }))
-}
diff --git a/pest_consume/Cargo.toml b/pest_consume/Cargo.toml
index b3f1db7..7b26d56 100644
--- a/pest_consume/Cargo.toml
+++ b/pest_consume/Cargo.toml
@@ -10,4 +10,4 @@ repository = "https://github.com/Nadrieril/dhall-rust"
 
 [dependencies]
 pest = "2.1"
-dhall_proc_macros = { path = "../dhall_proc_macros" }
+pest_consume_macros = { path = "../pest_consume_macros" }
diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index 1cedc74..6e4b2e3 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -2,7 +2,7 @@ use pest::error::{Error, ErrorVariant};
 use pest::iterators::Pair;
 use pest::Span;
 
-pub use dhall_proc_macros::{make_parser, parse_children};
+pub use pest_consume_macros::{make_parser, parse_children};
 
 /// Carries a pest Pair alongside custom user data.
 #[derive(Debug, Clone)]
diff --git a/pest_consume_macros/Cargo.toml b/pest_consume_macros/Cargo.toml
new file mode 100644
index 0000000..dd65d95
--- /dev/null
+++ b/pest_consume_macros/Cargo.toml
@@ -0,0 +1,18 @@
+[package]
+name = "pest_consume_macros"
+version = "0.1.0"  # remember to update html_root_url
+authors = ["Nadrieril <nadrieril@users.noreply.github.com>"]
+license = "MIT OR Apache-2.0"
+edition = "2018"
+description = "Macros for pest_consume"
+readme = "README.md"
+repository = "https://github.com/Nadrieril/dhall-rust"
+
+[lib]
+proc-macro = true
+doctest = false
+
+[dependencies]
+quote = "1.0.2"
+proc-macro2 = "1.0.2"
+syn = { version = "1.0.5", features = ["full", "extra-traits"] }
diff --git a/pest_consume_macros/src/lib.rs b/pest_consume_macros/src/lib.rs
new file mode 100644
index 0000000..dd437f6
--- /dev/null
+++ b/pest_consume_macros/src/lib.rs
@@ -0,0 +1,28 @@
+#![feature(drain_filter)]
+//! This crate contains the code-generation primitives for the [dhall-rust][dhall-rust] crate.
+//! This is highly unstable and breaks regularly; use at your own risk.
+//!
+//! [dhall-rust]: https://github.com/Nadrieril/dhall-rust
+
+extern crate proc_macro;
+
+mod make_parser;
+mod parse_children;
+
+use proc_macro::TokenStream;
+
+#[proc_macro_attribute]
+pub fn make_parser(attrs: TokenStream, input: TokenStream) -> TokenStream {
+    TokenStream::from(match make_parser::make_parser(attrs, input) {
+        Ok(tokens) => tokens,
+        Err(err) => err.to_compile_error(),
+    })
+}
+
+#[proc_macro]
+pub fn parse_children(input: TokenStream) -> TokenStream {
+    TokenStream::from(match parse_children::parse_children(input) {
+        Ok(tokens) => tokens,
+        Err(err) => err.to_compile_error(),
+    })
+}
diff --git a/pest_consume_macros/src/make_parser.rs b/pest_consume_macros/src/make_parser.rs
new file mode 100644
index 0000000..c0594a5
--- /dev/null
+++ b/pest_consume_macros/src/make_parser.rs
@@ -0,0 +1,334 @@
+use std::collections::HashMap;
+use std::iter;
+
+use quote::quote;
+use syn::parse::{Parse, ParseStream, Result};
+use syn::spanned::Spanned;
+use syn::{
+    parse_quote, Error, Expr, FnArg, Ident, ImplItem, ImplItemMethod, ItemImpl,
+    LitBool, Pat, Token,
+};
+
+mod kw {
+    syn::custom_keyword!(shortcut);
+}
+
+struct AliasArgs {
+    target: Ident,
+    is_shortcut: bool,
+}
+
+struct PrecClimbArgs {
+    child_rule: Ident,
+    climber: Expr,
+}
+
+struct AliasSrc {
+    ident: Ident,
+    is_shortcut: bool,
+}
+
+struct ParsedFn<'a> {
+    // Body of the function
+    function: &'a mut ImplItemMethod,
+    // Name of the function.
+    fn_name: Ident,
+    // Name of the first argument of the function, which should be of type `ParseInput`.
+    input_arg: Ident,
+    // List of aliases pointing to this function
+    alias_srcs: Vec<AliasSrc>,
+}
+
+impl Parse for AliasArgs {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let target = input.parse()?;
+        let is_shortcut = if input.peek(Token![,]) {
+            // #[alias(rule, shortcut = true)]
+            let _: Token![,] = input.parse()?;
+            let _: kw::shortcut = input.parse()?;
+            let _: Token![=] = input.parse()?;
+            let b: LitBool = input.parse()?;
+            b.value
+        } else {
+            // #[alias(rule)]
+            false
+        };
+        Ok(AliasArgs {
+            target,
+            is_shortcut,
+        })
+    }
+}
+
+impl Parse for PrecClimbArgs {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let child_rule = input.parse()?;
+        let _: Token![,] = input.parse()?;
+        let climber = input.parse()?;
+        Ok(PrecClimbArgs {
+            child_rule,
+            climber,
+        })
+    }
+}
+
+fn collect_aliases(
+    imp: &mut ItemImpl,
+) -> Result<HashMap<Ident, Vec<AliasSrc>>> {
+    let functions = imp.items.iter_mut().flat_map(|item| match item {
+        ImplItem::Method(m) => Some(m),
+        _ => None,
+    });
+
+    let mut alias_map = HashMap::new();
+    for function in functions {
+        let fn_name = function.sig.ident.clone();
+        let mut alias_attrs = function
+            .attrs
+            .drain_filter(|attr| attr.path.is_ident("alias"))
+            .collect::<Vec<_>>()
+            .into_iter();
+
+        if let Some(attr) = alias_attrs.next() {
+            let args: AliasArgs = attr.parse_args()?;
+            alias_map.entry(args.target).or_insert_with(Vec::new).push(
+                AliasSrc {
+                    ident: fn_name,
+                    is_shortcut: args.is_shortcut,
+                },
+            );
+        }
+        if let Some(attr) = alias_attrs.next() {
+            return Err(Error::new(
+                attr.span(),
+                "expected at most one alias attribute",
+            ));
+        }
+    }
+
+    Ok(alias_map)
+}
+
+fn parse_fn<'a>(
+    function: &'a mut ImplItemMethod,
+    alias_map: &mut HashMap<Ident, Vec<AliasSrc>>,
+) -> Result<ParsedFn<'a>> {
+    let fn_name = function.sig.ident.clone();
+    // Get the name of the first (`input`) function argument
+    let input_arg = function.sig.inputs.first().ok_or_else(|| {
+        Error::new(
+            function.sig.inputs.span(),
+            "a rule function needs an `input` argument",
+        )
+    })?;
+    let input_arg = match &input_arg {
+        FnArg::Receiver(_) => return Err(Error::new(
+            input_arg.span(),
+            "a rule function should not have a `self` argument",
+        )),
+        FnArg::Typed(input_arg) => match &*input_arg.pat{
+            Pat::Ident(ident) => ident.ident.clone(),
+            _ => return Err(Error::new(
+                input_arg.span(),
+                "this argument should be a plain identifier instead of a pattern",
+            )),
+        }
+    };
+
+    let alias_srcs = alias_map.remove(&fn_name).unwrap_or_else(Vec::new);
+
+    Ok(ParsedFn {
+        function,
+        fn_name,
+        input_arg,
+        alias_srcs,
+    })
+}
+
+fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Ident) -> Result<()> {
+    let function = &mut *f.function;
+    let fn_name = &f.fn_name;
+    let input_arg = &f.input_arg;
+
+    *function = parse_quote!(
+        #[allow(non_snake_case)]
+        #function
+    );
+
+    // `prec_climb` attr
+    let prec_climb_attrs: Vec<_> = function
+        .attrs
+        .drain_filter(|attr| attr.path.is_ident("prec_climb"))
+        .collect();
+
+    if prec_climb_attrs.len() > 1 {
+        return Err(Error::new(
+            prec_climb_attrs[1].span(),
+            "expected at most one prec_climb attribute",
+        ));
+    } else if prec_climb_attrs.is_empty() {
+        // do nothing
+    } else {
+        let attr = prec_climb_attrs.into_iter().next().unwrap();
+        let PrecClimbArgs {
+            child_rule,
+            climber,
+        } = attr.parse_args()?;
+
+        function.block = parse_quote!({
+            #function
+
+            #climber.climb(
+                #input_arg.as_pair().clone().into_inner(),
+                |p| Self::#child_rule(#input_arg.with_pair(p)),
+                |l, op, r| {
+                    #fn_name(#input_arg.clone(), l?, op, r?)
+                },
+            )
+        });
+        // Remove the 3 last arguments to keep only the `input` one
+        function.sig.inputs.pop();
+        function.sig.inputs.pop();
+        function.sig.inputs.pop();
+        // Check that an argument remains
+        function.sig.inputs.first().ok_or_else(|| {
+            Error::new(
+                function.sig.inputs.span(),
+                "a prec_climb function needs 4 arguments",
+            )
+        })?;
+    }
+
+    // `alias` attr
+    if !f.alias_srcs.is_empty() {
+        let aliases = f.alias_srcs.iter().map(|src| &src.ident);
+        let block = &function.block;
+        function.block = parse_quote!({
+            let mut #input_arg = #input_arg;
+            // While the current rule allows shortcutting, and there is a single child, and the
+            // child can still be parsed by the current function, then skip to that child.
+            while <Self as pest_consume::PestConsumer>::allows_shortcut(#input_arg.as_rule()) {
+                if let Some(child) = #input_arg.single_child() {
+                    if &<Self as pest_consume::PestConsumer>::rule_alias(child.as_rule())
+                            == stringify!(#fn_name) {
+                        #input_arg = child;
+                        continue;
+                    }
+                }
+                break
+            }
+
+            match #input_arg.as_rule() {
+                #(#rule_enum::#aliases => Self::#aliases(#input_arg),)*
+                #rule_enum::#fn_name => #block,
+                r => unreachable!(
+                    "make_parser: called {} on {:?}",
+                    stringify!(#fn_name),
+                    r
+                )
+            }
+        });
+    }
+
+    Ok(())
+}
+
+pub fn make_parser(
+    attrs: proc_macro::TokenStream,
+    input: proc_macro::TokenStream,
+) -> Result<proc_macro2::TokenStream> {
+    let rule_enum: Ident = syn::parse(attrs)?;
+    let mut imp: ItemImpl = syn::parse(input)?;
+
+    let mut alias_map = collect_aliases(&mut imp)?;
+    let rule_alias_branches: Vec<_> = alias_map
+        .iter()
+        .flat_map(|(tgt, srcs)| iter::repeat(tgt).zip(srcs))
+        .map(|(tgt, src)| {
+            let ident = &src.ident;
+            quote!(
+                #rule_enum::#ident => stringify!(#tgt).to_string(),
+            )
+        })
+        .collect();
+    let shortcut_branches: Vec<_> = alias_map
+        .iter()
+        .flat_map(|(_tgt, srcs)| srcs)
+        .map(|AliasSrc { ident, is_shortcut }| {
+            quote!(
+                #rule_enum::#ident => #is_shortcut,
+            )
+        })
+        .collect();
+
+    let fn_map: HashMap<Ident, ParsedFn> = imp
+        .items
+        .iter_mut()
+        .flat_map(|item| match item {
+            ImplItem::Method(m) => Some(m),
+            _ => None,
+        })
+        .map(|method| {
+            let mut f = parse_fn(method, &mut alias_map)?;
+            apply_special_attrs(&mut f, &rule_enum)?;
+            Ok((f.fn_name.clone(), f))
+        })
+        .collect::<Result<_>>()?;
+
+    // Entries that remain in the alias map don't have a matching method, so we create one.
+    let extra_fns: Vec<_> = alias_map
+        .iter()
+        .map(|(tgt, srcs)| {
+            // Get the signature of one of the functions that has this alias. They should all have
+            // essentially the same signature anyways.
+            let f = fn_map.get(&srcs.first().unwrap().ident).unwrap();
+            let input_arg = f.input_arg.clone();
+            let mut sig = f.function.sig.clone();
+            sig.ident = tgt.clone();
+            let srcs = srcs.iter().map(|src| &src.ident);
+
+            Ok(parse_quote!(
+                #sig {
+                    match #input_arg.as_rule() {
+                        #(#rule_enum::#srcs => Self::#srcs(#input_arg),)*
+                        // We can't match on #rule_enum::#tgt since `tgt` might be an arbitrary
+                        // identifier.
+                        r if &format!("{:?}", r) == stringify!(#tgt) =>
+                            return Err(#input_arg.error(format!(
+                                "make_parser: missing method for rule {}",
+                                stringify!(#tgt),
+                            ))),
+                        r => unreachable!(
+                            "make_parser: called {} on {:?}",
+                            stringify!(#tgt),
+                            r
+                        )
+                    }
+                }
+            ))
+        })
+        .collect::<Result<_>>()?;
+    imp.items.extend(extra_fns);
+
+    let ty = &imp.self_ty;
+    let (impl_generics, _, where_clause) = imp.generics.split_for_impl();
+    Ok(quote!(
+        impl #impl_generics pest_consume::PestConsumer for #ty #where_clause {
+            type Rule = #rule_enum;
+            fn rule_alias(rule: Self::Rule) -> String {
+                match rule {
+                    #(#rule_alias_branches)*
+                    r => format!("{:?}", r),
+                }
+            }
+            fn allows_shortcut(rule: Self::Rule) -> bool {
+                match rule {
+                    #(#shortcut_branches)*
+                    _ => false,
+                }
+            }
+        }
+
+        #imp
+    ))
+}
diff --git a/pest_consume_macros/src/parse_children.rs b/pest_consume_macros/src/parse_children.rs
new file mode 100644
index 0000000..d6474a7
--- /dev/null
+++ b/pest_consume_macros/src/parse_children.rs
@@ -0,0 +1,215 @@
+use proc_macro2::{Span, TokenStream};
+use quote::quote;
+use syn::parse::{Parse, ParseStream, Result};
+use syn::punctuated::Punctuated;
+use syn::spanned::Spanned;
+use syn::{bracketed, parenthesized, token, Error, Expr, Ident, Pat, Token};
+
+#[derive(Debug, Clone)]
+struct ChildrenBranch {
+    pattern_span: Span,
+    pattern: Punctuated<ChildrenBranchPatternItem, Token![,]>,
+    body: Expr,
+}
+
+#[derive(Debug, Clone)]
+enum ChildrenBranchPatternItem {
+    Single { rule_name: Ident, binder: Pat },
+    Multiple { rule_name: Ident, binder: Ident },
+}
+
+#[derive(Debug, Clone)]
+struct ParseChildrenInput {
+    input_expr: Expr,
+    branches: Punctuated<ChildrenBranch, Token![,]>,
+}
+
+impl Parse for ChildrenBranch {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let contents;
+        let _: token::Bracket = bracketed!(contents in input);
+        let pattern_unparsed: TokenStream = contents.fork().parse()?;
+        let pattern_span = pattern_unparsed.span();
+        let pattern = Punctuated::parse_terminated(&contents)?;
+        let _: Token![=>] = input.parse()?;
+        let body = input.parse()?;
+
+        Ok(ChildrenBranch {
+            pattern_span,
+            pattern,
+            body,
+        })
+    }
+}
+
+impl Parse for ChildrenBranchPatternItem {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let contents;
+        let rule_name = input.parse()?;
+        parenthesized!(contents in input);
+        if input.peek(Token![..]) {
+            let binder = contents.parse()?;
+            let _: Token![..] = input.parse()?;
+            Ok(ChildrenBranchPatternItem::Multiple { rule_name, binder })
+        } else if input.is_empty() || input.peek(Token![,]) {
+            let binder = contents.parse()?;
+            Ok(ChildrenBranchPatternItem::Single { rule_name, binder })
+        } else {
+            Err(input.error("expected `..` or nothing"))
+        }
+    }
+}
+
+impl Parse for ParseChildrenInput {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let input_expr = input.parse()?;
+        let _: Token![;] = input.parse()?;
+        let branches = Punctuated::parse_terminated(input)?;
+
+        Ok(ParseChildrenInput {
+            input_expr,
+            branches,
+        })
+    }
+}
+
+fn make_parser_branch(
+    branch: &ChildrenBranch,
+    i_inputs: &Ident,
+) -> Result<TokenStream> {
+    use ChildrenBranchPatternItem::{Multiple, Single};
+
+    let body = &branch.body;
+
+    // Convert the input pattern into a pattern-match on the Rules of the children. This uses
+    // slice_patterns.
+    // A single pattern just checks that the rule matches; a variable-length pattern binds the
+    // subslice and checks, in the if-guard, that its elements all match the chosen Rule.
+    let i_variable_pattern =
+        Ident::new("___variable_pattern", Span::call_site());
+    let match_pat = branch.pattern.iter().map(|item| match item {
+        Single { rule_name, .. } => quote!(stringify!(#rule_name)),
+        Multiple { .. } => quote!(#i_variable_pattern @ ..),
+    });
+    let match_filter = branch.pattern.iter().map(|item| match item {
+        Single { .. } => quote!(),
+        Multiple { rule_name, .. } => quote!(
+            {
+                // We can't use .all() directly in the pattern guard; see
+                // https://github.com/rust-lang/rust/issues/59803.
+                let all_match = |slice: &[_]| {
+                    slice.iter().all(|r|
+                        *r == stringify!(#rule_name)
+                    )
+                };
+                all_match(#i_variable_pattern)
+            } &&
+        ),
+    });
+
+    // Once we have found a branch that matches, we need to parse the children.
+    let mut singles_before_multiple = Vec::new();
+    let mut multiple = None;
+    let mut singles_after_multiple = Vec::new();
+    for item in &branch.pattern {
+        match item {
+            Single {
+                rule_name, binder, ..
+            } => {
+                if multiple.is_none() {
+                    singles_before_multiple.push((rule_name, binder))
+                } else {
+                    singles_after_multiple.push((rule_name, binder))
+                }
+            }
+            Multiple {
+                rule_name, binder, ..
+            } => {
+                if multiple.is_none() {
+                    multiple = Some((rule_name, binder))
+                } else {
+                    return Err(Error::new(
+                        branch.pattern_span.clone(),
+                        "multiple variable-length patterns are not allowed",
+                    ));
+                }
+            }
+        }
+    }
+    let mut parses = Vec::new();
+    for (rule_name, binder) in singles_before_multiple.into_iter() {
+        parses.push(quote!(
+            let #binder = Self::#rule_name(
+                #i_inputs.next().unwrap()
+            )?;
+        ))
+    }
+    // Note the `rev()`: we are taking inputs from the end of the iterator in reverse order, so that
+    // only the unmatched inputs are left for the variable-length pattern, if any.
+    for (rule_name, binder) in singles_after_multiple.into_iter().rev() {
+        parses.push(quote!(
+            let #binder = Self::#rule_name(
+                #i_inputs.next_back().unwrap()
+            )?;
+        ))
+    }
+    if let Some((rule_name, binder)) = multiple {
+        parses.push(quote!(
+            let #binder = #i_inputs
+                .map(|i| Self::#rule_name(i))
+                .collect::<Result<Vec<_>, _>>()?
+                .into_iter();
+        ))
+    }
+
+    Ok(quote!(
+        [#(#match_pat),*] if #(#match_filter)* true => {
+            #(#parses)*
+            #body
+        }
+    ))
+}
+
+pub fn parse_children(
+    input: proc_macro::TokenStream,
+) -> Result<proc_macro2::TokenStream> {
+    let input: ParseChildrenInput = syn::parse(input)?;
+
+    let i_children_rules = Ident::new("___children_rules", Span::call_site());
+    let i_inputs = Ident::new("___inputs", Span::call_site());
+
+    let input_expr = &input.input_expr;
+    let branches = input
+        .branches
+        .iter()
+        .map(|br| make_parser_branch(br, &i_inputs))
+        .collect::<Result<Vec<_>>>()?;
+
+    Ok(quote!({
+        let #i_children_rules: Vec<_> = #input_expr.as_pair()
+            .clone()
+            .into_inner()
+            .map(|p| p.as_rule())
+            .map(<Self as pest_consume::PestConsumer>::rule_alias)
+            .collect();
+        let #i_children_rules: Vec<&str> = #i_children_rules
+            .iter()
+            .map(String::as_str)
+            .collect();
+
+        #[allow(unused_mut)]
+        let mut #i_inputs = #input_expr
+            .as_pair()
+            .clone()
+            .into_inner()
+            .map(|p| #input_expr.with_pair(p));
+
+        #[allow(unreachable_code)]
+        match #i_children_rules.as_slice() {
+            #(#branches,)*
+            [..] => return Err(#input_expr.error(
+                format!("Unexpected children: {:?}", #i_children_rules)
+            )),
+        }
+    }))
+}
-- 
cgit v1.2.3


From fc8fce6facee9bd50958e78f3b177e16ed065c19 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 10 Sep 2019 13:55:35 +0200
Subject: Generalize parse_children and change its invocation

---
 dhall_syntax/src/parser.rs                | 72 +++++++++++------------
 pest_consume/src/lib.rs                   | 95 ++++++++++++++++++++++++++++++-
 pest_consume_macros/src/parse_children.rs | 27 +++------
 3 files changed, 139 insertions(+), 55 deletions(-)

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 6c47de4..d86e35a 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -168,7 +168,7 @@ impl Parsers {
     fn double_quote_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ParsedText<E>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [double_quote_chunk(chunks)..] => {
                 chunks.collect()
             }
@@ -178,7 +178,7 @@ impl Parsers {
     fn double_quote_chunk<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ParsedTextContents<E>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [expression(e)] => {
                 InterpolatedTextContents::Expr(e)
             },
@@ -265,7 +265,7 @@ impl Parsers {
     fn single_quote_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ParsedText<E>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [single_quote_continue(lines)] => {
                 let newline: ParsedText<E> = "\n".to_string().into();
 
@@ -308,7 +308,7 @@ impl Parsers {
     fn single_quote_continue<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Vec<Vec<ParsedTextContents<E>>>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [expression(e), single_quote_continue(lines)] => {
                 let c = InterpolatedTextContents::Expr(e);
                 let mut lines = lines;
@@ -393,7 +393,7 @@ impl Parsers {
 
     #[alias(expression, shortcut = true)]
     fn identifier<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [variable(v)] => {
                 spanned(input, Var(v))
             },
@@ -402,7 +402,7 @@ impl Parsers {
     }
 
     fn variable(input: ParseInput) -> ParseResult<V<Label>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [label(l), natural_literal(idx)] => {
                 V(l, idx)
             },
@@ -444,7 +444,7 @@ impl Parsers {
             .collect())
     }
     fn path(input: ParseInput) -> ParseResult<Vec<String>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [path_component(components)..] => {
                 components.collect()
             }
@@ -455,7 +455,7 @@ impl Parsers {
     fn local<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [local_path((prefix, p))] => ImportLocation::Local(prefix, p),
         ))
     }
@@ -464,19 +464,19 @@ impl Parsers {
     fn parent_path(
         input: ParseInput,
     ) -> ParseResult<(FilePrefix, Vec<String>)> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [path(p)] => (FilePrefix::Parent, p)
         ))
     }
     #[alias(local_path)]
     fn here_path(input: ParseInput) -> ParseResult<(FilePrefix, Vec<String>)> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [path(p)] => (FilePrefix::Here, p)
         ))
     }
     #[alias(local_path)]
     fn home_path(input: ParseInput) -> ParseResult<(FilePrefix, Vec<String>)> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [path(p)] => (FilePrefix::Home, p)
         ))
     }
@@ -484,7 +484,7 @@ impl Parsers {
     fn absolute_path(
         input: ParseInput,
     ) -> ParseResult<(FilePrefix, Vec<String>)> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [path(p)] => (FilePrefix::Absolute, p)
         ))
     }
@@ -498,7 +498,7 @@ impl Parsers {
     }
 
     fn http_raw<E: Clone>(input: ParseInput) -> ParseResult<URL<Expr<E>>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [scheme(sch), authority(auth), path(p)] => URL {
                 scheme: sch,
                 authority: auth,
@@ -528,7 +528,7 @@ impl Parsers {
     fn http<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
-        Ok(ImportLocation::Remote(parse_children!(input;
+        Ok(ImportLocation::Remote(parse_children!(input.children();
             [http_raw(url)] => url,
             [http_raw(url), expression(e)] => URL { headers: Some(e), ..url },
         )))
@@ -538,7 +538,7 @@ impl Parsers {
     fn env<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [environment_variable(v)] => ImportLocation::Env(v),
         ))
     }
@@ -548,7 +548,7 @@ impl Parsers {
     }
     #[alias(environment_variable)]
     fn posix_environment_variable(input: ParseInput) -> ParseResult<String> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [posix_environment_variable_character(chars)..] => {
                 chars.collect()
             },
@@ -593,7 +593,7 @@ impl Parsers {
     ) -> ParseResult<crate::Import<Expr<E>>> {
         use crate::Import;
         let mode = ImportMode::Code;
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [import_type(location)] => Import { mode, location, hash: None },
             [import_type(location), hash(h)] => Import { mode, location, hash: Some(h) },
         ))
@@ -611,7 +611,7 @@ impl Parsers {
     #[alias(expression)]
     fn import<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
         use crate::Import;
-        let import = parse_children!(input;
+        let import = parse_children!(input.children();
             [import_hashed(imp)] => {
                 Import { mode: ImportMode::Code, ..imp }
             },
@@ -646,13 +646,13 @@ impl Parsers {
 
     #[alias(expression)]
     fn empty_list_literal<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [expression(e)] => spanned(input, EmptyListLit(e)),
         ))
     }
 
     fn expression<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [lambda(()), label(l), expression(typ),
                     arrow(()), expression(body)] => {
                 spanned(input, Lam(l, typ, body))
@@ -699,7 +699,7 @@ impl Parsers {
     fn let_binding<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Label, Option<Expr<E>>, Expr<E>, Span)> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [label(name), expression(annot), expression(expr)] =>
                 (name, Some(annot), expr, input_to_span(input)),
             [label(name), expression(expr)] =>
@@ -749,7 +749,7 @@ impl Parsers {
     fn application_expression<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [expression(e)] => e,
             [expression(first), expression(rest)..] => {
                 rest.fold(
@@ -770,7 +770,7 @@ impl Parsers {
     fn first_application_expression<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [Some_(()), expression(e)] => {
                 spanned(input, SomeLit(e))
             },
@@ -788,7 +788,7 @@ impl Parsers {
     fn selector_expression<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [expression(e)] => e,
             [expression(first), selector(rest)..] => {
                 rest.fold(
@@ -811,7 +811,7 @@ impl Parsers {
     fn selector(
         input: ParseInput,
     ) -> ParseResult<(Either<Label, DupTreeSet<Label>>, Span)> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [label(l)] => (Either::Left(l), input_to_span(input)),
             [labels(ls)] => (Either::Right(ls), input_to_span(input)),
             // [expression(_e)] => unimplemented!("selection by expression"), // TODO
@@ -819,7 +819,7 @@ impl Parsers {
     }
 
     fn labels(input: ParseInput) -> ParseResult<DupTreeSet<Label>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [label(ls)..] => ls.collect(),
         ))
     }
@@ -828,7 +828,7 @@ impl Parsers {
     fn primitive_expression<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [double_literal(n)] => spanned(input, DoubleLit(n)),
             [natural_literal(n)] => spanned(input, NaturalLit(n)),
             [integer_literal(n)] => spanned(input, IntegerLit(n)),
@@ -854,7 +854,7 @@ impl Parsers {
     fn non_empty_record_type_or_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        let e = parse_children!(input;
+        let e = parse_children!(input.children();
             [label(first_label), non_empty_record_type(rest)] => {
                 let (first_expr, mut map) = rest;
                 map.insert(first_label, first_expr);
@@ -872,7 +872,7 @@ impl Parsers {
     fn non_empty_record_type<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Expr<E>, DupTreeMap<Label, Expr<E>>)> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [expression(expr), record_type_entry(entries)..] => {
                 (expr, entries.collect())
             }
@@ -882,7 +882,7 @@ impl Parsers {
     fn record_type_entry<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Label, Expr<E>)> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [label(name), expression(expr)] => (name, expr)
         ))
     }
@@ -890,7 +890,7 @@ impl Parsers {
     fn non_empty_record_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Expr<E>, DupTreeMap<Label, Expr<E>>)> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [expression(expr), record_literal_entry(entries)..] => {
                 (expr, entries.collect())
             }
@@ -900,14 +900,14 @@ impl Parsers {
     fn record_literal_entry<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Label, Expr<E>)> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [label(name), expression(expr)] => (name, expr)
         ))
     }
 
     #[alias(expression)]
     fn union_type<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        let map = parse_children!(input;
+        let map = parse_children!(input.children();
             [empty_union_type(_)] => Default::default(),
             [union_type_entry(entries)..] => entries.collect(),
         );
@@ -921,7 +921,7 @@ impl Parsers {
     fn union_type_entry<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Label, Option<Expr<E>>)> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [label(name), expression(expr)] => (name, Some(expr)),
             [label(name)] => (name, None),
         ))
@@ -931,7 +931,7 @@ impl Parsers {
     fn non_empty_list_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [expression(items)..] => spanned(
                 input,
                 NEListLit(items.collect())
@@ -940,7 +940,7 @@ impl Parsers {
     }
 
     fn final_expression<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input;
+        Ok(parse_children!(input.children();
             [expression(e), EOI(_)] => e
         ))
     }
diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index 6e4b2e3..70aee56 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -5,7 +5,7 @@ use pest::Span;
 pub use pest_consume_macros::{make_parser, parse_children};
 
 /// Carries a pest Pair alongside custom user data.
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct ParseInput<'input, 'data, Rule, Data>
 where
     Rule: pest::RuleType,
@@ -14,6 +14,16 @@ where
     user_data: &'data Data,
 }
 
+/// Iterator over `ParseInput`s. It is created by `ParseInput::children`.
+#[derive(Debug)]
+pub struct ParseInputs<'input, 'data, Rule, Data>
+where
+    Rule: pest::RuleType,
+{
+    input: ParseInput<'input, 'data, Rule, Data>,
+    pairs: pest::iterators::Pairs<'input, Rule>,
+}
+
 impl<'input, 'data, Rule, Data> ParseInput<'input, 'data, Rule, Data>
 where
     Rule: pest::RuleType,
@@ -50,6 +60,15 @@ where
         }
         None
     }
+    /// Return an iterator over the children of this input
+    // Can't use `-> impl Iterator` because of weird lifetime limitations
+    // (see https://github.com/rust-lang/rust/issues/61997).
+    pub fn children(&self) -> ParseInputs<'input, 'data, Rule, Data> {
+        ParseInputs {
+            input: self.clone(),
+            pairs: self.as_pair().clone().into_inner(),
+        }
+    }
 
     pub fn user_data(&self) -> &'data Data {
         self.user_data
@@ -66,6 +85,28 @@ where
     pub fn as_rule(&self) -> Rule {
         self.pair.as_rule()
     }
+    pub fn as_rule_alias<T>(&self) -> String
+    where
+        T: PestConsumer<Rule = Rule>,
+    {
+        T::rule_alias(self.as_rule())
+    }
+}
+
+impl<'input, 'data, Rule, Data> ParseInputs<'input, 'data, Rule, Data>
+where
+    Rule: pest::RuleType,
+{
+    /// Create an error that points to the span of the input.
+    pub fn error(&self, message: String) -> Error<Rule> {
+        self.input.error(message)
+    }
+    pub fn aliased_rules<T>(&self) -> Vec<String>
+    where
+        T: PestConsumer<Rule = Rule>,
+    {
+        self.clone().map(|p| p.as_rule_alias::<T>()).collect()
+    }
 }
 
 /// Used by the macros.
@@ -121,3 +162,55 @@ fn debug_pair<Rule: pest::RuleType>(pair: Pair<Rule>) -> String {
     aux(&mut s, 0, "".into(), pair);
     s
 }
+
+impl<'input, 'data, Rule, Data> Iterator
+    for ParseInputs<'input, 'data, Rule, Data>
+where
+    Rule: pest::RuleType,
+{
+    type Item = ParseInput<'input, 'data, Rule, Data>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let child_pair = self.pairs.next()?;
+        let child = self.input.with_pair(child_pair);
+        Some(child)
+    }
+}
+
+impl<'input, 'data, Rule, Data> DoubleEndedIterator
+    for ParseInputs<'input, 'data, Rule, Data>
+where
+    Rule: pest::RuleType,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        let child_pair = self.pairs.next_back()?;
+        let child = self.input.with_pair(child_pair);
+        Some(child)
+    }
+}
+
+// Manual impl to avoid stupid `Data: Clone` trait bound
+impl<'input, 'data, Rule, Data> Clone for ParseInput<'input, 'data, Rule, Data>
+where
+    Rule: pest::RuleType,
+{
+    fn clone(&self) -> Self {
+        ParseInput {
+            pair: self.pair.clone(),
+            user_data: self.user_data,
+        }
+    }
+}
+
+// Manual impl to avoid stupid `Data: Clone` trait bound
+impl<'input, 'data, Rule, Data> Clone for ParseInputs<'input, 'data, Rule, Data>
+where
+    Rule: pest::RuleType,
+{
+    fn clone(&self) -> Self {
+        ParseInputs {
+            input: self.input.clone(),
+            pairs: self.pairs.clone(),
+        }
+    }
+}
diff --git a/pest_consume_macros/src/parse_children.rs b/pest_consume_macros/src/parse_children.rs
index d6474a7..8feef03 100644
--- a/pest_consume_macros/src/parse_children.rs
+++ b/pest_consume_macros/src/parse_children.rs
@@ -175,7 +175,7 @@ pub fn parse_children(
 ) -> Result<proc_macro2::TokenStream> {
     let input: ParseChildrenInput = syn::parse(input)?;
 
-    let i_children_rules = Ident::new("___children_rules", Span::call_site());
+    let i_input_rules = Ident::new("___input_rules", Span::call_site());
     let i_inputs = Ident::new("___inputs", Span::call_site());
 
     let input_expr = &input.input_expr;
@@ -186,29 +186,20 @@ pub fn parse_children(
         .collect::<Result<Vec<_>>>()?;
 
     Ok(quote!({
-        let #i_children_rules: Vec<_> = #input_expr.as_pair()
-            .clone()
-            .into_inner()
-            .map(|p| p.as_rule())
-            .map(<Self as pest_consume::PestConsumer>::rule_alias)
-            .collect();
-        let #i_children_rules: Vec<&str> = #i_children_rules
+        #[allow(unused_mut)]
+        let mut #i_inputs = #input_expr;
+
+        let #i_input_rules = #i_inputs.aliased_rules::<Self>();
+        let #i_input_rules: Vec<&str> = #i_input_rules
             .iter()
             .map(String::as_str)
             .collect();
 
-        #[allow(unused_mut)]
-        let mut #i_inputs = #input_expr
-            .as_pair()
-            .clone()
-            .into_inner()
-            .map(|p| #input_expr.with_pair(p));
-
         #[allow(unreachable_code)]
-        match #i_children_rules.as_slice() {
+        match #i_input_rules.as_slice() {
             #(#branches,)*
-            [..] => return Err(#input_expr.error(
-                format!("Unexpected children: {:?}", #i_children_rules)
+            [..] => return Err(#i_inputs.error(
+                format!("Unexpected children: {:?}", #i_input_rules)
             )),
         }
     }))
-- 
cgit v1.2.3


From a86088505de38c9b3d4c4bb8feecab28055514d8 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 10 Sep 2019 13:57:43 +0200
Subject: Rename parse_children to match_inputs

---
 dhall_syntax/src/parser.rs                |  74 +++++------
 pest_consume/src/lib.rs                   |   2 +-
 pest_consume_macros/src/lib.rs            |   6 +-
 pest_consume_macros/src/match_inputs.rs   | 206 ++++++++++++++++++++++++++++++
 pest_consume_macros/src/parse_children.rs | 206 ------------------------------
 5 files changed, 247 insertions(+), 247 deletions(-)
 create mode 100644 pest_consume_macros/src/match_inputs.rs
 delete mode 100644 pest_consume_macros/src/parse_children.rs

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index d86e35a..761795a 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -6,7 +6,7 @@ use pest::Parser;
 use std::rc::Rc;
 
 use dhall_generated_parser::{DhallParser, Rule};
-use pest_consume::{make_parser, parse_children};
+use pest_consume::{make_parser, match_inputs};
 
 use crate::map::{DupTreeMap, DupTreeSet};
 use crate::ExprF::*;
@@ -168,7 +168,7 @@ impl Parsers {
     fn double_quote_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ParsedText<E>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [double_quote_chunk(chunks)..] => {
                 chunks.collect()
             }
@@ -178,7 +178,7 @@ impl Parsers {
     fn double_quote_chunk<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ParsedTextContents<E>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [expression(e)] => {
                 InterpolatedTextContents::Expr(e)
             },
@@ -265,7 +265,7 @@ impl Parsers {
     fn single_quote_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ParsedText<E>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [single_quote_continue(lines)] => {
                 let newline: ParsedText<E> = "\n".to_string().into();
 
@@ -308,7 +308,7 @@ impl Parsers {
     fn single_quote_continue<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Vec<Vec<ParsedTextContents<E>>>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [expression(e), single_quote_continue(lines)] => {
                 let c = InterpolatedTextContents::Expr(e);
                 let mut lines = lines;
@@ -393,7 +393,7 @@ impl Parsers {
 
     #[alias(expression, shortcut = true)]
     fn identifier<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [variable(v)] => {
                 spanned(input, Var(v))
             },
@@ -402,7 +402,7 @@ impl Parsers {
     }
 
     fn variable(input: ParseInput) -> ParseResult<V<Label>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [label(l), natural_literal(idx)] => {
                 V(l, idx)
             },
@@ -444,7 +444,7 @@ impl Parsers {
             .collect())
     }
     fn path(input: ParseInput) -> ParseResult<Vec<String>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [path_component(components)..] => {
                 components.collect()
             }
@@ -455,7 +455,7 @@ impl Parsers {
     fn local<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [local_path((prefix, p))] => ImportLocation::Local(prefix, p),
         ))
     }
@@ -464,19 +464,19 @@ impl Parsers {
     fn parent_path(
         input: ParseInput,
     ) -> ParseResult<(FilePrefix, Vec<String>)> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [path(p)] => (FilePrefix::Parent, p)
         ))
     }
     #[alias(local_path)]
     fn here_path(input: ParseInput) -> ParseResult<(FilePrefix, Vec<String>)> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [path(p)] => (FilePrefix::Here, p)
         ))
     }
     #[alias(local_path)]
     fn home_path(input: ParseInput) -> ParseResult<(FilePrefix, Vec<String>)> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [path(p)] => (FilePrefix::Home, p)
         ))
     }
@@ -484,7 +484,7 @@ impl Parsers {
     fn absolute_path(
         input: ParseInput,
     ) -> ParseResult<(FilePrefix, Vec<String>)> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [path(p)] => (FilePrefix::Absolute, p)
         ))
     }
@@ -498,7 +498,7 @@ impl Parsers {
     }
 
     fn http_raw<E: Clone>(input: ParseInput) -> ParseResult<URL<Expr<E>>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [scheme(sch), authority(auth), path(p)] => URL {
                 scheme: sch,
                 authority: auth,
@@ -528,7 +528,7 @@ impl Parsers {
     fn http<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
-        Ok(ImportLocation::Remote(parse_children!(input.children();
+        Ok(ImportLocation::Remote(match_inputs!(input.children();
             [http_raw(url)] => url,
             [http_raw(url), expression(e)] => URL { headers: Some(e), ..url },
         )))
@@ -538,7 +538,7 @@ impl Parsers {
     fn env<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [environment_variable(v)] => ImportLocation::Env(v),
         ))
     }
@@ -548,7 +548,7 @@ impl Parsers {
     }
     #[alias(environment_variable)]
     fn posix_environment_variable(input: ParseInput) -> ParseResult<String> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [posix_environment_variable_character(chars)..] => {
                 chars.collect()
             },
@@ -593,7 +593,7 @@ impl Parsers {
     ) -> ParseResult<crate::Import<Expr<E>>> {
         use crate::Import;
         let mode = ImportMode::Code;
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [import_type(location)] => Import { mode, location, hash: None },
             [import_type(location), hash(h)] => Import { mode, location, hash: Some(h) },
         ))
@@ -611,7 +611,7 @@ impl Parsers {
     #[alias(expression)]
     fn import<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
         use crate::Import;
-        let import = parse_children!(input.children();
+        let import = match_inputs!(input.children();
             [import_hashed(imp)] => {
                 Import { mode: ImportMode::Code, ..imp }
             },
@@ -646,13 +646,13 @@ impl Parsers {
 
     #[alias(expression)]
     fn empty_list_literal<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [expression(e)] => spanned(input, EmptyListLit(e)),
         ))
     }
 
     fn expression<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [lambda(()), label(l), expression(typ),
                     arrow(()), expression(body)] => {
                 spanned(input, Lam(l, typ, body))
@@ -699,7 +699,7 @@ impl Parsers {
     fn let_binding<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Label, Option<Expr<E>>, Expr<E>, Span)> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [label(name), expression(annot), expression(expr)] =>
                 (name, Some(annot), expr, input_to_span(input)),
             [label(name), expression(expr)] =>
@@ -749,7 +749,7 @@ impl Parsers {
     fn application_expression<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [expression(e)] => e,
             [expression(first), expression(rest)..] => {
                 rest.fold(
@@ -770,7 +770,7 @@ impl Parsers {
     fn first_application_expression<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [Some_(()), expression(e)] => {
                 spanned(input, SomeLit(e))
             },
@@ -788,7 +788,7 @@ impl Parsers {
     fn selector_expression<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [expression(e)] => e,
             [expression(first), selector(rest)..] => {
                 rest.fold(
@@ -811,7 +811,7 @@ impl Parsers {
     fn selector(
         input: ParseInput,
     ) -> ParseResult<(Either<Label, DupTreeSet<Label>>, Span)> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [label(l)] => (Either::Left(l), input_to_span(input)),
             [labels(ls)] => (Either::Right(ls), input_to_span(input)),
             // [expression(_e)] => unimplemented!("selection by expression"), // TODO
@@ -819,7 +819,7 @@ impl Parsers {
     }
 
     fn labels(input: ParseInput) -> ParseResult<DupTreeSet<Label>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [label(ls)..] => ls.collect(),
         ))
     }
@@ -828,7 +828,7 @@ impl Parsers {
     fn primitive_expression<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [double_literal(n)] => spanned(input, DoubleLit(n)),
             [natural_literal(n)] => spanned(input, NaturalLit(n)),
             [integer_literal(n)] => spanned(input, IntegerLit(n)),
@@ -854,7 +854,7 @@ impl Parsers {
     fn non_empty_record_type_or_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        let e = parse_children!(input.children();
+        let e = match_inputs!(input.children();
             [label(first_label), non_empty_record_type(rest)] => {
                 let (first_expr, mut map) = rest;
                 map.insert(first_label, first_expr);
@@ -872,7 +872,7 @@ impl Parsers {
     fn non_empty_record_type<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Expr<E>, DupTreeMap<Label, Expr<E>>)> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [expression(expr), record_type_entry(entries)..] => {
                 (expr, entries.collect())
             }
@@ -882,7 +882,7 @@ impl Parsers {
     fn record_type_entry<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Label, Expr<E>)> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [label(name), expression(expr)] => (name, expr)
         ))
     }
@@ -890,7 +890,7 @@ impl Parsers {
     fn non_empty_record_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Expr<E>, DupTreeMap<Label, Expr<E>>)> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [expression(expr), record_literal_entry(entries)..] => {
                 (expr, entries.collect())
             }
@@ -900,14 +900,14 @@ impl Parsers {
     fn record_literal_entry<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Label, Expr<E>)> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [label(name), expression(expr)] => (name, expr)
         ))
     }
 
     #[alias(expression)]
     fn union_type<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        let map = parse_children!(input.children();
+        let map = match_inputs!(input.children();
             [empty_union_type(_)] => Default::default(),
             [union_type_entry(entries)..] => entries.collect(),
         );
@@ -921,7 +921,7 @@ impl Parsers {
     fn union_type_entry<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Label, Option<Expr<E>>)> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [label(name), expression(expr)] => (name, Some(expr)),
             [label(name)] => (name, None),
         ))
@@ -931,7 +931,7 @@ impl Parsers {
     fn non_empty_list_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [expression(items)..] => spanned(
                 input,
                 NEListLit(items.collect())
@@ -940,7 +940,7 @@ impl Parsers {
     }
 
     fn final_expression<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input.children();
+        Ok(match_inputs!(input.children();
             [expression(e), EOI(_)] => e
         ))
     }
diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index 70aee56..7e2c1ca 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -2,7 +2,7 @@ use pest::error::{Error, ErrorVariant};
 use pest::iterators::Pair;
 use pest::Span;
 
-pub use pest_consume_macros::{make_parser, parse_children};
+pub use pest_consume_macros::{make_parser, match_inputs};
 
 /// Carries a pest Pair alongside custom user data.
 #[derive(Debug)]
diff --git a/pest_consume_macros/src/lib.rs b/pest_consume_macros/src/lib.rs
index dd437f6..b5368ec 100644
--- a/pest_consume_macros/src/lib.rs
+++ b/pest_consume_macros/src/lib.rs
@@ -7,7 +7,7 @@
 extern crate proc_macro;
 
 mod make_parser;
-mod parse_children;
+mod match_inputs;
 
 use proc_macro::TokenStream;
 
@@ -20,8 +20,8 @@ pub fn make_parser(attrs: TokenStream, input: TokenStream) -> TokenStream {
 }
 
 #[proc_macro]
-pub fn parse_children(input: TokenStream) -> TokenStream {
-    TokenStream::from(match parse_children::parse_children(input) {
+pub fn match_inputs(input: TokenStream) -> TokenStream {
+    TokenStream::from(match match_inputs::match_inputs(input) {
         Ok(tokens) => tokens,
         Err(err) => err.to_compile_error(),
     })
diff --git a/pest_consume_macros/src/match_inputs.rs b/pest_consume_macros/src/match_inputs.rs
new file mode 100644
index 0000000..3a325a6
--- /dev/null
+++ b/pest_consume_macros/src/match_inputs.rs
@@ -0,0 +1,206 @@
+use proc_macro2::{Span, TokenStream};
+use quote::quote;
+use syn::parse::{Parse, ParseStream, Result};
+use syn::punctuated::Punctuated;
+use syn::spanned::Spanned;
+use syn::{bracketed, parenthesized, token, Error, Expr, Ident, Pat, Token};
+
+#[derive(Debug, Clone)]
+struct ChildrenBranch {
+    pattern_span: Span,
+    pattern: Punctuated<ChildrenBranchPatternItem, Token![,]>,
+    body: Expr,
+}
+
+#[derive(Debug, Clone)]
+enum ChildrenBranchPatternItem {
+    Single { rule_name: Ident, binder: Pat },
+    Multiple { rule_name: Ident, binder: Ident },
+}
+
+#[derive(Debug, Clone)]
+struct ParseChildrenInput {
+    input_expr: Expr,
+    branches: Punctuated<ChildrenBranch, Token![,]>,
+}
+
+impl Parse for ChildrenBranch {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let contents;
+        let _: token::Bracket = bracketed!(contents in input);
+        let pattern_unparsed: TokenStream = contents.fork().parse()?;
+        let pattern_span = pattern_unparsed.span();
+        let pattern = Punctuated::parse_terminated(&contents)?;
+        let _: Token![=>] = input.parse()?;
+        let body = input.parse()?;
+
+        Ok(ChildrenBranch {
+            pattern_span,
+            pattern,
+            body,
+        })
+    }
+}
+
+impl Parse for ChildrenBranchPatternItem {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let contents;
+        let rule_name = input.parse()?;
+        parenthesized!(contents in input);
+        if input.peek(Token![..]) {
+            let binder = contents.parse()?;
+            let _: Token![..] = input.parse()?;
+            Ok(ChildrenBranchPatternItem::Multiple { rule_name, binder })
+        } else if input.is_empty() || input.peek(Token![,]) {
+            let binder = contents.parse()?;
+            Ok(ChildrenBranchPatternItem::Single { rule_name, binder })
+        } else {
+            Err(input.error("expected `..` or nothing"))
+        }
+    }
+}
+
+impl Parse for ParseChildrenInput {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let input_expr = input.parse()?;
+        let _: Token![;] = input.parse()?;
+        let branches = Punctuated::parse_terminated(input)?;
+
+        Ok(ParseChildrenInput {
+            input_expr,
+            branches,
+        })
+    }
+}
+
+fn make_parser_branch(
+    branch: &ChildrenBranch,
+    i_inputs: &Ident,
+) -> Result<TokenStream> {
+    use ChildrenBranchPatternItem::{Multiple, Single};
+
+    let body = &branch.body;
+
+    // Convert the input pattern into a pattern-match on the Rules of the children. This uses
+    // slice_patterns.
+    // A single pattern just checks that the rule matches; a variable-length pattern binds the
+    // subslice and checks, in the if-guard, that its elements all match the chosen Rule.
+    let i_variable_pattern =
+        Ident::new("___variable_pattern", Span::call_site());
+    let match_pat = branch.pattern.iter().map(|item| match item {
+        Single { rule_name, .. } => quote!(stringify!(#rule_name)),
+        Multiple { .. } => quote!(#i_variable_pattern @ ..),
+    });
+    let match_filter = branch.pattern.iter().map(|item| match item {
+        Single { .. } => quote!(),
+        Multiple { rule_name, .. } => quote!(
+            {
+                // We can't use .all() directly in the pattern guard; see
+                // https://github.com/rust-lang/rust/issues/59803.
+                let all_match = |slice: &[_]| {
+                    slice.iter().all(|r|
+                        *r == stringify!(#rule_name)
+                    )
+                };
+                all_match(#i_variable_pattern)
+            } &&
+        ),
+    });
+
+    // Once we have found a branch that matches, we need to parse the children.
+    let mut singles_before_multiple = Vec::new();
+    let mut multiple = None;
+    let mut singles_after_multiple = Vec::new();
+    for item in &branch.pattern {
+        match item {
+            Single {
+                rule_name, binder, ..
+            } => {
+                if multiple.is_none() {
+                    singles_before_multiple.push((rule_name, binder))
+                } else {
+                    singles_after_multiple.push((rule_name, binder))
+                }
+            }
+            Multiple {
+                rule_name, binder, ..
+            } => {
+                if multiple.is_none() {
+                    multiple = Some((rule_name, binder))
+                } else {
+                    return Err(Error::new(
+                        branch.pattern_span.clone(),
+                        "multiple variable-length patterns are not allowed",
+                    ));
+                }
+            }
+        }
+    }
+    let mut parses = Vec::new();
+    for (rule_name, binder) in singles_before_multiple.into_iter() {
+        parses.push(quote!(
+            let #binder = Self::#rule_name(
+                #i_inputs.next().unwrap()
+            )?;
+        ))
+    }
+    // Note the `rev()`: we are taking inputs from the end of the iterator in reverse order, so that
+    // only the unmatched inputs are left for the variable-length pattern, if any.
+    for (rule_name, binder) in singles_after_multiple.into_iter().rev() {
+        parses.push(quote!(
+            let #binder = Self::#rule_name(
+                #i_inputs.next_back().unwrap()
+            )?;
+        ))
+    }
+    if let Some((rule_name, binder)) = multiple {
+        parses.push(quote!(
+            let #binder = #i_inputs
+                .map(|i| Self::#rule_name(i))
+                .collect::<Result<Vec<_>, _>>()?
+                .into_iter();
+        ))
+    }
+
+    Ok(quote!(
+        [#(#match_pat),*] if #(#match_filter)* true => {
+            #(#parses)*
+            #body
+        }
+    ))
+}
+
+pub fn match_inputs(
+    input: proc_macro::TokenStream,
+) -> Result<proc_macro2::TokenStream> {
+    let input: ParseChildrenInput = syn::parse(input)?;
+
+    let i_input_rules = Ident::new("___input_rules", Span::call_site());
+    let i_inputs = Ident::new("___inputs", Span::call_site());
+
+    let input_expr = &input.input_expr;
+    let branches = input
+        .branches
+        .iter()
+        .map(|br| make_parser_branch(br, &i_inputs))
+        .collect::<Result<Vec<_>>>()?;
+
+    Ok(quote!({
+        #[allow(unused_mut)]
+        let mut #i_inputs = #input_expr;
+
+        let #i_input_rules = #i_inputs.aliased_rules::<Self>();
+        let #i_input_rules: Vec<&str> = #i_input_rules
+            .iter()
+            .map(String::as_str)
+            .collect();
+
+        #[allow(unreachable_code)]
+        match #i_input_rules.as_slice() {
+            #(#branches,)*
+            [..] => return Err(#i_inputs.error(
+                format!("Unexpected children: {:?}", #i_input_rules)
+            )),
+        }
+    }))
+}
diff --git a/pest_consume_macros/src/parse_children.rs b/pest_consume_macros/src/parse_children.rs
deleted file mode 100644
index 8feef03..0000000
--- a/pest_consume_macros/src/parse_children.rs
+++ /dev/null
@@ -1,206 +0,0 @@
-use proc_macro2::{Span, TokenStream};
-use quote::quote;
-use syn::parse::{Parse, ParseStream, Result};
-use syn::punctuated::Punctuated;
-use syn::spanned::Spanned;
-use syn::{bracketed, parenthesized, token, Error, Expr, Ident, Pat, Token};
-
-#[derive(Debug, Clone)]
-struct ChildrenBranch {
-    pattern_span: Span,
-    pattern: Punctuated<ChildrenBranchPatternItem, Token![,]>,
-    body: Expr,
-}
-
-#[derive(Debug, Clone)]
-enum ChildrenBranchPatternItem {
-    Single { rule_name: Ident, binder: Pat },
-    Multiple { rule_name: Ident, binder: Ident },
-}
-
-#[derive(Debug, Clone)]
-struct ParseChildrenInput {
-    input_expr: Expr,
-    branches: Punctuated<ChildrenBranch, Token![,]>,
-}
-
-impl Parse for ChildrenBranch {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let contents;
-        let _: token::Bracket = bracketed!(contents in input);
-        let pattern_unparsed: TokenStream = contents.fork().parse()?;
-        let pattern_span = pattern_unparsed.span();
-        let pattern = Punctuated::parse_terminated(&contents)?;
-        let _: Token![=>] = input.parse()?;
-        let body = input.parse()?;
-
-        Ok(ChildrenBranch {
-            pattern_span,
-            pattern,
-            body,
-        })
-    }
-}
-
-impl Parse for ChildrenBranchPatternItem {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let contents;
-        let rule_name = input.parse()?;
-        parenthesized!(contents in input);
-        if input.peek(Token![..]) {
-            let binder = contents.parse()?;
-            let _: Token![..] = input.parse()?;
-            Ok(ChildrenBranchPatternItem::Multiple { rule_name, binder })
-        } else if input.is_empty() || input.peek(Token![,]) {
-            let binder = contents.parse()?;
-            Ok(ChildrenBranchPatternItem::Single { rule_name, binder })
-        } else {
-            Err(input.error("expected `..` or nothing"))
-        }
-    }
-}
-
-impl Parse for ParseChildrenInput {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let input_expr = input.parse()?;
-        let _: Token![;] = input.parse()?;
-        let branches = Punctuated::parse_terminated(input)?;
-
-        Ok(ParseChildrenInput {
-            input_expr,
-            branches,
-        })
-    }
-}
-
-fn make_parser_branch(
-    branch: &ChildrenBranch,
-    i_inputs: &Ident,
-) -> Result<TokenStream> {
-    use ChildrenBranchPatternItem::{Multiple, Single};
-
-    let body = &branch.body;
-
-    // Convert the input pattern into a pattern-match on the Rules of the children. This uses
-    // slice_patterns.
-    // A single pattern just checks that the rule matches; a variable-length pattern binds the
-    // subslice and checks, in the if-guard, that its elements all match the chosen Rule.
-    let i_variable_pattern =
-        Ident::new("___variable_pattern", Span::call_site());
-    let match_pat = branch.pattern.iter().map(|item| match item {
-        Single { rule_name, .. } => quote!(stringify!(#rule_name)),
-        Multiple { .. } => quote!(#i_variable_pattern @ ..),
-    });
-    let match_filter = branch.pattern.iter().map(|item| match item {
-        Single { .. } => quote!(),
-        Multiple { rule_name, .. } => quote!(
-            {
-                // We can't use .all() directly in the pattern guard; see
-                // https://github.com/rust-lang/rust/issues/59803.
-                let all_match = |slice: &[_]| {
-                    slice.iter().all(|r|
-                        *r == stringify!(#rule_name)
-                    )
-                };
-                all_match(#i_variable_pattern)
-            } &&
-        ),
-    });
-
-    // Once we have found a branch that matches, we need to parse the children.
-    let mut singles_before_multiple = Vec::new();
-    let mut multiple = None;
-    let mut singles_after_multiple = Vec::new();
-    for item in &branch.pattern {
-        match item {
-            Single {
-                rule_name, binder, ..
-            } => {
-                if multiple.is_none() {
-                    singles_before_multiple.push((rule_name, binder))
-                } else {
-                    singles_after_multiple.push((rule_name, binder))
-                }
-            }
-            Multiple {
-                rule_name, binder, ..
-            } => {
-                if multiple.is_none() {
-                    multiple = Some((rule_name, binder))
-                } else {
-                    return Err(Error::new(
-                        branch.pattern_span.clone(),
-                        "multiple variable-length patterns are not allowed",
-                    ));
-                }
-            }
-        }
-    }
-    let mut parses = Vec::new();
-    for (rule_name, binder) in singles_before_multiple.into_iter() {
-        parses.push(quote!(
-            let #binder = Self::#rule_name(
-                #i_inputs.next().unwrap()
-            )?;
-        ))
-    }
-    // Note the `rev()`: we are taking inputs from the end of the iterator in reverse order, so that
-    // only the unmatched inputs are left for the variable-length pattern, if any.
-    for (rule_name, binder) in singles_after_multiple.into_iter().rev() {
-        parses.push(quote!(
-            let #binder = Self::#rule_name(
-                #i_inputs.next_back().unwrap()
-            )?;
-        ))
-    }
-    if let Some((rule_name, binder)) = multiple {
-        parses.push(quote!(
-            let #binder = #i_inputs
-                .map(|i| Self::#rule_name(i))
-                .collect::<Result<Vec<_>, _>>()?
-                .into_iter();
-        ))
-    }
-
-    Ok(quote!(
-        [#(#match_pat),*] if #(#match_filter)* true => {
-            #(#parses)*
-            #body
-        }
-    ))
-}
-
-pub fn parse_children(
-    input: proc_macro::TokenStream,
-) -> Result<proc_macro2::TokenStream> {
-    let input: ParseChildrenInput = syn::parse(input)?;
-
-    let i_input_rules = Ident::new("___input_rules", Span::call_site());
-    let i_inputs = Ident::new("___inputs", Span::call_site());
-
-    let input_expr = &input.input_expr;
-    let branches = input
-        .branches
-        .iter()
-        .map(|br| make_parser_branch(br, &i_inputs))
-        .collect::<Result<Vec<_>>>()?;
-
-    Ok(quote!({
-        #[allow(unused_mut)]
-        let mut #i_inputs = #input_expr;
-
-        let #i_input_rules = #i_inputs.aliased_rules::<Self>();
-        let #i_input_rules: Vec<&str> = #i_input_rules
-            .iter()
-            .map(String::as_str)
-            .collect();
-
-        #[allow(unreachable_code)]
-        match #i_input_rules.as_slice() {
-            #(#branches,)*
-            [..] => return Err(#i_inputs.error(
-                format!("Unexpected children: {:?}", #i_input_rules)
-            )),
-        }
-    }))
-}
-- 
cgit v1.2.3


From 7e9c8d5fbb1c6536012207073931b3db09345fad Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 10 Sep 2019 14:04:38 +0200
Subject: Remove custom pair debugging

---
 pest_consume/src/lib.rs | 52 -------------------------------------------------
 1 file changed, 52 deletions(-)

diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index 7e2c1ca..1a7d4f2 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -33,11 +33,6 @@ where
     }
     /// Create an error that points to the span of the input.
     pub fn error(&self, message: String) -> Error<Rule> {
-        let message = format!(
-            "{} while matching on:\n{}",
-            message,
-            debug_pair(self.pair.clone())
-        );
         Error::new_from_span(
             ErrorVariant::CustomError { message },
             self.as_span(),
@@ -116,53 +111,6 @@ pub trait PestConsumer {
     fn allows_shortcut(rule: Self::Rule) -> bool;
 }
 
-/// Pretty-print a pair and its nested children.
-fn debug_pair<Rule: pest::RuleType>(pair: Pair<Rule>) -> String {
-    use std::fmt::Write;
-    let mut s = String::new();
-    fn aux<Rule: pest::RuleType>(
-        s: &mut String,
-        indent: usize,
-        prefix: String,
-        pair: Pair<Rule>,
-    ) {
-        let indent_str = "| ".repeat(indent);
-        let rule = pair.as_rule();
-        let contents = pair.as_str();
-        let mut inner = pair.into_inner();
-        let mut first = true;
-        while let Some(p) = inner.next() {
-            if first {
-                first = false;
-                let last = inner.peek().is_none();
-                if last && p.as_str() == contents {
-                    let prefix = format!("{}{:?} > ", prefix, rule);
-                    aux(s, indent, prefix, p);
-                    continue;
-                } else {
-                    writeln!(
-                        s,
-                        r#"{}{}{:?}: "{}""#,
-                        indent_str, prefix, rule, contents
-                    )
-                    .unwrap();
-                }
-            }
-            aux(s, indent + 1, "".into(), p);
-        }
-        if first {
-            writeln!(
-                s,
-                r#"{}{}{:?}: "{}""#,
-                indent_str, prefix, rule, contents
-            )
-            .unwrap();
-        }
-    }
-    aux(&mut s, 0, "".into(), pair);
-    s
-}
-
 impl<'input, 'data, Rule, Data> Iterator
     for ParseInputs<'input, 'data, Rule, Data>
 where
-- 
cgit v1.2.3


From 9f3ada020ee7af61b80be24c0fb2f9a0b0a5a0bd Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 10 Sep 2019 14:21:09 +0200
Subject: Use match_inputs for parser entrypoint

---
 dhall_syntax/src/parser.rs | 20 +++++++++++++-------
 pest_consume/src/lib.rs    | 42 ++++++++++++++++++++++++++++++++++--------
 2 files changed, 47 insertions(+), 15 deletions(-)

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 761795a..15515f0 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -21,6 +21,8 @@ type ParsedText<E> = InterpolatedText<Expr<E>>;
 type ParsedTextContents<E> = InterpolatedTextContents<Expr<E>>;
 type ParseInput<'input, 'data> =
     pest_consume::ParseInput<'input, 'data, Rule, Rc<str>>;
+type ParseInputs<'input, 'data> =
+    pest_consume::ParseInputs<'input, 'data, Rule, Rc<str>>;
 
 pub type ParseError = pest::error::Error<Rule>;
 pub type ParseResult<T> = Result<T, ParseError>;
@@ -152,6 +154,15 @@ struct Parsers;
 
 #[make_parser(Rule)]
 impl Parsers {
+    fn entrypoint<E: Clone>(input_str: &str) -> ParseResult<Expr<E>> {
+        let pairs = DhallParser::parse(Rule::final_expression, input_str)?;
+        let rc_input_str = input_str.to_string().into();
+        let inputs = ParseInputs::new(input_str, pairs, &rc_input_str);
+        Ok(match_inputs!(inputs;
+            [expression(e)] => e,
+        ))
+    }
+
     fn EOI(_input: ParseInput) -> ParseResult<()> {
         Ok(())
     }
@@ -939,6 +950,7 @@ impl Parsers {
         ))
     }
 
+    #[alias(expression)]
     fn final_expression<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
         Ok(match_inputs!(input.children();
             [expression(e), EOI(_)] => e
@@ -947,11 +959,5 @@ impl Parsers {
 }
 
 pub fn parse_expr<E: Clone>(input_str: &str) -> ParseResult<Expr<E>> {
-    let mut pairs = DhallParser::parse(Rule::final_expression, input_str)?;
-    // TODO: proper errors
-    let pair = pairs.next().unwrap();
-    assert_eq!(pairs.next(), None);
-    let rc_input_str = input_str.to_string().into();
-    let input = ParseInput::new(pair, &rc_input_str);
-    Parsers::final_expression(input)
+    Parsers::entrypoint(input_str)
 }
diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index 1a7d4f2..d97c905 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -1,5 +1,5 @@
 use pest::error::{Error, ErrorVariant};
-use pest::iterators::Pair;
+use pest::iterators::{Pair, Pairs};
 use pest::Span;
 
 pub use pest_consume_macros::{make_parser, match_inputs};
@@ -20,8 +20,9 @@ pub struct ParseInputs<'input, 'data, Rule, Data>
 where
     Rule: pest::RuleType,
 {
-    input: ParseInput<'input, 'data, Rule, Data>,
-    pairs: pest::iterators::Pairs<'input, Rule>,
+    pairs: Pairs<'input, Rule>,
+    span: Span<'input>,
+    user_data: &'data Data,
 }
 
 impl<'input, 'data, Rule, Data> ParseInput<'input, 'data, Rule, Data>
@@ -60,8 +61,9 @@ where
     // (see https://github.com/rust-lang/rust/issues/61997).
     pub fn children(&self) -> ParseInputs<'input, 'data, Rule, Data> {
         ParseInputs {
-            input: self.clone(),
             pairs: self.as_pair().clone().into_inner(),
+            span: self.as_span(),
+            user_data: self.user_data(),
         }
     }
 
@@ -92,9 +94,25 @@ impl<'input, 'data, Rule, Data> ParseInputs<'input, 'data, Rule, Data>
 where
     Rule: pest::RuleType,
 {
+    /// `input` must be the _original_ input that `pairs` is pointing to.
+    pub fn new(
+        input: &'input str,
+        pairs: Pairs<'input, Rule>,
+        user_data: &'data Data,
+    ) -> Self {
+        let span = Span::new(input, 0, input.len()).unwrap();
+        ParseInputs {
+            pairs,
+            span,
+            user_data,
+        }
+    }
     /// Create an error that points to the span of the input.
     pub fn error(&self, message: String) -> Error<Rule> {
-        self.input.error(message)
+        Error::new_from_span(
+            ErrorVariant::CustomError { message },
+            self.span.clone(),
+        )
     }
     pub fn aliased_rules<T>(&self) -> Vec<String>
     where
@@ -102,6 +120,13 @@ where
     {
         self.clone().map(|p| p.as_rule_alias::<T>()).collect()
     }
+    /// Reconstruct the input with a new pair, passing the user data along.
+    fn with_pair(
+        &self,
+        new_pair: Pair<'input, Rule>,
+    ) -> ParseInput<'input, 'data, Rule, Data> {
+        ParseInput::new(new_pair, self.user_data)
+    }
 }
 
 /// Used by the macros.
@@ -120,7 +145,7 @@ where
 
     fn next(&mut self) -> Option<Self::Item> {
         let child_pair = self.pairs.next()?;
-        let child = self.input.with_pair(child_pair);
+        let child = self.with_pair(child_pair);
         Some(child)
     }
 }
@@ -132,7 +157,7 @@ where
 {
     fn next_back(&mut self) -> Option<Self::Item> {
         let child_pair = self.pairs.next_back()?;
-        let child = self.input.with_pair(child_pair);
+        let child = self.with_pair(child_pair);
         Some(child)
     }
 }
@@ -157,8 +182,9 @@ where
 {
     fn clone(&self) -> Self {
         ParseInputs {
-            input: self.input.clone(),
             pairs: self.pairs.clone(),
+            span: self.span.clone(),
+            user_data: self.user_data,
         }
     }
 }
-- 
cgit v1.2.3


From 88ec764ae1fed4481b9f745735be0ddf43b8f516 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 10 Sep 2019 14:28:00 +0200
Subject: Add dummy `entrypoint` attribute

---
 dhall_syntax/src/parser.rs             | 1 +
 pest_consume_macros/src/make_parser.rs | 7 +++++++
 2 files changed, 8 insertions(+)

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 15515f0..a83b8d0 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -154,6 +154,7 @@ struct Parsers;
 
 #[make_parser(Rule)]
 impl Parsers {
+    #[entrypoint]
     fn entrypoint<E: Clone>(input_str: &str) -> ParseResult<Expr<E>> {
         let pairs = DhallParser::parse(Rule::final_expression, input_str)?;
         let rc_input_str = input_str.to_string().into();
diff --git a/pest_consume_macros/src/make_parser.rs b/pest_consume_macros/src/make_parser.rs
index c0594a5..9de2f6f 100644
--- a/pest_consume_macros/src/make_parser.rs
+++ b/pest_consume_macros/src/make_parser.rs
@@ -155,6 +155,13 @@ fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Ident) -> Result<()> {
         #function
     );
 
+    // `prec_climb` attr
+    let _: () = function
+        .attrs
+        .drain_filter(|attr| attr.path.is_ident("entrypoint"))
+        .map(|_| ())
+        .collect();
+
     // `prec_climb` attr
     let prec_climb_attrs: Vec<_> = function
         .attrs
-- 
cgit v1.2.3


From 97f163475294a12f485a6c398df648ad0eeeca8c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 10 Sep 2019 14:34:58 +0200
Subject: Formatting

---
 pest_consume/src/lib.rs | 97 ++++++++++++++++---------------------------------
 1 file changed, 32 insertions(+), 65 deletions(-)

diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index d97c905..8f882a9 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -1,46 +1,37 @@
 use pest::error::{Error, ErrorVariant};
 use pest::iterators::{Pair, Pairs};
-use pest::Span;
+use pest::{RuleType, Span};
 
 pub use pest_consume_macros::{make_parser, match_inputs};
 
 /// Carries a pest Pair alongside custom user data.
 #[derive(Debug)]
-pub struct ParseInput<'input, 'data, Rule, Data>
-where
-    Rule: pest::RuleType,
-{
+pub struct ParseInput<'input, 'data, Rule: RuleType, Data> {
     pair: Pair<'input, Rule>,
     user_data: &'data Data,
 }
 
-/// Iterator over `ParseInput`s. It is created by `ParseInput::children`.
+/// Iterator over `ParseInput`s. It is created by `ParseInput::children` or `ParseInputs::new`.
 #[derive(Debug)]
-pub struct ParseInputs<'input, 'data, Rule, Data>
-where
-    Rule: pest::RuleType,
-{
+pub struct ParseInputs<'input, 'data, Rule: RuleType, Data> {
     pairs: Pairs<'input, Rule>,
     span: Span<'input>,
     user_data: &'data Data,
 }
 
-impl<'input, 'data, Rule, Data> ParseInput<'input, 'data, Rule, Data>
-where
-    Rule: pest::RuleType,
-{
-    pub fn new(pair: Pair<'input, Rule>, user_data: &'data Data) -> Self {
+impl<'i, 'd, R: RuleType, D> ParseInput<'i, 'd, R, D> {
+    pub fn new(pair: Pair<'i, R>, user_data: &'d D) -> Self {
         ParseInput { pair, user_data }
     }
     /// Create an error that points to the span of the input.
-    pub fn error(&self, message: String) -> Error<Rule> {
+    pub fn error(&self, message: String) -> Error<R> {
         Error::new_from_span(
             ErrorVariant::CustomError { message },
             self.as_span(),
         )
     }
     /// Reconstruct the input with a new pair, passing the user data along.
-    pub fn with_pair(&self, new_pair: Pair<'input, Rule>) -> Self {
+    pub fn with_pair(&self, new_pair: Pair<'i, R>) -> Self {
         ParseInput {
             pair: new_pair,
             user_data: self.user_data,
@@ -59,7 +50,7 @@ where
     /// Return an iterator over the children of this input
     // Can't use `-> impl Iterator` because of weird lifetime limitations
     // (see https://github.com/rust-lang/rust/issues/61997).
-    pub fn children(&self) -> ParseInputs<'input, 'data, Rule, Data> {
+    pub fn children(&self) -> ParseInputs<'i, 'd, R, D> {
         ParseInputs {
             pairs: self.as_pair().clone().into_inner(),
             span: self.as_span(),
@@ -67,39 +58,32 @@ where
         }
     }
 
-    pub fn user_data(&self) -> &'data Data {
+    pub fn user_data(&self) -> &'d D {
         self.user_data
     }
-    pub fn as_pair(&self) -> &Pair<'input, Rule> {
+    pub fn as_pair(&self) -> &Pair<'i, R> {
         &self.pair
     }
-    pub fn as_span(&self) -> Span<'input> {
+    pub fn as_span(&self) -> Span<'i> {
         self.pair.as_span()
     }
-    pub fn as_str(&self) -> &'input str {
+    pub fn as_str(&self) -> &'i str {
         self.pair.as_str()
     }
-    pub fn as_rule(&self) -> Rule {
+    pub fn as_rule(&self) -> R {
         self.pair.as_rule()
     }
-    pub fn as_rule_alias<T>(&self) -> String
+    pub fn as_rule_alias<C>(&self) -> String
     where
-        T: PestConsumer<Rule = Rule>,
+        C: PestConsumer<Rule = R>,
     {
-        T::rule_alias(self.as_rule())
+        C::rule_alias(self.as_rule())
     }
 }
 
-impl<'input, 'data, Rule, Data> ParseInputs<'input, 'data, Rule, Data>
-where
-    Rule: pest::RuleType,
-{
+impl<'i, 'd, R: RuleType, D> ParseInputs<'i, 'd, R, D> {
     /// `input` must be the _original_ input that `pairs` is pointing to.
-    pub fn new(
-        input: &'input str,
-        pairs: Pairs<'input, Rule>,
-        user_data: &'data Data,
-    ) -> Self {
+    pub fn new(input: &'i str, pairs: Pairs<'i, R>, user_data: &'d D) -> Self {
         let span = Span::new(input, 0, input.len()).unwrap();
         ParseInputs {
             pairs,
@@ -108,40 +92,33 @@ where
         }
     }
     /// Create an error that points to the span of the input.
-    pub fn error(&self, message: String) -> Error<Rule> {
+    pub fn error(&self, message: String) -> Error<R> {
         Error::new_from_span(
             ErrorVariant::CustomError { message },
             self.span.clone(),
         )
     }
-    pub fn aliased_rules<T>(&self) -> Vec<String>
+    pub fn aliased_rules<C>(&self) -> Vec<String>
     where
-        T: PestConsumer<Rule = Rule>,
+        C: PestConsumer<Rule = R>,
     {
-        self.clone().map(|p| p.as_rule_alias::<T>()).collect()
+        self.clone().map(|p| p.as_rule_alias::<C>()).collect()
     }
     /// Reconstruct the input with a new pair, passing the user data along.
-    fn with_pair(
-        &self,
-        new_pair: Pair<'input, Rule>,
-    ) -> ParseInput<'input, 'data, Rule, Data> {
+    fn with_pair(&self, new_pair: Pair<'i, R>) -> ParseInput<'i, 'd, R, D> {
         ParseInput::new(new_pair, self.user_data)
     }
 }
 
 /// Used by the macros.
 pub trait PestConsumer {
-    type Rule: pest::RuleType;
+    type Rule: RuleType;
     fn rule_alias(rule: Self::Rule) -> String;
     fn allows_shortcut(rule: Self::Rule) -> bool;
 }
 
-impl<'input, 'data, Rule, Data> Iterator
-    for ParseInputs<'input, 'data, Rule, Data>
-where
-    Rule: pest::RuleType,
-{
-    type Item = ParseInput<'input, 'data, Rule, Data>;
+impl<'i, 'd, R: RuleType, D> Iterator for ParseInputs<'i, 'd, R, D> {
+    type Item = ParseInput<'i, 'd, R, D>;
 
     fn next(&mut self) -> Option<Self::Item> {
         let child_pair = self.pairs.next()?;
@@ -150,11 +127,7 @@ where
     }
 }
 
-impl<'input, 'data, Rule, Data> DoubleEndedIterator
-    for ParseInputs<'input, 'data, Rule, Data>
-where
-    Rule: pest::RuleType,
-{
+impl<'i, 'd, R: RuleType, D> DoubleEndedIterator for ParseInputs<'i, 'd, R, D> {
     fn next_back(&mut self) -> Option<Self::Item> {
         let child_pair = self.pairs.next_back()?;
         let child = self.with_pair(child_pair);
@@ -162,11 +135,8 @@ where
     }
 }
 
-// Manual impl to avoid stupid `Data: Clone` trait bound
-impl<'input, 'data, Rule, Data> Clone for ParseInput<'input, 'data, Rule, Data>
-where
-    Rule: pest::RuleType,
-{
+// Manual impl to avoid stupid `D: Clone` trait bound
+impl<'i, 'd, R: RuleType, D> Clone for ParseInput<'i, 'd, R, D> {
     fn clone(&self) -> Self {
         ParseInput {
             pair: self.pair.clone(),
@@ -175,11 +145,8 @@ where
     }
 }
 
-// Manual impl to avoid stupid `Data: Clone` trait bound
-impl<'input, 'data, Rule, Data> Clone for ParseInputs<'input, 'data, Rule, Data>
-where
-    Rule: pest::RuleType,
-{
+// Manual impl to avoid stupid `D: Clone` trait bound
+impl<'i, 'd, R: RuleType, D> Clone for ParseInputs<'i, 'd, R, D> {
     fn clone(&self) -> Self {
         ParseInputs {
             pairs: self.pairs.clone(),
-- 
cgit v1.2.3


From 9f41dc5a4680cba3697c64da28855c8d4f437191 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 10 Sep 2019 14:51:37 +0200
Subject: Implement parsing in PestConsumer

---
 dhall_syntax/src/parser.rs             | 14 +++++++-------
 pest_consume/src/lib.rs                | 23 +++++++++++++++++++++++
 pest_consume_macros/src/make_parser.rs | 19 ++++++++++++++++++-
 3 files changed, 48 insertions(+), 8 deletions(-)

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index a83b8d0..a783f77 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -2,11 +2,10 @@ use itertools::Itertools;
 use pest::iterators::Pair;
 use pest::prec_climber as pcl;
 use pest::prec_climber::PrecClimber;
-use pest::Parser;
 use std::rc::Rc;
 
 use dhall_generated_parser::{DhallParser, Rule};
-use pest_consume::{make_parser, match_inputs};
+use pest_consume::{make_parser, match_inputs, PestConsumer};
 
 use crate::map::{DupTreeMap, DupTreeSet};
 use crate::ExprF::*;
@@ -21,8 +20,6 @@ type ParsedText<E> = InterpolatedText<Expr<E>>;
 type ParsedTextContents<E> = InterpolatedTextContents<Expr<E>>;
 type ParseInput<'input, 'data> =
     pest_consume::ParseInput<'input, 'data, Rule, Rc<str>>;
-type ParseInputs<'input, 'data> =
-    pest_consume::ParseInputs<'input, 'data, Rule, Rc<str>>;
 
 pub type ParseError = pest::error::Error<Rule>;
 pub type ParseResult<T> = Result<T, ParseError>;
@@ -152,13 +149,16 @@ lazy_static::lazy_static! {
 
 struct Parsers;
 
-#[make_parser(Rule)]
+#[make_parser(DhallParser, Rule)]
 impl Parsers {
     #[entrypoint]
     fn entrypoint<E: Clone>(input_str: &str) -> ParseResult<Expr<E>> {
-        let pairs = DhallParser::parse(Rule::final_expression, input_str)?;
         let rc_input_str = input_str.to_string().into();
-        let inputs = ParseInputs::new(input_str, pairs, &rc_input_str);
+        let inputs = Self::parse_with_userdata(
+            Rule::final_expression,
+            input_str,
+            &rc_input_str,
+        )?;
         Ok(match_inputs!(inputs;
             [expression(e)] => e,
         ))
diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index 8f882a9..1579f81 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -1,9 +1,12 @@
 use pest::error::{Error, ErrorVariant};
 use pest::iterators::{Pair, Pairs};
+use pest::Parser as PestParser;
 use pest::{RuleType, Span};
 
 pub use pest_consume_macros::{make_parser, match_inputs};
 
+static UNIT: () = ();
+
 /// Carries a pest Pair alongside custom user data.
 #[derive(Debug)]
 pub struct ParseInput<'input, 'data, Rule: RuleType, Data> {
@@ -76,6 +79,7 @@ impl<'i, 'd, R: RuleType, D> ParseInput<'i, 'd, R, D> {
     pub fn as_rule_alias<C>(&self) -> String
     where
         C: PestConsumer<Rule = R>,
+        <C as PestConsumer>::Parser: PestParser<R>,
     {
         C::rule_alias(self.as_rule())
     }
@@ -101,6 +105,7 @@ impl<'i, 'd, R: RuleType, D> ParseInputs<'i, 'd, R, D> {
     pub fn aliased_rules<C>(&self) -> Vec<String>
     where
         C: PestConsumer<Rule = R>,
+        <C as PestConsumer>::Parser: PestParser<R>,
     {
         self.clone().map(|p| p.as_rule_alias::<C>()).collect()
     }
@@ -113,8 +118,26 @@ impl<'i, 'd, R: RuleType, D> ParseInputs<'i, 'd, R, D> {
 /// Used by the macros.
 pub trait PestConsumer {
     type Rule: RuleType;
+    type Parser: PestParser<Self::Rule>;
     fn rule_alias(rule: Self::Rule) -> String;
     fn allows_shortcut(rule: Self::Rule) -> bool;
+
+    fn parse_with_userdata<'i, 'd, D>(
+        rule: Self::Rule,
+        input_str: &'i str,
+        user_data: &'d D,
+    ) -> Result<ParseInputs<'i, 'd, Self::Rule, D>, Error<Self::Rule>> {
+        let pairs = Self::Parser::parse(rule, input_str)?;
+        Ok(ParseInputs::new(input_str, pairs, user_data))
+    }
+
+    fn parse<'i>(
+        rule: Self::Rule,
+        input_str: &'i str,
+    ) -> Result<ParseInputs<'i, 'static, Self::Rule, ()>, Error<Self::Rule>>
+    {
+        Self::parse_with_userdata(rule, input_str, &UNIT)
+    }
 }
 
 impl<'i, 'd, R: RuleType, D> Iterator for ParseInputs<'i, 'd, R, D> {
diff --git a/pest_consume_macros/src/make_parser.rs b/pest_consume_macros/src/make_parser.rs
index 9de2f6f..0638c19 100644
--- a/pest_consume_macros/src/make_parser.rs
+++ b/pest_consume_macros/src/make_parser.rs
@@ -13,6 +13,11 @@ mod kw {
     syn::custom_keyword!(shortcut);
 }
 
+struct MakeParserAttrs {
+    parser: Ident,
+    rule_enum: Ident,
+}
+
 struct AliasArgs {
     target: Ident,
     is_shortcut: bool,
@@ -39,6 +44,15 @@ struct ParsedFn<'a> {
     alias_srcs: Vec<AliasSrc>,
 }
 
+impl Parse for MakeParserAttrs {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let parser = input.parse()?;
+        let _: Token![,] = input.parse()?;
+        let rule_enum = input.parse()?;
+        Ok(MakeParserAttrs { parser, rule_enum })
+    }
+}
+
 impl Parse for AliasArgs {
     fn parse(input: ParseStream) -> Result<Self> {
         let target = input.parse()?;
@@ -244,7 +258,9 @@ pub fn make_parser(
     attrs: proc_macro::TokenStream,
     input: proc_macro::TokenStream,
 ) -> Result<proc_macro2::TokenStream> {
-    let rule_enum: Ident = syn::parse(attrs)?;
+    let attrs: MakeParserAttrs = syn::parse(attrs)?;
+    let parser = &attrs.parser;
+    let rule_enum = &attrs.rule_enum;
     let mut imp: ItemImpl = syn::parse(input)?;
 
     let mut alias_map = collect_aliases(&mut imp)?;
@@ -322,6 +338,7 @@ pub fn make_parser(
     Ok(quote!(
         impl #impl_generics pest_consume::PestConsumer for #ty #where_clause {
             type Rule = #rule_enum;
+            type Parser = #parser;
             fn rule_alias(rule: Self::Rule) -> String {
                 match rule {
                     #(#rule_alias_branches)*
-- 
cgit v1.2.3


From e4003cc25efcae79c1332e3481d7edfca1067c4f Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 10 Sep 2019 15:04:26 +0200
Subject: Allows using match_inputs outside of a make_parser impl

---
 dhall_syntax/src/parser.rs              | 32 ++++++++++++++------------------
 pest_consume_macros/src/make_parser.rs  | 15 ++++-----------
 pest_consume_macros/src/match_inputs.rs | 28 ++++++++++++++++++++++------
 3 files changed, 40 insertions(+), 35 deletions(-)

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index a783f77..0d529bc 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -4,7 +4,8 @@ use pest::prec_climber as pcl;
 use pest::prec_climber::PrecClimber;
 use std::rc::Rc;
 
-use dhall_generated_parser::{DhallParser, Rule};
+use dgp::Rule;
+use dhall_generated_parser as dgp;
 use pest_consume::{make_parser, match_inputs, PestConsumer};
 
 use crate::map::{DupTreeMap, DupTreeSet};
@@ -147,23 +148,10 @@ lazy_static::lazy_static! {
     };
 }
 
-struct Parsers;
-
-#[make_parser(DhallParser, Rule)]
-impl Parsers {
-    #[entrypoint]
-    fn entrypoint<E: Clone>(input_str: &str) -> ParseResult<Expr<E>> {
-        let rc_input_str = input_str.to_string().into();
-        let inputs = Self::parse_with_userdata(
-            Rule::final_expression,
-            input_str,
-            &rc_input_str,
-        )?;
-        Ok(match_inputs!(inputs;
-            [expression(e)] => e,
-        ))
-    }
+struct DhallParser;
 
+#[make_parser(dgp::DhallParser, dgp::Rule)]
+impl DhallParser {
     fn EOI(_input: ParseInput) -> ParseResult<()> {
         Ok(())
     }
@@ -960,5 +948,13 @@ impl Parsers {
 }
 
 pub fn parse_expr<E: Clone>(input_str: &str) -> ParseResult<Expr<E>> {
-    Parsers::entrypoint(input_str)
+    let rc_input_str = input_str.to_string().into();
+    let inputs = DhallParser::parse_with_userdata(
+        Rule::final_expression,
+        input_str,
+        &rc_input_str,
+    )?;
+    Ok(match_inputs!(<DhallParser>; inputs;
+        [expression(e)] => e,
+    ))
 }
diff --git a/pest_consume_macros/src/make_parser.rs b/pest_consume_macros/src/make_parser.rs
index 0638c19..8a15deb 100644
--- a/pest_consume_macros/src/make_parser.rs
+++ b/pest_consume_macros/src/make_parser.rs
@@ -6,7 +6,7 @@ use syn::parse::{Parse, ParseStream, Result};
 use syn::spanned::Spanned;
 use syn::{
     parse_quote, Error, Expr, FnArg, Ident, ImplItem, ImplItemMethod, ItemImpl,
-    LitBool, Pat, Token,
+    LitBool, Pat, Path, Token,
 };
 
 mod kw {
@@ -14,8 +14,8 @@ mod kw {
 }
 
 struct MakeParserAttrs {
-    parser: Ident,
-    rule_enum: Ident,
+    parser: Path,
+    rule_enum: Path,
 }
 
 struct AliasArgs {
@@ -159,7 +159,7 @@ fn parse_fn<'a>(
     })
 }
 
-fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Ident) -> Result<()> {
+fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Path) -> Result<()> {
     let function = &mut *f.function;
     let fn_name = &f.fn_name;
     let input_arg = &f.input_arg;
@@ -169,13 +169,6 @@ fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Ident) -> Result<()> {
         #function
     );
 
-    // `prec_climb` attr
-    let _: () = function
-        .attrs
-        .drain_filter(|attr| attr.path.is_ident("entrypoint"))
-        .map(|_| ())
-        .collect();
-
     // `prec_climb` attr
     let prec_climb_attrs: Vec<_> = function
         .attrs
diff --git a/pest_consume_macros/src/match_inputs.rs b/pest_consume_macros/src/match_inputs.rs
index 3a325a6..d4bc492 100644
--- a/pest_consume_macros/src/match_inputs.rs
+++ b/pest_consume_macros/src/match_inputs.rs
@@ -3,7 +3,10 @@ use quote::quote;
 use syn::parse::{Parse, ParseStream, Result};
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
-use syn::{bracketed, parenthesized, token, Error, Expr, Ident, Pat, Token};
+use syn::{
+    bracketed, parenthesized, parse_quote, token, Error, Expr, Ident, Pat,
+    Token, Type,
+};
 
 #[derive(Debug, Clone)]
 struct ChildrenBranch {
@@ -20,6 +23,7 @@ enum ChildrenBranchPatternItem {
 
 #[derive(Debug, Clone)]
 struct ParseChildrenInput {
+    consumer: Type,
     input_expr: Expr,
     branches: Punctuated<ChildrenBranch, Token![,]>,
 }
@@ -62,11 +66,21 @@ impl Parse for ChildrenBranchPatternItem {
 
 impl Parse for ParseChildrenInput {
     fn parse(input: ParseStream) -> Result<Self> {
+        let consumer = if input.peek(token::Lt) {
+            let _: token::Lt = input.parse()?;
+            let consumer = input.parse()?;
+            let _: token::Gt = input.parse()?;
+            let _: Token![;] = input.parse()?;
+            consumer
+        } else {
+            parse_quote!(Self)
+        };
         let input_expr = input.parse()?;
         let _: Token![;] = input.parse()?;
         let branches = Punctuated::parse_terminated(input)?;
 
         Ok(ParseChildrenInput {
+            consumer,
             input_expr,
             branches,
         })
@@ -76,6 +90,7 @@ impl Parse for ParseChildrenInput {
 fn make_parser_branch(
     branch: &ChildrenBranch,
     i_inputs: &Ident,
+    consumer: &Type,
 ) -> Result<TokenStream> {
     use ChildrenBranchPatternItem::{Multiple, Single};
 
@@ -139,7 +154,7 @@ fn make_parser_branch(
     let mut parses = Vec::new();
     for (rule_name, binder) in singles_before_multiple.into_iter() {
         parses.push(quote!(
-            let #binder = Self::#rule_name(
+            let #binder = #consumer::#rule_name(
                 #i_inputs.next().unwrap()
             )?;
         ))
@@ -148,7 +163,7 @@ fn make_parser_branch(
     // only the unmatched inputs are left for the variable-length pattern, if any.
     for (rule_name, binder) in singles_after_multiple.into_iter().rev() {
         parses.push(quote!(
-            let #binder = Self::#rule_name(
+            let #binder = #consumer::#rule_name(
                 #i_inputs.next_back().unwrap()
             )?;
         ))
@@ -156,7 +171,7 @@ fn make_parser_branch(
     if let Some((rule_name, binder)) = multiple {
         parses.push(quote!(
             let #binder = #i_inputs
-                .map(|i| Self::#rule_name(i))
+                .map(|i| #consumer::#rule_name(i))
                 .collect::<Result<Vec<_>, _>>()?
                 .into_iter();
         ))
@@ -179,17 +194,18 @@ pub fn match_inputs(
     let i_inputs = Ident::new("___inputs", Span::call_site());
 
     let input_expr = &input.input_expr;
+    let consumer = &input.consumer;
     let branches = input
         .branches
         .iter()
-        .map(|br| make_parser_branch(br, &i_inputs))
+        .map(|br| make_parser_branch(br, &i_inputs, consumer))
         .collect::<Result<Vec<_>>>()?;
 
     Ok(quote!({
         #[allow(unused_mut)]
         let mut #i_inputs = #input_expr;
 
-        let #i_input_rules = #i_inputs.aliased_rules::<Self>();
+        let #i_input_rules = #i_inputs.aliased_rules::<#consumer>();
         let #i_input_rules: Vec<&str> = #i_input_rules
             .iter()
             .map(String::as_str)
-- 
cgit v1.2.3


From 20e75122354dc44468fa58c40e94a43a128aa764 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 10 Sep 2019 15:42:11 +0200
Subject: Use proc_macro_hack to avoid the need for the proc_macro_hygiene
 feature

---
 Cargo.lock                     | 13 +++++++++++++
 dhall_syntax/src/lib.rs        |  1 -
 pest_consume/Cargo.toml        |  1 +
 pest_consume/src/lib.rs        |  4 +++-
 pest_consume_macros/Cargo.toml |  1 +
 pest_consume_macros/src/lib.rs |  2 +-
 6 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index dd650ff..bf9f18a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -244,12 +244,14 @@ version = "0.1.0"
 dependencies = [
  "pest 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "pest_consume_macros 0.1.0",
+ "proc-macro-hack 0.5.9 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "pest_consume_macros"
 version = "0.1.0"
 dependencies = [
+ "proc-macro-hack 0.5.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "proc-macro2 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "syn 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -296,6 +298,16 @@ dependencies = [
  "output_vt100 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "proc-macro-hack"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.2"
@@ -504,6 +516,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum pest_meta 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "df43fd99896fd72c485fe47542c7b500e4ac1e8700bf995544d1317a60ded547"
 "checksum pretty 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f60c0d9f6fc88ecdd245d90c1920ff76a430ab34303fc778d33b1d0a4c3bf6d3"
 "checksum pretty_assertions 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3f81e1644e1b54f5a68959a29aa86cde704219254669da328ecfdf6a1f09d427"
+"checksum proc-macro-hack 0.5.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e688f31d92ffd7c1ddc57a1b4e6d773c0f2a14ee437a4b0a4f5a69c80eb221c8"
 "checksum proc-macro2 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "175a40b9cf564ce9bf050654633dbf339978706b8ead1a907bb970b63185dd95"
 "checksum quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "053a8c8bcc71fcce321828dc897a98ab9760bef03a4fc36693c231e5b3216cfe"
 "checksum same-file 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "585e8ddcedc187886a30fa705c47985c3fa88d06624095856b36ca0b82ff4421"
diff --git a/dhall_syntax/src/lib.rs b/dhall_syntax/src/lib.rs
index 95f40c2..3e6db80 100644
--- a/dhall_syntax/src/lib.rs
+++ b/dhall_syntax/src/lib.rs
@@ -1,7 +1,6 @@
 #![feature(trace_macros)]
 #![feature(slice_patterns)]
 #![feature(never_type)]
-#![feature(proc_macro_hygiene)]
 #![allow(
     clippy::many_single_char_names,
     clippy::should_implement_trait,
diff --git a/pest_consume/Cargo.toml b/pest_consume/Cargo.toml
index 7b26d56..70bdd22 100644
--- a/pest_consume/Cargo.toml
+++ b/pest_consume/Cargo.toml
@@ -10,4 +10,5 @@ repository = "https://github.com/Nadrieril/dhall-rust"
 
 [dependencies]
 pest = "2.1"
+proc-macro-hack = "0.5.9"
 pest_consume_macros = { path = "../pest_consume_macros" }
diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index 1579f81..439effb 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -3,7 +3,9 @@ use pest::iterators::{Pair, Pairs};
 use pest::Parser as PestParser;
 use pest::{RuleType, Span};
 
-pub use pest_consume_macros::{make_parser, match_inputs};
+pub use pest_consume_macros::make_parser;
+#[proc_macro_hack::proc_macro_hack]
+pub use pest_consume_macros::match_inputs;
 
 static UNIT: () = ();
 
diff --git a/pest_consume_macros/Cargo.toml b/pest_consume_macros/Cargo.toml
index dd65d95..317fd29 100644
--- a/pest_consume_macros/Cargo.toml
+++ b/pest_consume_macros/Cargo.toml
@@ -15,4 +15,5 @@ doctest = false
 [dependencies]
 quote = "1.0.2"
 proc-macro2 = "1.0.2"
+proc-macro-hack = "0.5.9"
 syn = { version = "1.0.5", features = ["full", "extra-traits"] }
diff --git a/pest_consume_macros/src/lib.rs b/pest_consume_macros/src/lib.rs
index b5368ec..3929974 100644
--- a/pest_consume_macros/src/lib.rs
+++ b/pest_consume_macros/src/lib.rs
@@ -19,7 +19,7 @@ pub fn make_parser(attrs: TokenStream, input: TokenStream) -> TokenStream {
     })
 }
 
-#[proc_macro]
+#[proc_macro_hack::proc_macro_hack]
 pub fn match_inputs(input: TokenStream) -> TokenStream {
     TokenStream::from(match match_inputs::match_inputs(input) {
         Ok(tokens) => tokens,
-- 
cgit v1.2.3


From 83ca228b1b0d3c40d2a1998dde45ecfef6fa0bb7 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 10 Sep 2019 15:43:24 +0200
Subject: Tentatively derive pest::Parser normally

If it still creates spurious recompilations, I'll revert that
---
 Cargo.lock                        | 14 ++++++++++++--
 dhall_generated_parser/Cargo.toml |  3 +--
 dhall_generated_parser/build.rs   | 17 -----------------
 dhall_generated_parser/src/lib.rs |  7 ++++++-
 dhall_syntax/Cargo.toml           |  1 +
 5 files changed, 20 insertions(+), 22 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bf9f18a..017e1b2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -91,8 +91,7 @@ version = "0.1.0"
 dependencies = [
  "abnf_to_pest 0.1.1",
  "pest 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "pest_generator 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pest_derive 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -118,6 +117,7 @@ dependencies = [
  "percent-encoding 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "pest 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "pest_consume 0.1.0",
+ "pest_derive 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "take_mut 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
@@ -257,6 +257,15 @@ dependencies = [
  "syn 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "pest_derive"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "pest 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pest_generator 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "pest_generator"
 version = "2.1.1"
@@ -512,6 +521,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum output_vt100 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "53cdc5b785b7a58c5aad8216b3dfa114df64b0b06ae6e1501cef91df2fbdf8f9"
 "checksum percent-encoding 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
 "checksum pest 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7e4fb201c5c22a55d8b24fef95f78be52738e5e1361129be1b5e862ecdb6894a"
+"checksum pest_derive 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "833d1ae558dc601e9a60366421196a8d94bc0ac980476d0b67e1d0988d72b2d0"
 "checksum pest_generator 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7b9fcf299b5712d06ee128a556c94709aaa04512c4dffb8ead07c5c998447fc0"
 "checksum pest_meta 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "df43fd99896fd72c485fe47542c7b500e4ac1e8700bf995544d1317a60ded547"
 "checksum pretty 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f60c0d9f6fc88ecdd245d90c1920ff76a430ab34303fc778d33b1d0a4c3bf6d3"
diff --git a/dhall_generated_parser/Cargo.toml b/dhall_generated_parser/Cargo.toml
index 0730f60..b1f0d02 100644
--- a/dhall_generated_parser/Cargo.toml
+++ b/dhall_generated_parser/Cargo.toml
@@ -12,8 +12,7 @@ doctest = false
 
 [build-dependencies]
 abnf_to_pest = { version = "0.1.1", path = "../abnf_to_pest" }
-pest_generator = "2.1"
-quote = "1.0.2"
 
 [dependencies]
 pest = "2.1"
+pest_derive = "2.1"
diff --git a/dhall_generated_parser/build.rs b/dhall_generated_parser/build.rs
index c562fad..68895dd 100644
--- a/dhall_generated_parser/build.rs
+++ b/dhall_generated_parser/build.rs
@@ -1,7 +1,5 @@
-use std::env;
 use std::fs::File;
 use std::io::{BufRead, BufReader, Read, Write};
-use std::path::Path;
 
 use abnf_to_pest::render_rules_to_pest;
 
@@ -90,20 +88,5 @@ fn main() -> std::io::Result<()> {
     writeln!(&mut file)?;
     writeln!(&mut file, "{}", render_rules_to_pest(rules).pretty(80))?;
 
-    // Generate pest parser manually to avoid spurious recompilations
-    let derived = {
-        let pest_path = "dhall.pest";
-        let pest = quote::quote! {
-            #[grammar = #pest_path]
-            pub struct DhallParser;
-        };
-        pest_generator::derive_parser(pest, false)
-    };
-
-    let out_dir = env::var("OUT_DIR").unwrap();
-    let grammar_path = Path::new(&out_dir).join("grammar.rs");
-    let mut file = File::create(grammar_path)?;
-    writeln!(file, "pub struct DhallParser;\n{}", derived,)?;
-
     Ok(())
 }
diff --git a/dhall_generated_parser/src/lib.rs b/dhall_generated_parser/src/lib.rs
index 280b75e..fbb9ccd 100644
--- a/dhall_generated_parser/src/lib.rs
+++ b/dhall_generated_parser/src/lib.rs
@@ -14,4 +14,9 @@
 // additional overrides are done in ../build.rs.
 // The lines that are commented out in ./dhall.pest.visibility are marked as
 // silent (see pest docs for what that means) in the generated pest file.
-include!(concat!(env!("OUT_DIR"), "/grammar.rs"));
+
+use pest_derive::Parser;
+
+#[derive(Parser)]
+#[grammar = "dhall.pest"]
+pub struct DhallParser;
diff --git a/dhall_syntax/Cargo.toml b/dhall_syntax/Cargo.toml
index 450175c..8d9cca6 100644
--- a/dhall_syntax/Cargo.toml
+++ b/dhall_syntax/Cargo.toml
@@ -12,6 +12,7 @@ doctest = false
 itertools = "0.8.0"
 percent-encoding = "2.1.0"
 pest = "2.1"
+pest_derive = "2.1"
 either = "1.5.2"
 take_mut = "0.2.2"
 hex = "0.3.2"
-- 
cgit v1.2.3


From 65fd9a895ba3093f9b5d9d02fb8bd18a9be61808 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 10 Sep 2019 16:00:00 +0200
Subject: Avoid the use of drain_filter feature

---
 pest_consume_macros/src/lib.rs         |  1 -
 pest_consume_macros/src/make_parser.rs | 32 ++++++++++++++++++++++++++++----
 2 files changed, 28 insertions(+), 5 deletions(-)

diff --git a/pest_consume_macros/src/lib.rs b/pest_consume_macros/src/lib.rs
index 3929974..db21f37 100644
--- a/pest_consume_macros/src/lib.rs
+++ b/pest_consume_macros/src/lib.rs
@@ -1,4 +1,3 @@
-#![feature(drain_filter)]
 //! This crate contains the code-generation primitives for the [dhall-rust][dhall-rust] crate.
 //! This is highly unstable and breaks regularly; use at your own risk.
 //!
diff --git a/pest_consume_macros/src/make_parser.rs b/pest_consume_macros/src/make_parser.rs
index 8a15deb..4165046 100644
--- a/pest_consume_macros/src/make_parser.rs
+++ b/pest_consume_macros/src/make_parser.rs
@@ -9,6 +9,32 @@ use syn::{
     LitBool, Pat, Path, Token,
 };
 
+/// Ext. trait adding `partition_filter` to `Vec`. Would like to use `Vec::drain_filter`
+/// but it's unstable for now.
+pub trait VecPartitionFilterExt<Item> {
+    fn partition_filter<F>(&mut self, predicate: F) -> Vec<Item>
+    where
+        F: FnMut(&mut Item) -> bool;
+}
+
+impl<Item> VecPartitionFilterExt<Item> for Vec<Item> {
+    fn partition_filter<F>(&mut self, mut predicate: F) -> Vec<Item>
+    where
+        F: FnMut(&mut Item) -> bool,
+    {
+        let mut ret = Vec::new();
+        let mut i = 0;
+        while i != self.len() {
+            if predicate(&mut self[i]) {
+                ret.push(self.remove(i))
+            } else {
+                i += 1;
+            }
+        }
+        ret
+    }
+}
+
 mod kw {
     syn::custom_keyword!(shortcut);
 }
@@ -99,8 +125,7 @@ fn collect_aliases(
         let fn_name = function.sig.ident.clone();
         let mut alias_attrs = function
             .attrs
-            .drain_filter(|attr| attr.path.is_ident("alias"))
-            .collect::<Vec<_>>()
+            .partition_filter(|attr| attr.path.is_ident("alias"))
             .into_iter();
 
         if let Some(attr) = alias_attrs.next() {
@@ -172,8 +197,7 @@ fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Path) -> Result<()> {
     // `prec_climb` attr
     let prec_climb_attrs: Vec<_> = function
         .attrs
-        .drain_filter(|attr| attr.path.is_ident("prec_climb"))
-        .collect();
+        .partition_filter(|attr| attr.path.is_ident("prec_climb"));
 
     if prec_climb_attrs.len() > 1 {
         return Err(Error::new(
-- 
cgit v1.2.3


From 26f54b10314f90dc5457cd0760af7f109be78e5f Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 10 Sep 2019 16:29:48 +0200
Subject: Use an enum instead of strings for rule aliasing

---
 pest_consume/src/lib.rs                 |  7 +++---
 pest_consume_macros/src/make_parser.rs  | 42 ++++++++++++++++++++++++++-------
 pest_consume_macros/src/match_inputs.rs | 11 ++++-----
 3 files changed, 41 insertions(+), 19 deletions(-)

diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index 439effb..62361f2 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -78,7 +78,7 @@ impl<'i, 'd, R: RuleType, D> ParseInput<'i, 'd, R, D> {
     pub fn as_rule(&self) -> R {
         self.pair.as_rule()
     }
-    pub fn as_rule_alias<C>(&self) -> String
+    pub fn as_rule_alias<C>(&self) -> C::AliasedRule
     where
         C: PestConsumer<Rule = R>,
         <C as PestConsumer>::Parser: PestParser<R>,
@@ -104,7 +104,7 @@ impl<'i, 'd, R: RuleType, D> ParseInputs<'i, 'd, R, D> {
             self.span.clone(),
         )
     }
-    pub fn aliased_rules<C>(&self) -> Vec<String>
+    pub fn aliased_rules<C>(&self) -> Vec<C::AliasedRule>
     where
         C: PestConsumer<Rule = R>,
         <C as PestConsumer>::Parser: PestParser<R>,
@@ -120,8 +120,9 @@ impl<'i, 'd, R: RuleType, D> ParseInputs<'i, 'd, R, D> {
 /// Used by the macros.
 pub trait PestConsumer {
     type Rule: RuleType;
+    type AliasedRule: RuleType;
     type Parser: PestParser<Self::Rule>;
-    fn rule_alias(rule: Self::Rule) -> String;
+    fn rule_alias(rule: Self::Rule) -> Self::AliasedRule;
     fn allows_shortcut(rule: Self::Rule) -> bool;
 
     fn parse_with_userdata<'i, 'd, D>(
diff --git a/pest_consume_macros/src/make_parser.rs b/pest_consume_macros/src/make_parser.rs
index 4165046..e8d861f 100644
--- a/pest_consume_macros/src/make_parser.rs
+++ b/pest_consume_macros/src/make_parser.rs
@@ -136,6 +136,15 @@ fn collect_aliases(
                     is_shortcut: args.is_shortcut,
                 },
             );
+        } else {
+            // Self entry
+            alias_map
+                .entry(fn_name.clone())
+                .or_insert_with(Vec::new)
+                .push(AliasSrc {
+                    ident: fn_name,
+                    is_shortcut: false,
+                });
         }
         if let Some(attr) = alias_attrs.next() {
             return Err(Error::new(
@@ -238,17 +247,22 @@ fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Path) -> Result<()> {
     }
 
     // `alias` attr
-    if !f.alias_srcs.is_empty() {
-        let aliases = f.alias_srcs.iter().map(|src| &src.ident);
+    // f.alias_srcs has always at least 1 element because it has an entry pointing from itself.
+    if f.alias_srcs.len() > 1 {
+        let aliases = f
+            .alias_srcs
+            .iter()
+            .map(|src| &src.ident)
+            .filter(|i| i != &fn_name);
         let block = &function.block;
+        let self_ty = quote!(<Self as ::pest_consume::PestConsumer>);
         function.block = parse_quote!({
             let mut #input_arg = #input_arg;
             // While the current rule allows shortcutting, and there is a single child, and the
             // child can still be parsed by the current function, then skip to that child.
-            while <Self as pest_consume::PestConsumer>::allows_shortcut(#input_arg.as_rule()) {
+            while #self_ty::allows_shortcut(#input_arg.as_rule()) {
                 if let Some(child) = #input_arg.single_child() {
-                    if &<Self as pest_consume::PestConsumer>::rule_alias(child.as_rule())
-                            == stringify!(#fn_name) {
+                    if child.as_rule_alias::<Self>() == #self_ty::AliasedRule::#fn_name {
                         #input_arg = child;
                         continue;
                     }
@@ -287,10 +301,12 @@ pub fn make_parser(
         .map(|(tgt, src)| {
             let ident = &src.ident;
             quote!(
-                #rule_enum::#ident => stringify!(#tgt).to_string(),
+                #rule_enum::#ident => Self::AliasedRule::#tgt,
             )
         })
         .collect();
+    let aliased_rule_variants: Vec<_> =
+        alias_map.iter().map(|(tgt, _)| tgt.clone()).collect();
     let shortcut_branches: Vec<_> = alias_map
         .iter()
         .flat_map(|(_tgt, srcs)| srcs)
@@ -353,13 +369,21 @@ pub fn make_parser(
     let ty = &imp.self_ty;
     let (impl_generics, _, where_clause) = imp.generics.split_for_impl();
     Ok(quote!(
-        impl #impl_generics pest_consume::PestConsumer for #ty #where_clause {
+        #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+        #[allow(non_camel_case_types)]
+        enum AliasedRule {
+            #(#aliased_rule_variants,)*
+        }
+
+        impl #impl_generics ::pest_consume::PestConsumer for #ty #where_clause {
             type Rule = #rule_enum;
+            type AliasedRule = AliasedRule;
             type Parser = #parser;
-            fn rule_alias(rule: Self::Rule) -> String {
+            fn rule_alias(rule: Self::Rule) -> Self::AliasedRule {
                 match rule {
                     #(#rule_alias_branches)*
-                    r => format!("{:?}", r),
+                    // TODO: return a proper error ?
+                    r => unreachable!("Rule {:?} does not have a corresponding parsing method", r),
                 }
             }
             fn allows_shortcut(rule: Self::Rule) -> bool {
diff --git a/pest_consume_macros/src/match_inputs.rs b/pest_consume_macros/src/match_inputs.rs
index d4bc492..34bfd38 100644
--- a/pest_consume_macros/src/match_inputs.rs
+++ b/pest_consume_macros/src/match_inputs.rs
@@ -95,6 +95,8 @@ fn make_parser_branch(
     use ChildrenBranchPatternItem::{Multiple, Single};
 
     let body = &branch.body;
+    let aliased_rule =
+        quote!(<#consumer as ::pest_consume::PestConsumer>::AliasedRule);
 
     // Convert the input pattern into a pattern-match on the Rules of the children. This uses
     // slice_patterns.
@@ -103,7 +105,7 @@ fn make_parser_branch(
     let i_variable_pattern =
         Ident::new("___variable_pattern", Span::call_site());
     let match_pat = branch.pattern.iter().map(|item| match item {
-        Single { rule_name, .. } => quote!(stringify!(#rule_name)),
+        Single { rule_name, .. } => quote!(#aliased_rule::#rule_name),
         Multiple { .. } => quote!(#i_variable_pattern @ ..),
     });
     let match_filter = branch.pattern.iter().map(|item| match item {
@@ -114,7 +116,7 @@ fn make_parser_branch(
                 // https://github.com/rust-lang/rust/issues/59803.
                 let all_match = |slice: &[_]| {
                     slice.iter().all(|r|
-                        *r == stringify!(#rule_name)
+                        *r == #aliased_rule::#rule_name
                     )
                 };
                 all_match(#i_variable_pattern)
@@ -204,12 +206,7 @@ pub fn match_inputs(
     Ok(quote!({
         #[allow(unused_mut)]
         let mut #i_inputs = #input_expr;
-
         let #i_input_rules = #i_inputs.aliased_rules::<#consumer>();
-        let #i_input_rules: Vec<&str> = #i_input_rules
-            .iter()
-            .map(String::as_str)
-            .collect();
 
         #[allow(unreachable_code)]
         match #i_input_rules.as_slice() {
-- 
cgit v1.2.3


From 50f586844c096d98a7d5b07332a6a77dac4ec933 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 10 Sep 2019 17:34:59 +0200
Subject: Rename various bits of the pest_consume API

---
 dhall_syntax/src/parser.rs              |   6 +-
 pest_consume/src/lib.rs                 | 302 +++++++++++++++++---------------
 pest_consume_macros/src/lib.rs          |   2 +-
 pest_consume_macros/src/make_parser.rs  |   8 +-
 pest_consume_macros/src/match_inputs.rs |  27 ++-
 5 files changed, 180 insertions(+), 165 deletions(-)

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 0d529bc..74d2731 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -6,7 +6,7 @@ use std::rc::Rc;
 
 use dgp::Rule;
 use dhall_generated_parser as dgp;
-use pest_consume::{make_parser, match_inputs, PestConsumer};
+use pest_consume::{match_inputs, Parser};
 
 use crate::map::{DupTreeMap, DupTreeSet};
 use crate::ExprF::*;
@@ -20,7 +20,7 @@ use crate::*;
 type ParsedText<E> = InterpolatedText<Expr<E>>;
 type ParsedTextContents<E> = InterpolatedTextContents<Expr<E>>;
 type ParseInput<'input, 'data> =
-    pest_consume::ParseInput<'input, 'data, Rule, Rc<str>>;
+    pest_consume::Node<'input, 'data, Rule, Rc<str>>;
 
 pub type ParseError = pest::error::Error<Rule>;
 pub type ParseResult<T> = Result<T, ParseError>;
@@ -150,7 +150,7 @@ lazy_static::lazy_static! {
 
 struct DhallParser;
 
-#[make_parser(dgp::DhallParser, dgp::Rule)]
+#[pest_consume::parser(dgp::DhallParser, dgp::Rule)]
 impl DhallParser {
     fn EOI(_input: ParseInput) -> ParseResult<()> {
         Ok(())
diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index 62361f2..701fbba 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -1,183 +1,199 @@
-use pest::error::{Error, ErrorVariant};
-use pest::iterators::{Pair, Pairs};
+use pest::error::Error;
 use pest::Parser as PestParser;
-use pest::{RuleType, Span};
+use pest::RuleType;
 
-pub use pest_consume_macros::make_parser;
 #[proc_macro_hack::proc_macro_hack]
 pub use pest_consume_macros::match_inputs;
+pub use pest_consume_macros::parser;
 
 static UNIT: () = ();
 
-/// Carries a pest Pair alongside custom user data.
-#[derive(Debug)]
-pub struct ParseInput<'input, 'data, Rule: RuleType, Data> {
-    pair: Pair<'input, Rule>,
-    user_data: &'data Data,
-}
-
-/// Iterator over `ParseInput`s. It is created by `ParseInput::children` or `ParseInputs::new`.
-#[derive(Debug)]
-pub struct ParseInputs<'input, 'data, Rule: RuleType, Data> {
-    pairs: Pairs<'input, Rule>,
-    span: Span<'input>,
-    user_data: &'data Data,
-}
+mod node {
+    use super::Parser;
+    use pest::error::{Error, ErrorVariant};
+    use pest::iterators::{Pair, Pairs};
+    use pest::Parser as PestParser;
+    use pest::{RuleType, Span};
 
-impl<'i, 'd, R: RuleType, D> ParseInput<'i, 'd, R, D> {
-    pub fn new(pair: Pair<'i, R>, user_data: &'d D) -> Self {
-        ParseInput { pair, user_data }
+    /// Carries a pest Pair alongside custom user data.
+    #[derive(Debug)]
+    pub struct Node<'input, 'data, Rule: RuleType, Data> {
+        pair: Pair<'input, Rule>,
+        user_data: &'data Data,
     }
-    /// Create an error that points to the span of the input.
-    pub fn error(&self, message: String) -> Error<R> {
-        Error::new_from_span(
-            ErrorVariant::CustomError { message },
-            self.as_span(),
-        )
+
+    /// Iterator over `Node`s. It is created by `Node::children` or `Nodes::new`.
+    #[derive(Debug)]
+    pub struct Nodes<'input, 'data, Rule: RuleType, Data> {
+        pairs: Pairs<'input, Rule>,
+        span: Span<'input>,
+        user_data: &'data Data,
     }
-    /// Reconstruct the input with a new pair, passing the user data along.
-    pub fn with_pair(&self, new_pair: Pair<'i, R>) -> Self {
-        ParseInput {
-            pair: new_pair,
-            user_data: self.user_data,
+
+    impl<'i, 'd, R: RuleType, D> Node<'i, 'd, R, D> {
+        pub fn new(pair: Pair<'i, R>, user_data: &'d D) -> Self {
+            Node { pair, user_data }
         }
-    }
-    /// If the contained pair has exactly one child, return a new Self containing it.
-    pub fn single_child(&self) -> Option<Self> {
-        let mut children = self.pair.clone().into_inner();
-        if let Some(child) = children.next() {
-            if children.next().is_none() {
-                return Some(self.with_pair(child));
+        /// Create an error that points to the span of the input.
+        pub fn error(&self, message: String) -> Error<R> {
+            Error::new_from_span(
+                ErrorVariant::CustomError { message },
+                self.as_span(),
+            )
+        }
+        /// Reconstruct the input with a new pair, passing the user data along.
+        pub fn with_pair(&self, new_pair: Pair<'i, R>) -> Self {
+            Node {
+                pair: new_pair,
+                user_data: self.user_data,
             }
         }
-        None
-    }
-    /// Return an iterator over the children of this input
-    // Can't use `-> impl Iterator` because of weird lifetime limitations
-    // (see https://github.com/rust-lang/rust/issues/61997).
-    pub fn children(&self) -> ParseInputs<'i, 'd, R, D> {
-        ParseInputs {
-            pairs: self.as_pair().clone().into_inner(),
-            span: self.as_span(),
-            user_data: self.user_data(),
+        /// If the contained pair has exactly one child, return a new Self containing it.
+        pub fn single_child(&self) -> Option<Self> {
+            let mut children = self.pair.clone().into_inner();
+            if let Some(child) = children.next() {
+                if children.next().is_none() {
+                    return Some(self.with_pair(child));
+                }
+            }
+            None
+        }
+        /// Return an iterator over the children of this input
+        // Can't use `-> impl Iterator` because of weird lifetime limitations
+        // (see https://github.com/rust-lang/rust/issues/61997).
+        pub fn children(&self) -> Nodes<'i, 'd, R, D> {
+            Nodes {
+                pairs: self.as_pair().clone().into_inner(),
+                span: self.as_span(),
+                user_data: self.user_data(),
+            }
         }
-    }
 
-    pub fn user_data(&self) -> &'d D {
-        self.user_data
-    }
-    pub fn as_pair(&self) -> &Pair<'i, R> {
-        &self.pair
-    }
-    pub fn as_span(&self) -> Span<'i> {
-        self.pair.as_span()
-    }
-    pub fn as_str(&self) -> &'i str {
-        self.pair.as_str()
-    }
-    pub fn as_rule(&self) -> R {
-        self.pair.as_rule()
+        pub fn user_data(&self) -> &'d D {
+            self.user_data
+        }
+        pub fn as_pair(&self) -> &Pair<'i, R> {
+            &self.pair
+        }
+        pub fn as_span(&self) -> Span<'i> {
+            self.pair.as_span()
+        }
+        pub fn as_str(&self) -> &'i str {
+            self.pair.as_str()
+        }
+        pub fn as_rule(&self) -> R {
+            self.pair.as_rule()
+        }
+        pub fn as_aliased_rule<C>(&self) -> C::AliasedRule
+        where
+            C: Parser<Rule = R>,
+            <C as Parser>::Parser: PestParser<R>,
+        {
+            C::rule_alias(self.as_rule())
+        }
     }
-    pub fn as_rule_alias<C>(&self) -> C::AliasedRule
-    where
-        C: PestConsumer<Rule = R>,
-        <C as PestConsumer>::Parser: PestParser<R>,
-    {
-        C::rule_alias(self.as_rule())
+
+    impl<'i, 'd, R: RuleType, D> Nodes<'i, 'd, R, D> {
+        /// `input` must be the _original_ input that `pairs` is pointing to.
+        pub fn new(
+            input: &'i str,
+            pairs: Pairs<'i, R>,
+            user_data: &'d D,
+        ) -> Self {
+            let span = Span::new(input, 0, input.len()).unwrap();
+            Nodes {
+                pairs,
+                span,
+                user_data,
+            }
+        }
+        /// Create an error that points to the span of the input.
+        pub fn error(&self, message: String) -> Error<R> {
+            Error::new_from_span(
+                ErrorVariant::CustomError { message },
+                self.span.clone(),
+            )
+        }
+        pub fn aliased_rules<C>(&self) -> Vec<C::AliasedRule>
+        where
+            C: Parser<Rule = R>,
+            <C as Parser>::Parser: PestParser<R>,
+        {
+            self.clone().map(|p| p.as_aliased_rule::<C>()).collect()
+        }
+        /// Reconstruct the input with a new pair, passing the user data along.
+        fn with_pair(&self, new_pair: Pair<'i, R>) -> Node<'i, 'd, R, D> {
+            Node::new(new_pair, self.user_data)
+        }
     }
-}
 
-impl<'i, 'd, R: RuleType, D> ParseInputs<'i, 'd, R, D> {
-    /// `input` must be the _original_ input that `pairs` is pointing to.
-    pub fn new(input: &'i str, pairs: Pairs<'i, R>, user_data: &'d D) -> Self {
-        let span = Span::new(input, 0, input.len()).unwrap();
-        ParseInputs {
-            pairs,
-            span,
-            user_data,
+    impl<'i, 'd, R: RuleType, D> Iterator for Nodes<'i, 'd, R, D> {
+        type Item = Node<'i, 'd, R, D>;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            let child_pair = self.pairs.next()?;
+            let child = self.with_pair(child_pair);
+            Some(child)
         }
     }
-    /// Create an error that points to the span of the input.
-    pub fn error(&self, message: String) -> Error<R> {
-        Error::new_from_span(
-            ErrorVariant::CustomError { message },
-            self.span.clone(),
-        )
+
+    impl<'i, 'd, R: RuleType, D> DoubleEndedIterator for Nodes<'i, 'd, R, D> {
+        fn next_back(&mut self) -> Option<Self::Item> {
+            let child_pair = self.pairs.next_back()?;
+            let child = self.with_pair(child_pair);
+            Some(child)
+        }
     }
-    pub fn aliased_rules<C>(&self) -> Vec<C::AliasedRule>
-    where
-        C: PestConsumer<Rule = R>,
-        <C as PestConsumer>::Parser: PestParser<R>,
-    {
-        self.clone().map(|p| p.as_rule_alias::<C>()).collect()
+
+    // Manual impl to avoid stupid `D: Clone` trait bound
+    impl<'i, 'd, R: RuleType, D> Clone for Node<'i, 'd, R, D> {
+        fn clone(&self) -> Self {
+            Node {
+                pair: self.pair.clone(),
+                user_data: self.user_data,
+            }
+        }
     }
-    /// Reconstruct the input with a new pair, passing the user data along.
-    fn with_pair(&self, new_pair: Pair<'i, R>) -> ParseInput<'i, 'd, R, D> {
-        ParseInput::new(new_pair, self.user_data)
+
+    // Manual impl to avoid stupid `D: Clone` trait bound
+    impl<'i, 'd, R: RuleType, D> Clone for Nodes<'i, 'd, R, D> {
+        fn clone(&self) -> Self {
+            Nodes {
+                pairs: self.pairs.clone(),
+                span: self.span.clone(),
+                user_data: self.user_data,
+            }
+        }
     }
 }
 
+pub use node::{Node, Nodes};
+
 /// Used by the macros.
-pub trait PestConsumer {
+/// Do not implement manually.
+pub trait Parser {
     type Rule: RuleType;
     type AliasedRule: RuleType;
     type Parser: PestParser<Self::Rule>;
+
     fn rule_alias(rule: Self::Rule) -> Self::AliasedRule;
     fn allows_shortcut(rule: Self::Rule) -> bool;
 
-    fn parse_with_userdata<'i, 'd, D>(
-        rule: Self::Rule,
-        input_str: &'i str,
-        user_data: &'d D,
-    ) -> Result<ParseInputs<'i, 'd, Self::Rule, D>, Error<Self::Rule>> {
-        let pairs = Self::Parser::parse(rule, input_str)?;
-        Ok(ParseInputs::new(input_str, pairs, user_data))
-    }
-
+    /// Parses a `&str` starting from `rule`
     fn parse<'i>(
         rule: Self::Rule,
         input_str: &'i str,
-    ) -> Result<ParseInputs<'i, 'static, Self::Rule, ()>, Error<Self::Rule>>
-    {
+    ) -> Result<Nodes<'i, 'static, Self::Rule, ()>, Error<Self::Rule>> {
         Self::parse_with_userdata(rule, input_str, &UNIT)
     }
-}
-
-impl<'i, 'd, R: RuleType, D> Iterator for ParseInputs<'i, 'd, R, D> {
-    type Item = ParseInput<'i, 'd, R, D>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let child_pair = self.pairs.next()?;
-        let child = self.with_pair(child_pair);
-        Some(child)
-    }
-}
-
-impl<'i, 'd, R: RuleType, D> DoubleEndedIterator for ParseInputs<'i, 'd, R, D> {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        let child_pair = self.pairs.next_back()?;
-        let child = self.with_pair(child_pair);
-        Some(child)
-    }
-}
-
-// Manual impl to avoid stupid `D: Clone` trait bound
-impl<'i, 'd, R: RuleType, D> Clone for ParseInput<'i, 'd, R, D> {
-    fn clone(&self) -> Self {
-        ParseInput {
-            pair: self.pair.clone(),
-            user_data: self.user_data,
-        }
-    }
-}
 
-// Manual impl to avoid stupid `D: Clone` trait bound
-impl<'i, 'd, R: RuleType, D> Clone for ParseInputs<'i, 'd, R, D> {
-    fn clone(&self) -> Self {
-        ParseInputs {
-            pairs: self.pairs.clone(),
-            span: self.span.clone(),
-            user_data: self.user_data,
-        }
+    /// Parses a `&str` starting from `rule`, carrying `user_data` through the parser methods.
+    fn parse_with_userdata<'i, 'd, D>(
+        rule: Self::Rule,
+        input_str: &'i str,
+        user_data: &'d D,
+    ) -> Result<Nodes<'i, 'd, Self::Rule, D>, Error<Self::Rule>> {
+        let pairs = Self::Parser::parse(rule, input_str)?;
+        Ok(Nodes::new(input_str, pairs, user_data))
     }
 }
diff --git a/pest_consume_macros/src/lib.rs b/pest_consume_macros/src/lib.rs
index db21f37..7f9f464 100644
--- a/pest_consume_macros/src/lib.rs
+++ b/pest_consume_macros/src/lib.rs
@@ -11,7 +11,7 @@ mod match_inputs;
 use proc_macro::TokenStream;
 
 #[proc_macro_attribute]
-pub fn make_parser(attrs: TokenStream, input: TokenStream) -> TokenStream {
+pub fn parser(attrs: TokenStream, input: TokenStream) -> TokenStream {
     TokenStream::from(match make_parser::make_parser(attrs, input) {
         Ok(tokens) => tokens,
         Err(err) => err.to_compile_error(),
diff --git a/pest_consume_macros/src/make_parser.rs b/pest_consume_macros/src/make_parser.rs
index e8d861f..2ed3271 100644
--- a/pest_consume_macros/src/make_parser.rs
+++ b/pest_consume_macros/src/make_parser.rs
@@ -64,7 +64,7 @@ struct ParsedFn<'a> {
     function: &'a mut ImplItemMethod,
     // Name of the function.
     fn_name: Ident,
-    // Name of the first argument of the function, which should be of type `ParseInput`.
+    // Name of the first argument of the function, which should be of type `Node`.
     input_arg: Ident,
     // List of aliases pointing to this function
     alias_srcs: Vec<AliasSrc>,
@@ -255,14 +255,14 @@ fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Path) -> Result<()> {
             .map(|src| &src.ident)
             .filter(|i| i != &fn_name);
         let block = &function.block;
-        let self_ty = quote!(<Self as ::pest_consume::PestConsumer>);
+        let self_ty = quote!(<Self as ::pest_consume::Parser>);
         function.block = parse_quote!({
             let mut #input_arg = #input_arg;
             // While the current rule allows shortcutting, and there is a single child, and the
             // child can still be parsed by the current function, then skip to that child.
             while #self_ty::allows_shortcut(#input_arg.as_rule()) {
                 if let Some(child) = #input_arg.single_child() {
-                    if child.as_rule_alias::<Self>() == #self_ty::AliasedRule::#fn_name {
+                    if child.as_aliased_rule::<Self>() == #self_ty::AliasedRule::#fn_name {
                         #input_arg = child;
                         continue;
                     }
@@ -375,7 +375,7 @@ pub fn make_parser(
             #(#aliased_rule_variants,)*
         }
 
-        impl #impl_generics ::pest_consume::PestConsumer for #ty #where_clause {
+        impl #impl_generics ::pest_consume::Parser for #ty #where_clause {
             type Rule = #rule_enum;
             type AliasedRule = AliasedRule;
             type Parser = #parser;
diff --git a/pest_consume_macros/src/match_inputs.rs b/pest_consume_macros/src/match_inputs.rs
index 34bfd38..773f806 100644
--- a/pest_consume_macros/src/match_inputs.rs
+++ b/pest_consume_macros/src/match_inputs.rs
@@ -23,7 +23,7 @@ enum ChildrenBranchPatternItem {
 
 #[derive(Debug, Clone)]
 struct ParseChildrenInput {
-    consumer: Type,
+    parser: Type,
     input_expr: Expr,
     branches: Punctuated<ChildrenBranch, Token![,]>,
 }
@@ -66,12 +66,12 @@ impl Parse for ChildrenBranchPatternItem {
 
 impl Parse for ParseChildrenInput {
     fn parse(input: ParseStream) -> Result<Self> {
-        let consumer = if input.peek(token::Lt) {
+        let parser = if input.peek(token::Lt) {
             let _: token::Lt = input.parse()?;
-            let consumer = input.parse()?;
+            let parser = input.parse()?;
             let _: token::Gt = input.parse()?;
             let _: Token![;] = input.parse()?;
-            consumer
+            parser
         } else {
             parse_quote!(Self)
         };
@@ -80,7 +80,7 @@ impl Parse for ParseChildrenInput {
         let branches = Punctuated::parse_terminated(input)?;
 
         Ok(ParseChildrenInput {
-            consumer,
+            parser,
             input_expr,
             branches,
         })
@@ -90,13 +90,12 @@ impl Parse for ParseChildrenInput {
 fn make_parser_branch(
     branch: &ChildrenBranch,
     i_inputs: &Ident,
-    consumer: &Type,
+    parser: &Type,
 ) -> Result<TokenStream> {
     use ChildrenBranchPatternItem::{Multiple, Single};
 
     let body = &branch.body;
-    let aliased_rule =
-        quote!(<#consumer as ::pest_consume::PestConsumer>::AliasedRule);
+    let aliased_rule = quote!(<#parser as ::pest_consume::Parser>::AliasedRule);
 
     // Convert the input pattern into a pattern-match on the Rules of the children. This uses
     // slice_patterns.
@@ -156,7 +155,7 @@ fn make_parser_branch(
     let mut parses = Vec::new();
     for (rule_name, binder) in singles_before_multiple.into_iter() {
         parses.push(quote!(
-            let #binder = #consumer::#rule_name(
+            let #binder = #parser::#rule_name(
                 #i_inputs.next().unwrap()
             )?;
         ))
@@ -165,7 +164,7 @@ fn make_parser_branch(
     // only the unmatched inputs are left for the variable-length pattern, if any.
     for (rule_name, binder) in singles_after_multiple.into_iter().rev() {
         parses.push(quote!(
-            let #binder = #consumer::#rule_name(
+            let #binder = #parser::#rule_name(
                 #i_inputs.next_back().unwrap()
             )?;
         ))
@@ -173,7 +172,7 @@ fn make_parser_branch(
     if let Some((rule_name, binder)) = multiple {
         parses.push(quote!(
             let #binder = #i_inputs
-                .map(|i| #consumer::#rule_name(i))
+                .map(|i| #parser::#rule_name(i))
                 .collect::<Result<Vec<_>, _>>()?
                 .into_iter();
         ))
@@ -196,17 +195,17 @@ pub fn match_inputs(
     let i_inputs = Ident::new("___inputs", Span::call_site());
 
     let input_expr = &input.input_expr;
-    let consumer = &input.consumer;
+    let parser = &input.parser;
     let branches = input
         .branches
         .iter()
-        .map(|br| make_parser_branch(br, &i_inputs, consumer))
+        .map(|br| make_parser_branch(br, &i_inputs, parser))
         .collect::<Result<Vec<_>>>()?;
 
     Ok(quote!({
         #[allow(unused_mut)]
         let mut #i_inputs = #input_expr;
-        let #i_input_rules = #i_inputs.aliased_rules::<#consumer>();
+        let #i_input_rules = #i_inputs.aliased_rules::<#parser>();
 
         #[allow(unreachable_code)]
         match #i_input_rules.as_slice() {
-- 
cgit v1.2.3


From f1a4d315de5be701f29beb7d3c32af2e96f967b6 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 10 Sep 2019 17:41:40 +0200
Subject: No need to force user data to be a reference

---
 dhall_syntax/src/parser.rs |  17 +++-----
 pest_consume/src/lib.rs    | 103 ++++++++++++++++++++++-----------------------
 2 files changed, 56 insertions(+), 64 deletions(-)

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 74d2731..d945435 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -19,8 +19,7 @@ use crate::*;
 
 type ParsedText<E> = InterpolatedText<Expr<E>>;
 type ParsedTextContents<E> = InterpolatedTextContents<Expr<E>>;
-type ParseInput<'input, 'data> =
-    pest_consume::Node<'input, 'data, Rule, Rc<str>>;
+type ParseInput<'input> = pest_consume::Node<'input, Rule, Rc<str>>;
 
 pub type ParseError = pest::error::Error<Rule>;
 pub type ParseResult<T> = Result<T, ParseError>;
@@ -286,20 +285,16 @@ impl DhallParser {
             }
         ))
     }
-    fn single_quote_char<'a>(
-        input: ParseInput<'a, '_>,
-    ) -> ParseResult<&'a str> {
+    fn single_quote_char<'a>(input: ParseInput<'a>) -> ParseResult<&'a str> {
         Ok(input.as_str())
     }
     #[alias(single_quote_char)]
-    fn escaped_quote_pair<'a>(
-        _input: ParseInput<'a, '_>,
-    ) -> ParseResult<&'a str> {
+    fn escaped_quote_pair<'a>(_input: ParseInput<'a>) -> ParseResult<&'a str> {
         Ok("''")
     }
     #[alias(single_quote_char)]
     fn escaped_interpolation<'a>(
-        _input: ParseInput<'a, '_>,
+        _input: ParseInput<'a>,
     ) -> ParseResult<&'a str> {
         Ok("${")
     }
@@ -555,7 +550,7 @@ impl DhallParser {
         ))
     }
     fn posix_environment_variable_character<'a>(
-        input: ParseInput<'a, '_>,
+        input: ParseInput<'a>,
     ) -> ParseResult<&'a str> {
         Ok(match input.as_str() {
             "\\\"" => "\"",
@@ -952,7 +947,7 @@ pub fn parse_expr<E: Clone>(input_str: &str) -> ParseResult<Expr<E>> {
     let inputs = DhallParser::parse_with_userdata(
         Rule::final_expression,
         input_str,
-        &rc_input_str,
+        rc_input_str,
     )?;
     Ok(match_inputs!(<DhallParser>; inputs;
         [expression(e)] => e,
diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index 701fbba..425d8cf 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -6,8 +6,6 @@ use pest::RuleType;
 pub use pest_consume_macros::match_inputs;
 pub use pest_consume_macros::parser;
 
-static UNIT: () = ();
-
 mod node {
     use super::Parser;
     use pest::error::{Error, ErrorVariant};
@@ -16,22 +14,22 @@ mod node {
     use pest::{RuleType, Span};
 
     /// Carries a pest Pair alongside custom user data.
-    #[derive(Debug)]
-    pub struct Node<'input, 'data, Rule: RuleType, Data> {
+    #[derive(Debug, Clone)]
+    pub struct Node<'input, Rule: RuleType, Data> {
         pair: Pair<'input, Rule>,
-        user_data: &'data Data,
+        user_data: Data,
     }
 
     /// Iterator over `Node`s. It is created by `Node::children` or `Nodes::new`.
-    #[derive(Debug)]
-    pub struct Nodes<'input, 'data, Rule: RuleType, Data> {
+    #[derive(Debug, Clone)]
+    pub struct Nodes<'input, Rule: RuleType, Data> {
         pairs: Pairs<'input, Rule>,
         span: Span<'input>,
-        user_data: &'data Data,
+        user_data: Data,
     }
 
-    impl<'i, 'd, R: RuleType, D> Node<'i, 'd, R, D> {
-        pub fn new(pair: Pair<'i, R>, user_data: &'d D) -> Self {
+    impl<'i, R: RuleType, D> Node<'i, R, D> {
+        pub fn new(pair: Pair<'i, R>, user_data: D) -> Self {
             Node { pair, user_data }
         }
         /// Create an error that points to the span of the input.
@@ -42,14 +40,20 @@ mod node {
             )
         }
         /// Reconstruct the input with a new pair, passing the user data along.
-        pub fn with_pair(&self, new_pair: Pair<'i, R>) -> Self {
+        pub fn with_pair(&self, new_pair: Pair<'i, R>) -> Self
+        where
+            D: Clone,
+        {
             Node {
                 pair: new_pair,
-                user_data: self.user_data,
+                user_data: self.user_data.clone(),
             }
         }
         /// If the contained pair has exactly one child, return a new Self containing it.
-        pub fn single_child(&self) -> Option<Self> {
+        pub fn single_child(&self) -> Option<Self>
+        where
+            D: Clone,
+        {
             let mut children = self.pair.clone().into_inner();
             if let Some(child) = children.next() {
                 if children.next().is_none() {
@@ -61,7 +65,10 @@ mod node {
         /// Return an iterator over the children of this input
         // Can't use `-> impl Iterator` because of weird lifetime limitations
         // (see https://github.com/rust-lang/rust/issues/61997).
-        pub fn children(&self) -> Nodes<'i, 'd, R, D> {
+        pub fn children(&self) -> Nodes<'i, R, D>
+        where
+            D: Clone,
+        {
             Nodes {
                 pairs: self.as_pair().clone().into_inner(),
                 span: self.as_span(),
@@ -69,8 +76,11 @@ mod node {
             }
         }
 
-        pub fn user_data(&self) -> &'d D {
-            self.user_data
+        pub fn user_data(&self) -> D
+        where
+            D: Clone,
+        {
+            self.user_data.clone()
         }
         pub fn as_pair(&self) -> &Pair<'i, R> {
             &self.pair
@@ -93,13 +103,9 @@ mod node {
         }
     }
 
-    impl<'i, 'd, R: RuleType, D> Nodes<'i, 'd, R, D> {
+    impl<'i, R: RuleType, D> Nodes<'i, R, D> {
         /// `input` must be the _original_ input that `pairs` is pointing to.
-        pub fn new(
-            input: &'i str,
-            pairs: Pairs<'i, R>,
-            user_data: &'d D,
-        ) -> Self {
+        pub fn new(input: &'i str, pairs: Pairs<'i, R>, user_data: D) -> Self {
             let span = Span::new(input, 0, input.len()).unwrap();
             Nodes {
                 pairs,
@@ -116,19 +122,27 @@ mod node {
         }
         pub fn aliased_rules<C>(&self) -> Vec<C::AliasedRule>
         where
+            D: Clone,
             C: Parser<Rule = R>,
             <C as Parser>::Parser: PestParser<R>,
         {
             self.clone().map(|p| p.as_aliased_rule::<C>()).collect()
         }
         /// Reconstruct the input with a new pair, passing the user data along.
-        fn with_pair(&self, new_pair: Pair<'i, R>) -> Node<'i, 'd, R, D> {
-            Node::new(new_pair, self.user_data)
+        fn with_pair(&self, new_pair: Pair<'i, R>) -> Node<'i, R, D>
+        where
+            D: Clone,
+        {
+            Node::new(new_pair, self.user_data.clone())
         }
     }
 
-    impl<'i, 'd, R: RuleType, D> Iterator for Nodes<'i, 'd, R, D> {
-        type Item = Node<'i, 'd, R, D>;
+    impl<'i, R, D> Iterator for Nodes<'i, R, D>
+    where
+        R: RuleType,
+        D: Clone,
+    {
+        type Item = Node<'i, R, D>;
 
         fn next(&mut self) -> Option<Self::Item> {
             let child_pair = self.pairs.next()?;
@@ -137,34 +151,17 @@ mod node {
         }
     }
 
-    impl<'i, 'd, R: RuleType, D> DoubleEndedIterator for Nodes<'i, 'd, R, D> {
+    impl<'i, R, D> DoubleEndedIterator for Nodes<'i, R, D>
+    where
+        R: RuleType,
+        D: Clone,
+    {
         fn next_back(&mut self) -> Option<Self::Item> {
             let child_pair = self.pairs.next_back()?;
             let child = self.with_pair(child_pair);
             Some(child)
         }
     }
-
-    // Manual impl to avoid stupid `D: Clone` trait bound
-    impl<'i, 'd, R: RuleType, D> Clone for Node<'i, 'd, R, D> {
-        fn clone(&self) -> Self {
-            Node {
-                pair: self.pair.clone(),
-                user_data: self.user_data,
-            }
-        }
-    }
-
-    // Manual impl to avoid stupid `D: Clone` trait bound
-    impl<'i, 'd, R: RuleType, D> Clone for Nodes<'i, 'd, R, D> {
-        fn clone(&self) -> Self {
-            Nodes {
-                pairs: self.pairs.clone(),
-                span: self.span.clone(),
-                user_data: self.user_data,
-            }
-        }
-    }
 }
 
 pub use node::{Node, Nodes};
@@ -183,16 +180,16 @@ pub trait Parser {
     fn parse<'i>(
         rule: Self::Rule,
         input_str: &'i str,
-    ) -> Result<Nodes<'i, 'static, Self::Rule, ()>, Error<Self::Rule>> {
-        Self::parse_with_userdata(rule, input_str, &UNIT)
+    ) -> Result<Nodes<'i, Self::Rule, ()>, Error<Self::Rule>> {
+        Self::parse_with_userdata(rule, input_str, ())
     }
 
     /// Parses a `&str` starting from `rule`, carrying `user_data` through the parser methods.
-    fn parse_with_userdata<'i, 'd, D>(
+    fn parse_with_userdata<'i, D>(
         rule: Self::Rule,
         input_str: &'i str,
-        user_data: &'d D,
-    ) -> Result<Nodes<'i, 'd, Self::Rule, D>, Error<Self::Rule>> {
+        user_data: D,
+    ) -> Result<Nodes<'i, Self::Rule, D>, Error<Self::Rule>> {
         let pairs = Self::Parser::parse(rule, input_str)?;
         Ok(Nodes::new(input_str, pairs, user_data))
     }
-- 
cgit v1.2.3


From 810a3d8066c2efed3f7c74cfb171d17988168080 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 11 Sep 2019 21:10:38 +0200
Subject: Add an example to pest_consume

---
 Cargo.lock                         |  1 +
 pest_consume/Cargo.toml            |  3 ++
 pest_consume/examples/csv/csv.pest | 15 +++++++++
 pest_consume/examples/csv/main.rs  | 64 ++++++++++++++++++++++++++++++++++++++
 pest_consume/src/lib.rs            | 14 +++++++++
 5 files changed, 97 insertions(+)
 create mode 100644 pest_consume/examples/csv/csv.pest
 create mode 100644 pest_consume/examples/csv/main.rs

diff --git a/Cargo.lock b/Cargo.lock
index 017e1b2..82212fe 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -244,6 +244,7 @@ version = "0.1.0"
 dependencies = [
  "pest 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "pest_consume_macros 0.1.0",
+ "pest_derive 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "proc-macro-hack 0.5.9 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
diff --git a/pest_consume/Cargo.toml b/pest_consume/Cargo.toml
index 70bdd22..1e2b1af 100644
--- a/pest_consume/Cargo.toml
+++ b/pest_consume/Cargo.toml
@@ -12,3 +12,6 @@ repository = "https://github.com/Nadrieril/dhall-rust"
 pest = "2.1"
 proc-macro-hack = "0.5.9"
 pest_consume_macros = { path = "../pest_consume_macros" }
+
+[dev-dependencies]
+pest_derive = "2.1"
diff --git a/pest_consume/examples/csv/csv.pest b/pest_consume/examples/csv/csv.pest
new file mode 100644
index 0000000..a67af8c
--- /dev/null
+++ b/pest_consume/examples/csv/csv.pest
@@ -0,0 +1,15 @@
+WHITESPACE = _{ " "+ }
+newline = _{ "\r\n" | "\n" }
+number = { "-"? ~ (ASCII_DIGIT | ".")+ }
+string = { (!"'" ~ ASCII)* }
+field = ${
+      number
+    | "'" ~ string ~ "'"
+}
+record = {
+      field ~ ("," ~ field)*
+    | ""
+}
+file = {
+    SOI ~ record ~ (newline ~ record)* ~ newline? ~ EOI
+}
diff --git a/pest_consume/examples/csv/main.rs b/pest_consume/examples/csv/main.rs
new file mode 100644
index 0000000..037948b
--- /dev/null
+++ b/pest_consume/examples/csv/main.rs
@@ -0,0 +1,64 @@
+#![feature(slice_patterns)]
+use pest_consume::{match_inputs, Parser};
+
+#[derive(pest_derive::Parser)]
+#[grammar = "../examples/csv/csv.pest"]
+struct CSVParser;
+
+type ParseResult<T> = Result<T, pest::error::Error<Rule>>;
+type Node<'i> = pest_consume::Node<'i, Rule, ()>;
+
+#[derive(Debug)]
+enum CSVField<'a> {
+    Number(f64),
+    String(&'a str),
+}
+
+type CSVRecord<'a> = Vec<CSVField<'a>>;
+type CSVFile<'a> = Vec<CSVRecord<'a>>;
+
+#[pest_consume::parser(CSVParser, Rule)]
+impl CSVParser {
+    fn EOI(_input: Node) -> ParseResult<()> {
+        Ok(())
+    }
+
+    fn number(input: Node) -> ParseResult<f64> {
+        Ok(input.as_str().parse().unwrap())
+    }
+
+    fn string(input: Node) -> ParseResult<&str> {
+        Ok(input.as_str())
+    }
+
+    fn field(input: Node) -> ParseResult<CSVField> {
+        Ok(match_inputs!(input.children();
+            [number(n)] => CSVField::Number(n),
+            [string(s)] => CSVField::String(s),
+        ))
+    }
+
+    fn record(input: Node) -> ParseResult<CSVRecord> {
+        Ok(match_inputs!(input.children();
+            [field(fields)..] => fields.collect(),
+        ))
+    }
+
+    fn file(input: Node) -> ParseResult<CSVFile> {
+        Ok(match_inputs!(input.children();
+            [record(records).., EOI(_)] => records.collect(),
+        ))
+    }
+}
+
+fn parse_csv(input_str: &str) -> ParseResult<CSVFile> {
+    let inputs = CSVParser::parse(Rule::file, input_str)?;
+    Ok(match_inputs!(<CSVParser>; inputs;
+        [file(e)] => e,
+    ))
+}
+
+fn main() {
+    let parsed = parse_csv("-273.15, ' a string '\n\n42, 0");
+    println!("{:?}", parsed);
+}
diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index 425d8cf..f14f6f5 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -1,3 +1,7 @@
+/// `pest_consume` extends [pest] to make it easy to consume the resulting pest parse tree.
+/// Given a grammar file, pest generates a parser that outputs an untyped parse tree. Then that
+/// parse tree needs to be transformed into whatever datastructures your application uses.
+/// `pest_consume` provides two powerful macros to make this easy.
 use pest::error::Error;
 use pest::Parser as PestParser;
 use pest::RuleType;
@@ -85,6 +89,9 @@ mod node {
         pub fn as_pair(&self) -> &Pair<'i, R> {
             &self.pair
         }
+        pub fn into_pair(self) -> Pair<'i, R> {
+            self.pair
+        }
         pub fn as_span(&self) -> Span<'i> {
             self.pair.as_span()
         }
@@ -135,6 +142,13 @@ mod node {
         {
             Node::new(new_pair, self.user_data.clone())
         }
+
+        pub fn as_pairs(&self) -> &Pairs<'i, R> {
+            &self.pairs
+        }
+        pub fn into_pairs(self) -> Pairs<'i, R> {
+            self.pairs
+        }
     }
 
     impl<'i, R, D> Iterator for Nodes<'i, R, D>
-- 
cgit v1.2.3


From f4f83af7831c309923feaf453069a6a75e181084 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 11 Sep 2019 21:11:39 +0200
Subject: Rename match_inputs to match_nodes to reflect new terminology

---
 dhall_syntax/src/parser.rs              |  76 +++++------
 pest_consume/examples/csv/main.rs       |  10 +-
 pest_consume/src/lib.rs                 |   2 +-
 pest_consume_macros/src/lib.rs          |   6 +-
 pest_consume_macros/src/match_inputs.rs | 218 --------------------------------
 pest_consume_macros/src/match_nodes.rs  | 218 ++++++++++++++++++++++++++++++++
 6 files changed, 265 insertions(+), 265 deletions(-)
 delete mode 100644 pest_consume_macros/src/match_inputs.rs
 create mode 100644 pest_consume_macros/src/match_nodes.rs

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index d945435..c0b9712 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -6,7 +6,7 @@ use std::rc::Rc;
 
 use dgp::Rule;
 use dhall_generated_parser as dgp;
-use pest_consume::{match_inputs, Parser};
+use pest_consume::{match_nodes, Parser};
 
 use crate::map::{DupTreeMap, DupTreeSet};
 use crate::ExprF::*;
@@ -167,7 +167,7 @@ impl DhallParser {
     fn double_quote_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ParsedText<E>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [double_quote_chunk(chunks)..] => {
                 chunks.collect()
             }
@@ -177,7 +177,7 @@ impl DhallParser {
     fn double_quote_chunk<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ParsedTextContents<E>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [expression(e)] => {
                 InterpolatedTextContents::Expr(e)
             },
@@ -264,7 +264,7 @@ impl DhallParser {
     fn single_quote_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ParsedText<E>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [single_quote_continue(lines)] => {
                 let newline: ParsedText<E> = "\n".to_string().into();
 
@@ -303,7 +303,7 @@ impl DhallParser {
     fn single_quote_continue<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Vec<Vec<ParsedTextContents<E>>>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [expression(e), single_quote_continue(lines)] => {
                 let c = InterpolatedTextContents::Expr(e);
                 let mut lines = lines;
@@ -388,7 +388,7 @@ impl DhallParser {
 
     #[alias(expression, shortcut = true)]
     fn identifier<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [variable(v)] => {
                 spanned(input, Var(v))
             },
@@ -397,7 +397,7 @@ impl DhallParser {
     }
 
     fn variable(input: ParseInput) -> ParseResult<V<Label>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [label(l), natural_literal(idx)] => {
                 V(l, idx)
             },
@@ -439,7 +439,7 @@ impl DhallParser {
             .collect())
     }
     fn path(input: ParseInput) -> ParseResult<Vec<String>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [path_component(components)..] => {
                 components.collect()
             }
@@ -450,7 +450,7 @@ impl DhallParser {
     fn local<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [local_path((prefix, p))] => ImportLocation::Local(prefix, p),
         ))
     }
@@ -459,19 +459,19 @@ impl DhallParser {
     fn parent_path(
         input: ParseInput,
     ) -> ParseResult<(FilePrefix, Vec<String>)> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [path(p)] => (FilePrefix::Parent, p)
         ))
     }
     #[alias(local_path)]
     fn here_path(input: ParseInput) -> ParseResult<(FilePrefix, Vec<String>)> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [path(p)] => (FilePrefix::Here, p)
         ))
     }
     #[alias(local_path)]
     fn home_path(input: ParseInput) -> ParseResult<(FilePrefix, Vec<String>)> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [path(p)] => (FilePrefix::Home, p)
         ))
     }
@@ -479,7 +479,7 @@ impl DhallParser {
     fn absolute_path(
         input: ParseInput,
     ) -> ParseResult<(FilePrefix, Vec<String>)> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [path(p)] => (FilePrefix::Absolute, p)
         ))
     }
@@ -493,7 +493,7 @@ impl DhallParser {
     }
 
     fn http_raw<E: Clone>(input: ParseInput) -> ParseResult<URL<Expr<E>>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [scheme(sch), authority(auth), path(p)] => URL {
                 scheme: sch,
                 authority: auth,
@@ -523,7 +523,7 @@ impl DhallParser {
     fn http<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
-        Ok(ImportLocation::Remote(match_inputs!(input.children();
+        Ok(ImportLocation::Remote(match_nodes!(input.children();
             [http_raw(url)] => url,
             [http_raw(url), expression(e)] => URL { headers: Some(e), ..url },
         )))
@@ -533,7 +533,7 @@ impl DhallParser {
     fn env<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [environment_variable(v)] => ImportLocation::Env(v),
         ))
     }
@@ -543,7 +543,7 @@ impl DhallParser {
     }
     #[alias(environment_variable)]
     fn posix_environment_variable(input: ParseInput) -> ParseResult<String> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [posix_environment_variable_character(chars)..] => {
                 chars.collect()
             },
@@ -588,7 +588,7 @@ impl DhallParser {
     ) -> ParseResult<crate::Import<Expr<E>>> {
         use crate::Import;
         let mode = ImportMode::Code;
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [import_type(location)] => Import { mode, location, hash: None },
             [import_type(location), hash(h)] => Import { mode, location, hash: Some(h) },
         ))
@@ -606,7 +606,7 @@ impl DhallParser {
     #[alias(expression)]
     fn import<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
         use crate::Import;
-        let import = match_inputs!(input.children();
+        let import = match_nodes!(input.children();
             [import_hashed(imp)] => {
                 Import { mode: ImportMode::Code, ..imp }
             },
@@ -641,13 +641,13 @@ impl DhallParser {
 
     #[alias(expression)]
     fn empty_list_literal<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [expression(e)] => spanned(input, EmptyListLit(e)),
         ))
     }
 
     fn expression<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [lambda(()), label(l), expression(typ),
                     arrow(()), expression(body)] => {
                 spanned(input, Lam(l, typ, body))
@@ -694,7 +694,7 @@ impl DhallParser {
     fn let_binding<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Label, Option<Expr<E>>, Expr<E>, Span)> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [label(name), expression(annot), expression(expr)] =>
                 (name, Some(annot), expr, input_to_span(input)),
             [label(name), expression(expr)] =>
@@ -744,7 +744,7 @@ impl DhallParser {
     fn application_expression<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [expression(e)] => e,
             [expression(first), expression(rest)..] => {
                 rest.fold(
@@ -765,7 +765,7 @@ impl DhallParser {
     fn first_application_expression<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [Some_(()), expression(e)] => {
                 spanned(input, SomeLit(e))
             },
@@ -783,7 +783,7 @@ impl DhallParser {
     fn selector_expression<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [expression(e)] => e,
             [expression(first), selector(rest)..] => {
                 rest.fold(
@@ -806,7 +806,7 @@ impl DhallParser {
     fn selector(
         input: ParseInput,
     ) -> ParseResult<(Either<Label, DupTreeSet<Label>>, Span)> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [label(l)] => (Either::Left(l), input_to_span(input)),
             [labels(ls)] => (Either::Right(ls), input_to_span(input)),
             // [expression(_e)] => unimplemented!("selection by expression"), // TODO
@@ -814,7 +814,7 @@ impl DhallParser {
     }
 
     fn labels(input: ParseInput) -> ParseResult<DupTreeSet<Label>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [label(ls)..] => ls.collect(),
         ))
     }
@@ -823,7 +823,7 @@ impl DhallParser {
     fn primitive_expression<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [double_literal(n)] => spanned(input, DoubleLit(n)),
             [natural_literal(n)] => spanned(input, NaturalLit(n)),
             [integer_literal(n)] => spanned(input, IntegerLit(n)),
@@ -849,7 +849,7 @@ impl DhallParser {
     fn non_empty_record_type_or_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        let e = match_inputs!(input.children();
+        let e = match_nodes!(input.children();
             [label(first_label), non_empty_record_type(rest)] => {
                 let (first_expr, mut map) = rest;
                 map.insert(first_label, first_expr);
@@ -867,7 +867,7 @@ impl DhallParser {
     fn non_empty_record_type<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Expr<E>, DupTreeMap<Label, Expr<E>>)> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [expression(expr), record_type_entry(entries)..] => {
                 (expr, entries.collect())
             }
@@ -877,7 +877,7 @@ impl DhallParser {
     fn record_type_entry<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Label, Expr<E>)> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [label(name), expression(expr)] => (name, expr)
         ))
     }
@@ -885,7 +885,7 @@ impl DhallParser {
     fn non_empty_record_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Expr<E>, DupTreeMap<Label, Expr<E>>)> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [expression(expr), record_literal_entry(entries)..] => {
                 (expr, entries.collect())
             }
@@ -895,14 +895,14 @@ impl DhallParser {
     fn record_literal_entry<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Label, Expr<E>)> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [label(name), expression(expr)] => (name, expr)
         ))
     }
 
     #[alias(expression)]
     fn union_type<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        let map = match_inputs!(input.children();
+        let map = match_nodes!(input.children();
             [empty_union_type(_)] => Default::default(),
             [union_type_entry(entries)..] => entries.collect(),
         );
@@ -916,7 +916,7 @@ impl DhallParser {
     fn union_type_entry<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Label, Option<Expr<E>>)> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [label(name), expression(expr)] => (name, Some(expr)),
             [label(name)] => (name, None),
         ))
@@ -926,7 +926,7 @@ impl DhallParser {
     fn non_empty_list_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [expression(items)..] => spanned(
                 input,
                 NEListLit(items.collect())
@@ -936,7 +936,7 @@ impl DhallParser {
 
     #[alias(expression)]
     fn final_expression<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [expression(e), EOI(_)] => e
         ))
     }
@@ -949,7 +949,7 @@ pub fn parse_expr<E: Clone>(input_str: &str) -> ParseResult<Expr<E>> {
         input_str,
         rc_input_str,
     )?;
-    Ok(match_inputs!(<DhallParser>; inputs;
+    Ok(match_nodes!(<DhallParser>; inputs;
         [expression(e)] => e,
     ))
 }
diff --git a/pest_consume/examples/csv/main.rs b/pest_consume/examples/csv/main.rs
index 037948b..bb9f8fc 100644
--- a/pest_consume/examples/csv/main.rs
+++ b/pest_consume/examples/csv/main.rs
@@ -1,5 +1,5 @@
 #![feature(slice_patterns)]
-use pest_consume::{match_inputs, Parser};
+use pest_consume::{match_nodes, Parser};
 
 #[derive(pest_derive::Parser)]
 #[grammar = "../examples/csv/csv.pest"]
@@ -32,20 +32,20 @@ impl CSVParser {
     }
 
     fn field(input: Node) -> ParseResult<CSVField> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [number(n)] => CSVField::Number(n),
             [string(s)] => CSVField::String(s),
         ))
     }
 
     fn record(input: Node) -> ParseResult<CSVRecord> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [field(fields)..] => fields.collect(),
         ))
     }
 
     fn file(input: Node) -> ParseResult<CSVFile> {
-        Ok(match_inputs!(input.children();
+        Ok(match_nodes!(input.children();
             [record(records).., EOI(_)] => records.collect(),
         ))
     }
@@ -53,7 +53,7 @@ impl CSVParser {
 
 fn parse_csv(input_str: &str) -> ParseResult<CSVFile> {
     let inputs = CSVParser::parse(Rule::file, input_str)?;
-    Ok(match_inputs!(<CSVParser>; inputs;
+    Ok(match_nodes!(<CSVParser>; inputs;
         [file(e)] => e,
     ))
 }
diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index f14f6f5..319810a 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -7,7 +7,7 @@ use pest::Parser as PestParser;
 use pest::RuleType;
 
 #[proc_macro_hack::proc_macro_hack]
-pub use pest_consume_macros::match_inputs;
+pub use pest_consume_macros::match_nodes;
 pub use pest_consume_macros::parser;
 
 mod node {
diff --git a/pest_consume_macros/src/lib.rs b/pest_consume_macros/src/lib.rs
index 7f9f464..d726b5d 100644
--- a/pest_consume_macros/src/lib.rs
+++ b/pest_consume_macros/src/lib.rs
@@ -6,7 +6,7 @@
 extern crate proc_macro;
 
 mod make_parser;
-mod match_inputs;
+mod match_nodes;
 
 use proc_macro::TokenStream;
 
@@ -19,8 +19,8 @@ pub fn parser(attrs: TokenStream, input: TokenStream) -> TokenStream {
 }
 
 #[proc_macro_hack::proc_macro_hack]
-pub fn match_inputs(input: TokenStream) -> TokenStream {
-    TokenStream::from(match match_inputs::match_inputs(input) {
+pub fn match_nodes(input: TokenStream) -> TokenStream {
+    TokenStream::from(match match_nodes::match_nodes(input) {
         Ok(tokens) => tokens,
         Err(err) => err.to_compile_error(),
     })
diff --git a/pest_consume_macros/src/match_inputs.rs b/pest_consume_macros/src/match_inputs.rs
deleted file mode 100644
index 773f806..0000000
--- a/pest_consume_macros/src/match_inputs.rs
+++ /dev/null
@@ -1,218 +0,0 @@
-use proc_macro2::{Span, TokenStream};
-use quote::quote;
-use syn::parse::{Parse, ParseStream, Result};
-use syn::punctuated::Punctuated;
-use syn::spanned::Spanned;
-use syn::{
-    bracketed, parenthesized, parse_quote, token, Error, Expr, Ident, Pat,
-    Token, Type,
-};
-
-#[derive(Debug, Clone)]
-struct ChildrenBranch {
-    pattern_span: Span,
-    pattern: Punctuated<ChildrenBranchPatternItem, Token![,]>,
-    body: Expr,
-}
-
-#[derive(Debug, Clone)]
-enum ChildrenBranchPatternItem {
-    Single { rule_name: Ident, binder: Pat },
-    Multiple { rule_name: Ident, binder: Ident },
-}
-
-#[derive(Debug, Clone)]
-struct ParseChildrenInput {
-    parser: Type,
-    input_expr: Expr,
-    branches: Punctuated<ChildrenBranch, Token![,]>,
-}
-
-impl Parse for ChildrenBranch {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let contents;
-        let _: token::Bracket = bracketed!(contents in input);
-        let pattern_unparsed: TokenStream = contents.fork().parse()?;
-        let pattern_span = pattern_unparsed.span();
-        let pattern = Punctuated::parse_terminated(&contents)?;
-        let _: Token![=>] = input.parse()?;
-        let body = input.parse()?;
-
-        Ok(ChildrenBranch {
-            pattern_span,
-            pattern,
-            body,
-        })
-    }
-}
-
-impl Parse for ChildrenBranchPatternItem {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let contents;
-        let rule_name = input.parse()?;
-        parenthesized!(contents in input);
-        if input.peek(Token![..]) {
-            let binder = contents.parse()?;
-            let _: Token![..] = input.parse()?;
-            Ok(ChildrenBranchPatternItem::Multiple { rule_name, binder })
-        } else if input.is_empty() || input.peek(Token![,]) {
-            let binder = contents.parse()?;
-            Ok(ChildrenBranchPatternItem::Single { rule_name, binder })
-        } else {
-            Err(input.error("expected `..` or nothing"))
-        }
-    }
-}
-
-impl Parse for ParseChildrenInput {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let parser = if input.peek(token::Lt) {
-            let _: token::Lt = input.parse()?;
-            let parser = input.parse()?;
-            let _: token::Gt = input.parse()?;
-            let _: Token![;] = input.parse()?;
-            parser
-        } else {
-            parse_quote!(Self)
-        };
-        let input_expr = input.parse()?;
-        let _: Token![;] = input.parse()?;
-        let branches = Punctuated::parse_terminated(input)?;
-
-        Ok(ParseChildrenInput {
-            parser,
-            input_expr,
-            branches,
-        })
-    }
-}
-
-fn make_parser_branch(
-    branch: &ChildrenBranch,
-    i_inputs: &Ident,
-    parser: &Type,
-) -> Result<TokenStream> {
-    use ChildrenBranchPatternItem::{Multiple, Single};
-
-    let body = &branch.body;
-    let aliased_rule = quote!(<#parser as ::pest_consume::Parser>::AliasedRule);
-
-    // Convert the input pattern into a pattern-match on the Rules of the children. This uses
-    // slice_patterns.
-    // A single pattern just checks that the rule matches; a variable-length pattern binds the
-    // subslice and checks, in the if-guard, that its elements all match the chosen Rule.
-    let i_variable_pattern =
-        Ident::new("___variable_pattern", Span::call_site());
-    let match_pat = branch.pattern.iter().map(|item| match item {
-        Single { rule_name, .. } => quote!(#aliased_rule::#rule_name),
-        Multiple { .. } => quote!(#i_variable_pattern @ ..),
-    });
-    let match_filter = branch.pattern.iter().map(|item| match item {
-        Single { .. } => quote!(),
-        Multiple { rule_name, .. } => quote!(
-            {
-                // We can't use .all() directly in the pattern guard; see
-                // https://github.com/rust-lang/rust/issues/59803.
-                let all_match = |slice: &[_]| {
-                    slice.iter().all(|r|
-                        *r == #aliased_rule::#rule_name
-                    )
-                };
-                all_match(#i_variable_pattern)
-            } &&
-        ),
-    });
-
-    // Once we have found a branch that matches, we need to parse the children.
-    let mut singles_before_multiple = Vec::new();
-    let mut multiple = None;
-    let mut singles_after_multiple = Vec::new();
-    for item in &branch.pattern {
-        match item {
-            Single {
-                rule_name, binder, ..
-            } => {
-                if multiple.is_none() {
-                    singles_before_multiple.push((rule_name, binder))
-                } else {
-                    singles_after_multiple.push((rule_name, binder))
-                }
-            }
-            Multiple {
-                rule_name, binder, ..
-            } => {
-                if multiple.is_none() {
-                    multiple = Some((rule_name, binder))
-                } else {
-                    return Err(Error::new(
-                        branch.pattern_span.clone(),
-                        "multiple variable-length patterns are not allowed",
-                    ));
-                }
-            }
-        }
-    }
-    let mut parses = Vec::new();
-    for (rule_name, binder) in singles_before_multiple.into_iter() {
-        parses.push(quote!(
-            let #binder = #parser::#rule_name(
-                #i_inputs.next().unwrap()
-            )?;
-        ))
-    }
-    // Note the `rev()`: we are taking inputs from the end of the iterator in reverse order, so that
-    // only the unmatched inputs are left for the variable-length pattern, if any.
-    for (rule_name, binder) in singles_after_multiple.into_iter().rev() {
-        parses.push(quote!(
-            let #binder = #parser::#rule_name(
-                #i_inputs.next_back().unwrap()
-            )?;
-        ))
-    }
-    if let Some((rule_name, binder)) = multiple {
-        parses.push(quote!(
-            let #binder = #i_inputs
-                .map(|i| #parser::#rule_name(i))
-                .collect::<Result<Vec<_>, _>>()?
-                .into_iter();
-        ))
-    }
-
-    Ok(quote!(
-        [#(#match_pat),*] if #(#match_filter)* true => {
-            #(#parses)*
-            #body
-        }
-    ))
-}
-
-pub fn match_inputs(
-    input: proc_macro::TokenStream,
-) -> Result<proc_macro2::TokenStream> {
-    let input: ParseChildrenInput = syn::parse(input)?;
-
-    let i_input_rules = Ident::new("___input_rules", Span::call_site());
-    let i_inputs = Ident::new("___inputs", Span::call_site());
-
-    let input_expr = &input.input_expr;
-    let parser = &input.parser;
-    let branches = input
-        .branches
-        .iter()
-        .map(|br| make_parser_branch(br, &i_inputs, parser))
-        .collect::<Result<Vec<_>>>()?;
-
-    Ok(quote!({
-        #[allow(unused_mut)]
-        let mut #i_inputs = #input_expr;
-        let #i_input_rules = #i_inputs.aliased_rules::<#parser>();
-
-        #[allow(unreachable_code)]
-        match #i_input_rules.as_slice() {
-            #(#branches,)*
-            [..] => return Err(#i_inputs.error(
-                format!("Unexpected children: {:?}", #i_input_rules)
-            )),
-        }
-    }))
-}
diff --git a/pest_consume_macros/src/match_nodes.rs b/pest_consume_macros/src/match_nodes.rs
new file mode 100644
index 0000000..251b7ef
--- /dev/null
+++ b/pest_consume_macros/src/match_nodes.rs
@@ -0,0 +1,218 @@
+use proc_macro2::{Span, TokenStream};
+use quote::quote;
+use syn::parse::{Parse, ParseStream, Result};
+use syn::punctuated::Punctuated;
+use syn::spanned::Spanned;
+use syn::{
+    bracketed, parenthesized, parse_quote, token, Error, Expr, Ident, Pat,
+    Token, Type,
+};
+
+#[derive(Debug, Clone)]
+struct ChildrenBranch {
+    pattern_span: Span,
+    pattern: Punctuated<ChildrenBranchPatternItem, Token![,]>,
+    body: Expr,
+}
+
+#[derive(Debug, Clone)]
+enum ChildrenBranchPatternItem {
+    Single { rule_name: Ident, binder: Pat },
+    Multiple { rule_name: Ident, binder: Ident },
+}
+
+#[derive(Debug, Clone)]
+struct ParseChildrenInput {
+    parser: Type,
+    input_expr: Expr,
+    branches: Punctuated<ChildrenBranch, Token![,]>,
+}
+
+impl Parse for ChildrenBranch {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let contents;
+        let _: token::Bracket = bracketed!(contents in input);
+        let pattern_unparsed: TokenStream = contents.fork().parse()?;
+        let pattern_span = pattern_unparsed.span();
+        let pattern = Punctuated::parse_terminated(&contents)?;
+        let _: Token![=>] = input.parse()?;
+        let body = input.parse()?;
+
+        Ok(ChildrenBranch {
+            pattern_span,
+            pattern,
+            body,
+        })
+    }
+}
+
+impl Parse for ChildrenBranchPatternItem {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let contents;
+        let rule_name = input.parse()?;
+        parenthesized!(contents in input);
+        if input.peek(Token![..]) {
+            let binder = contents.parse()?;
+            let _: Token![..] = input.parse()?;
+            Ok(ChildrenBranchPatternItem::Multiple { rule_name, binder })
+        } else if input.is_empty() || input.peek(Token![,]) {
+            let binder = contents.parse()?;
+            Ok(ChildrenBranchPatternItem::Single { rule_name, binder })
+        } else {
+            Err(input.error("expected `..` or nothing"))
+        }
+    }
+}
+
+impl Parse for ParseChildrenInput {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let parser = if input.peek(token::Lt) {
+            let _: token::Lt = input.parse()?;
+            let parser = input.parse()?;
+            let _: token::Gt = input.parse()?;
+            let _: Token![;] = input.parse()?;
+            parser
+        } else {
+            parse_quote!(Self)
+        };
+        let input_expr = input.parse()?;
+        let _: Token![;] = input.parse()?;
+        let branches = Punctuated::parse_terminated(input)?;
+
+        Ok(ParseChildrenInput {
+            parser,
+            input_expr,
+            branches,
+        })
+    }
+}
+
+fn make_parser_branch(
+    branch: &ChildrenBranch,
+    i_inputs: &Ident,
+    parser: &Type,
+) -> Result<TokenStream> {
+    use ChildrenBranchPatternItem::{Multiple, Single};
+
+    let body = &branch.body;
+    let aliased_rule = quote!(<#parser as ::pest_consume::Parser>::AliasedRule);
+
+    // Convert the input pattern into a pattern-match on the Rules of the children. This uses
+    // slice_patterns.
+    // A single pattern just checks that the rule matches; a variable-length pattern binds the
+    // subslice and checks, in the if-guard, that its elements all match the chosen Rule.
+    let i_variable_pattern =
+        Ident::new("___variable_pattern", Span::call_site());
+    let match_pat = branch.pattern.iter().map(|item| match item {
+        Single { rule_name, .. } => quote!(#aliased_rule::#rule_name),
+        Multiple { .. } => quote!(#i_variable_pattern @ ..),
+    });
+    let match_filter = branch.pattern.iter().map(|item| match item {
+        Single { .. } => quote!(),
+        Multiple { rule_name, .. } => quote!(
+            {
+                // We can't use .all() directly in the pattern guard; see
+                // https://github.com/rust-lang/rust/issues/59803.
+                let all_match = |slice: &[_]| {
+                    slice.iter().all(|r|
+                        *r == #aliased_rule::#rule_name
+                    )
+                };
+                all_match(#i_variable_pattern)
+            } &&
+        ),
+    });
+
+    // Once we have found a branch that matches, we need to parse the children.
+    let mut singles_before_multiple = Vec::new();
+    let mut multiple = None;
+    let mut singles_after_multiple = Vec::new();
+    for item in &branch.pattern {
+        match item {
+            Single {
+                rule_name, binder, ..
+            } => {
+                if multiple.is_none() {
+                    singles_before_multiple.push((rule_name, binder))
+                } else {
+                    singles_after_multiple.push((rule_name, binder))
+                }
+            }
+            Multiple {
+                rule_name, binder, ..
+            } => {
+                if multiple.is_none() {
+                    multiple = Some((rule_name, binder))
+                } else {
+                    return Err(Error::new(
+                        branch.pattern_span.clone(),
+                        "multiple variable-length patterns are not allowed",
+                    ));
+                }
+            }
+        }
+    }
+    let mut parses = Vec::new();
+    for (rule_name, binder) in singles_before_multiple.into_iter() {
+        parses.push(quote!(
+            let #binder = #parser::#rule_name(
+                #i_inputs.next().unwrap()
+            )?;
+        ))
+    }
+    // Note the `rev()`: we are taking inputs from the end of the iterator in reverse order, so that
+    // only the unmatched inputs are left for the variable-length pattern, if any.
+    for (rule_name, binder) in singles_after_multiple.into_iter().rev() {
+        parses.push(quote!(
+            let #binder = #parser::#rule_name(
+                #i_inputs.next_back().unwrap()
+            )?;
+        ))
+    }
+    if let Some((rule_name, binder)) = multiple {
+        parses.push(quote!(
+            let #binder = #i_inputs
+                .map(|i| #parser::#rule_name(i))
+                .collect::<Result<Vec<_>, _>>()?
+                .into_iter();
+        ))
+    }
+
+    Ok(quote!(
+        [#(#match_pat),*] if #(#match_filter)* true => {
+            #(#parses)*
+            #body
+        }
+    ))
+}
+
+pub fn match_nodes(
+    input: proc_macro::TokenStream,
+) -> Result<proc_macro2::TokenStream> {
+    let input: ParseChildrenInput = syn::parse(input)?;
+
+    let i_input_rules = Ident::new("___input_rules", Span::call_site());
+    let i_inputs = Ident::new("___inputs", Span::call_site());
+
+    let input_expr = &input.input_expr;
+    let parser = &input.parser;
+    let branches = input
+        .branches
+        .iter()
+        .map(|br| make_parser_branch(br, &i_inputs, parser))
+        .collect::<Result<Vec<_>>>()?;
+
+    Ok(quote!({
+        #[allow(unused_mut)]
+        let mut #i_inputs = #input_expr;
+        let #i_input_rules = #i_inputs.aliased_rules::<#parser>();
+
+        #[allow(unreachable_code)]
+        match #i_input_rules.as_slice() {
+            #(#branches,)*
+            [..] => return Err(#i_inputs.error(
+                format!("Unexpected children: {:?}", #i_input_rules)
+            )),
+        }
+    }))
+}
-- 
cgit v1.2.3


From 80bd718677080227f7b2e26744456cb13debca27 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 11 Sep 2019 22:42:15 +0200
Subject: Various tweaks

---
 dhall_syntax/src/parser.rs             | 14 +++++------
 pest_consume/Cargo.toml                |  4 +---
 pest_consume/examples/csv/main.rs      | 44 +++++++++++++++++++---------------
 pest_consume/src/lib.rs                |  3 +++
 pest_consume_macros/src/make_parser.rs | 18 +++++++-------
 pest_consume_macros/src/match_nodes.rs |  6 ++---
 6 files changed, 47 insertions(+), 42 deletions(-)

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index c0b9712..8f6f423 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -285,17 +285,15 @@ impl DhallParser {
             }
         ))
     }
-    fn single_quote_char<'a>(input: ParseInput<'a>) -> ParseResult<&'a str> {
+    fn single_quote_char(input: ParseInput) -> ParseResult<&str> {
         Ok(input.as_str())
     }
     #[alias(single_quote_char)]
-    fn escaped_quote_pair<'a>(_input: ParseInput<'a>) -> ParseResult<&'a str> {
+    fn escaped_quote_pair(_input: ParseInput) -> ParseResult<&str> {
         Ok("''")
     }
     #[alias(single_quote_char)]
-    fn escaped_interpolation<'a>(
-        _input: ParseInput<'a>,
-    ) -> ParseResult<&'a str> {
+    fn escaped_interpolation(_input: ParseInput) -> ParseResult<&str> {
         Ok("${")
     }
 
@@ -549,9 +547,9 @@ impl DhallParser {
             },
         ))
     }
-    fn posix_environment_variable_character<'a>(
-        input: ParseInput<'a>,
-    ) -> ParseResult<&'a str> {
+    fn posix_environment_variable_character(
+        input: ParseInput,
+    ) -> ParseResult<&str> {
         Ok(match input.as_str() {
             "\\\"" => "\"",
             "\\\\" => "\\",
diff --git a/pest_consume/Cargo.toml b/pest_consume/Cargo.toml
index 1e2b1af..1b8ebf6 100644
--- a/pest_consume/Cargo.toml
+++ b/pest_consume/Cargo.toml
@@ -10,8 +10,6 @@ repository = "https://github.com/Nadrieril/dhall-rust"
 
 [dependencies]
 pest = "2.1"
+pest_derive = "2.1"
 proc-macro-hack = "0.5.9"
 pest_consume_macros = { path = "../pest_consume_macros" }
-
-[dev-dependencies]
-pest_derive = "2.1"
diff --git a/pest_consume/examples/csv/main.rs b/pest_consume/examples/csv/main.rs
index bb9f8fc..efb83ad 100644
--- a/pest_consume/examples/csv/main.rs
+++ b/pest_consume/examples/csv/main.rs
@@ -1,57 +1,60 @@
 #![feature(slice_patterns)]
-use pest_consume::{match_nodes, Parser};
-
-#[derive(pest_derive::Parser)]
-#[grammar = "../examples/csv/csv.pest"]
-struct CSVParser;
-
-type ParseResult<T> = Result<T, pest::error::Error<Rule>>;
-type Node<'i> = pest_consume::Node<'i, Rule, ()>;
+use pest_consume::{match_nodes, Error, Parser};
 
 #[derive(Debug)]
 enum CSVField<'a> {
     Number(f64),
     String(&'a str),
 }
-
 type CSVRecord<'a> = Vec<CSVField<'a>>;
 type CSVFile<'a> = Vec<CSVRecord<'a>>;
 
+type Result<T> = std::result::Result<T, Error<Rule>>;
+type Node<'i> = pest_consume::Node<'i, Rule, ()>;
+
+#[derive(Parser)]
+#[grammar = "../examples/csv/csv.pest"]
+struct CSVParser;
+
 #[pest_consume::parser(CSVParser, Rule)]
 impl CSVParser {
-    fn EOI(_input: Node) -> ParseResult<()> {
+    fn EOI(_input: Node) -> Result<()> {
         Ok(())
     }
 
-    fn number(input: Node) -> ParseResult<f64> {
-        Ok(input.as_str().parse().unwrap())
+    fn number(input: Node) -> Result<f64> {
+        input
+            .as_str()
+            .parse::<f64>()
+            // `input.error` links the error to the location in the input file where it occurred.
+            .map_err(|e| input.error(e.to_string()))
     }
 
-    fn string(input: Node) -> ParseResult<&str> {
+    fn string(input: Node) -> Result<&str> {
         Ok(input.as_str())
     }
 
-    fn field(input: Node) -> ParseResult<CSVField> {
+    fn field(input: Node) -> Result<CSVField> {
         Ok(match_nodes!(input.children();
             [number(n)] => CSVField::Number(n),
             [string(s)] => CSVField::String(s),
         ))
     }
 
-    fn record(input: Node) -> ParseResult<CSVRecord> {
+    fn record(input: Node) -> Result<CSVRecord> {
         Ok(match_nodes!(input.children();
             [field(fields)..] => fields.collect(),
         ))
     }
 
-    fn file(input: Node) -> ParseResult<CSVFile> {
+    fn file(input: Node) -> Result<CSVFile> {
         Ok(match_nodes!(input.children();
             [record(records).., EOI(_)] => records.collect(),
         ))
     }
 }
 
-fn parse_csv(input_str: &str) -> ParseResult<CSVFile> {
+fn parse_csv(input_str: &str) -> Result<CSVFile> {
     let inputs = CSVParser::parse(Rule::file, input_str)?;
     Ok(match_nodes!(<CSVParser>; inputs;
         [file(e)] => e,
@@ -59,6 +62,9 @@ fn parse_csv(input_str: &str) -> ParseResult<CSVFile> {
 }
 
 fn main() {
-    let parsed = parse_csv("-273.15, ' a string '\n\n42, 0");
-    println!("{:?}", parsed);
+    let successful_parse = parse_csv("-273.15, ' a string '\n\n42, 0");
+    println!("success: {:?}", successful_parse.unwrap());
+
+    let unsuccessful_parse = parse_csv("0, 273.15.12");
+    println!("failure: {}", unsuccessful_parse.unwrap_err());
 }
diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index 319810a..dd6c1f2 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -3,8 +3,11 @@
 /// parse tree needs to be transformed into whatever datastructures your application uses.
 /// `pest_consume` provides two powerful macros to make this easy.
 use pest::error::Error;
+
+pub use pest::error::Error;
 use pest::Parser as PestParser;
 use pest::RuleType;
+pub use pest_derive::Parser;
 
 #[proc_macro_hack::proc_macro_hack]
 pub use pest_consume_macros::match_nodes;
diff --git a/pest_consume_macros/src/make_parser.rs b/pest_consume_macros/src/make_parser.rs
index 2ed3271..c30b12f 100644
--- a/pest_consume_macros/src/make_parser.rs
+++ b/pest_consume_macros/src/make_parser.rs
@@ -261,7 +261,7 @@ fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Path) -> Result<()> {
             // While the current rule allows shortcutting, and there is a single child, and the
             // child can still be parsed by the current function, then skip to that child.
             while #self_ty::allows_shortcut(#input_arg.as_rule()) {
-                if let Some(child) = #input_arg.single_child() {
+                if let ::std::option::Option::Some(child) = #input_arg.single_child() {
                     if child.as_aliased_rule::<Self>() == #self_ty::AliasedRule::#fn_name {
                         #input_arg = child;
                         continue;
@@ -273,9 +273,9 @@ fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Path) -> Result<()> {
             match #input_arg.as_rule() {
                 #(#rule_enum::#aliases => Self::#aliases(#input_arg),)*
                 #rule_enum::#fn_name => #block,
-                r => unreachable!(
+                r => ::std::unreachable!(
                     "make_parser: called {} on {:?}",
-                    stringify!(#fn_name),
+                    ::std::stringify!(#fn_name),
                     r
                 )
             }
@@ -349,14 +349,14 @@ pub fn make_parser(
                         #(#rule_enum::#srcs => Self::#srcs(#input_arg),)*
                         // We can't match on #rule_enum::#tgt since `tgt` might be an arbitrary
                         // identifier.
-                        r if &format!("{:?}", r) == stringify!(#tgt) =>
-                            return Err(#input_arg.error(format!(
+                        r if &::std::format!("{:?}", r) == ::std::stringify!(#tgt) =>
+                            return ::std::result::Result::Err(#input_arg.error(::std::format!(
                                 "make_parser: missing method for rule {}",
-                                stringify!(#tgt),
+                                ::std::stringify!(#tgt),
                             ))),
-                        r => unreachable!(
+                        r => ::std::unreachable!(
                             "make_parser: called {} on {:?}",
-                            stringify!(#tgt),
+                            ::std::stringify!(#tgt),
                             r
                         )
                     }
@@ -383,7 +383,7 @@ pub fn make_parser(
                 match rule {
                     #(#rule_alias_branches)*
                     // TODO: return a proper error ?
-                    r => unreachable!("Rule {:?} does not have a corresponding parsing method", r),
+                    r => ::std::unreachable!("Rule {:?} does not have a corresponding parsing method", r),
                 }
             }
             fn allows_shortcut(rule: Self::Rule) -> bool {
diff --git a/pest_consume_macros/src/match_nodes.rs b/pest_consume_macros/src/match_nodes.rs
index 251b7ef..4d9fd52 100644
--- a/pest_consume_macros/src/match_nodes.rs
+++ b/pest_consume_macros/src/match_nodes.rs
@@ -173,7 +173,7 @@ fn make_parser_branch(
         parses.push(quote!(
             let #binder = #i_inputs
                 .map(|i| #parser::#rule_name(i))
-                .collect::<Result<Vec<_>, _>>()?
+                .collect::<::std::result::Result<::std::vec::Vec<_>, _>>()?
                 .into_iter();
         ))
     }
@@ -210,8 +210,8 @@ pub fn match_nodes(
         #[allow(unreachable_code)]
         match #i_input_rules.as_slice() {
             #(#branches,)*
-            [..] => return Err(#i_inputs.error(
-                format!("Unexpected children: {:?}", #i_input_rules)
+            [..] => return ::std::result::Result::Err(#i_inputs.error(
+                std::format!("Unexpected children: {:?}", #i_input_rules)
             )),
         }
     }))
-- 
cgit v1.2.3


From 2a769a1890212fedfe09b685bb7b1bfe83ad7ac5 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 11 Sep 2019 22:42:21 +0200
Subject: Add basic doc to pest_consume

---
 pest_consume/src/lib.rs | 123 ++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 118 insertions(+), 5 deletions(-)

diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index dd6c1f2..e4c9f04 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -1,8 +1,121 @@
-/// `pest_consume` extends [pest] to make it easy to consume the resulting pest parse tree.
-/// Given a grammar file, pest generates a parser that outputs an untyped parse tree. Then that
-/// parse tree needs to be transformed into whatever datastructures your application uses.
-/// `pest_consume` provides two powerful macros to make this easy.
-use pest::error::Error;
+//! `pest_consume` extends [pest] to make it easy to consume a pest parse tree.
+//! Given a grammar file, pest generates a parser that outputs an untyped parse tree. Then that
+//! parse tree needs to be transformed into whatever datastructures your application uses.
+//! `pest_consume` provides two macros to make this easy.
+//!
+//! Features of `pest_consume` include:
+//! - strong types;
+//! - consuming children uses an intuitive syntax;
+//! - error handling is well integrated.
+//!
+//! # Example
+//!
+//! Here is the [CSV example from the doc](https://pest.rs/book/examples/csv.html),
+//! using `pest_consume`.
+//!
+//! The pest grammar file contains:
+//! ```text
+//! field = { (ASCII_DIGIT | "." | "-")+ }
+//! record = { field ~ ("," ~ field)* }
+//! file = { SOI ~ (record ~ ("\r\n" | "\n"))* ~ EOI }
+//! ```
+//!
+//! ```no_run
+//! #![feature(slice_patterns)]
+//! use pest_consume::{match_nodes, Error, Parser};
+//!
+//! type Result<T> = std::result::Result<T, Error<Rule>>;
+//! type Node<'i> = pest_consume::Node<'i, Rule, ()>;
+//!
+//! // Construct the first half of the parser using pest as usual.
+//! #[derive(Parser)]
+//! #[grammar = "../examples/csv/csv.pest"]
+//! struct CSVParser;
+//!
+//! // This is the other half of the parser, using pest_consume.
+//! #[pest_consume::parser(CSVParser, Rule)]
+//! impl CSVParser {
+//!     fn EOI(_input: Node) -> Result<()> {
+//!         Ok(())
+//!     }
+//!     fn field(input: Node) -> Result<f64> {
+//!         input
+//!             .as_str()
+//!             .parse::<f64>()
+//!             .map_err(|e| input.error(e.to_string()))
+//!     }
+//!     fn record(input: Node) -> Result<Vec<f64>> {
+//!         Ok(match_nodes!(input.children();
+//!             [field(fields)..] => fields.collect(),
+//!         ))
+//!     }
+//!     fn file(input: Node) -> Result<Vec<Vec<f64>>> {
+//!         Ok(match_nodes!(input.children();
+//!             [record(records).., EOI(_)] => records.collect(),
+//!         ))
+//!     }
+//! }
+//!
+//! fn parse_csv(input_str: &str) -> Result<Vec<Vec<f64>>> {
+//!     let inputs = CSVParser::parse(Rule::file, input_str)?;
+//!     Ok(match_nodes!(<CSVParser>; inputs;
+//!         [file(e)] => e,
+//!     ))
+//! }
+//!
+//! fn main() {
+//!     let parsed = parse_csv("-273.15, 12\n42, 0").unwrap();
+//!     let mut sum = 0.;
+//!     for record in parsed {
+//!         for field in record {
+//!             sum += field;
+//!         }
+//!     }
+//!     println!("{}", sum);
+//! }
+//! ```
+//!
+//! There are several things to note:
+//! - we use two macros provided by `pest_consume`: `parser` and `match_nodes`;
+//! - there is one `fn` item per (non-silent) rule in the grammar;
+//! - we associate an output type to every rule;
+//! - there is no need to fiddle with `.into_inner()`, `.next()` or `.unwrap()`, as is common when using pest
+//!
+//! # How it works
+//!
+//! The main types of this crate ([Node], [Nodes] and [Parser]) are mostly wrappers around
+//! the corresponding [pest] types.
+//!
+//! The `pest_consume::parser` macro does almost nothing when not using advanced features;
+//! most of the magic happens in `match_nodes`.
+//! `match_nodes` desugars rather straightforwardly into calls to the `fn` items corresponding to
+//! the rules matched on.
+//! For example:
+//! ```ignore
+//! match_nodes!(input.children();
+//!     [field(fields)..] => fields.collect(),
+//! )
+//! ```
+//! desugars into:
+//! ```ignore
+//! let nodes = { input.children() };
+//! if ... { // check that all rules in `nodes` are the `field` rule
+//!     let fields = nodes
+//!         .map(|node| Self::field(node)) // Recursively parse children nodes
+//!         ... // Propagate errors
+//!     { fields.collect() }
+//! } else {
+//!     ... // error because we got unexpected rules
+//! }
+//! ```
+//!
+//! # Advanced features
+//!
+//! TODO
+//!
+//! - rule aliasing
+//! - rule shortcutting
+//! - user data
 
 pub use pest::error::Error;
 use pest::Parser as PestParser;
-- 
cgit v1.2.3


From e029372fe2f44bedcff01649c2cc70fd60b2824c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 17 Sep 2019 18:35:53 +0200
Subject: Remove need for slice_patterns in pest_consume

---
 dhall_syntax/src/lib.rs                |  1 -
 pest_consume/examples/csv/main.rs      |  1 -
 pest_consume/src/lib.rs                |  1 -
 pest_consume_macros/src/match_nodes.rs | 79 ++++++++++++++++++++--------------
 4 files changed, 47 insertions(+), 35 deletions(-)

diff --git a/dhall_syntax/src/lib.rs b/dhall_syntax/src/lib.rs
index 3e6db80..b8fa19f 100644
--- a/dhall_syntax/src/lib.rs
+++ b/dhall_syntax/src/lib.rs
@@ -1,5 +1,4 @@
 #![feature(trace_macros)]
-#![feature(slice_patterns)]
 #![feature(never_type)]
 #![allow(
     clippy::many_single_char_names,
diff --git a/pest_consume/examples/csv/main.rs b/pest_consume/examples/csv/main.rs
index efb83ad..a045eb4 100644
--- a/pest_consume/examples/csv/main.rs
+++ b/pest_consume/examples/csv/main.rs
@@ -1,4 +1,3 @@
-#![feature(slice_patterns)]
 use pest_consume::{match_nodes, Error, Parser};
 
 #[derive(Debug)]
diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index e4c9f04..a161d3f 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -21,7 +21,6 @@
 //! ```
 //!
 //! ```no_run
-//! #![feature(slice_patterns)]
 //! use pest_consume::{match_nodes, Error, Parser};
 //!
 //! type Result<T> = std::result::Result<T, Error<Rule>>;
diff --git a/pest_consume_macros/src/match_nodes.rs b/pest_consume_macros/src/match_nodes.rs
index 4d9fd52..e4cd1e6 100644
--- a/pest_consume_macros/src/match_nodes.rs
+++ b/pest_consume_macros/src/match_nodes.rs
@@ -90,6 +90,7 @@ impl Parse for ParseChildrenInput {
 fn make_parser_branch(
     branch: &ChildrenBranch,
     i_inputs: &Ident,
+    i_input_rules: &Ident,
     parser: &Type,
 ) -> Result<TokenStream> {
     use ChildrenBranchPatternItem::{Multiple, Single};
@@ -97,33 +98,8 @@ fn make_parser_branch(
     let body = &branch.body;
     let aliased_rule = quote!(<#parser as ::pest_consume::Parser>::AliasedRule);
 
-    // Convert the input pattern into a pattern-match on the Rules of the children. This uses
-    // slice_patterns.
-    // A single pattern just checks that the rule matches; a variable-length pattern binds the
-    // subslice and checks, in the if-guard, that its elements all match the chosen Rule.
-    let i_variable_pattern =
-        Ident::new("___variable_pattern", Span::call_site());
-    let match_pat = branch.pattern.iter().map(|item| match item {
-        Single { rule_name, .. } => quote!(#aliased_rule::#rule_name),
-        Multiple { .. } => quote!(#i_variable_pattern @ ..),
-    });
-    let match_filter = branch.pattern.iter().map(|item| match item {
-        Single { .. } => quote!(),
-        Multiple { rule_name, .. } => quote!(
-            {
-                // We can't use .all() directly in the pattern guard; see
-                // https://github.com/rust-lang/rust/issues/59803.
-                let all_match = |slice: &[_]| {
-                    slice.iter().all(|r|
-                        *r == #aliased_rule::#rule_name
-                    )
-                };
-                all_match(#i_variable_pattern)
-            } &&
-        ),
-    });
-
-    // Once we have found a branch that matches, we need to parse the children.
+    // Patterns all have the form [a, b, c.., d], with a bunch of simple patterns,
+    // optionally a multiple pattern, and then some more simple patterns.
     let mut singles_before_multiple = Vec::new();
     let mut multiple = None;
     let mut singles_after_multiple = Vec::new();
@@ -152,6 +128,45 @@ fn make_parser_branch(
             }
         }
     }
+
+    // Find which branch to take
+    let mut conditions = Vec::new();
+    let start = singles_before_multiple.len();
+    let end = singles_after_multiple.len();
+    conditions.push(quote!(
+        #start + #end <= #i_input_rules.len()
+    ));
+    for (i, (rule_name, _)) in singles_before_multiple.iter().enumerate() {
+        conditions.push(quote!(
+            #i_input_rules[#i] == #aliased_rule::#rule_name
+        ))
+    }
+    for (i, (rule_name, _)) in singles_after_multiple.iter().enumerate() {
+        conditions.push(quote!(
+            #i_input_rules[#i_input_rules.len()-1 - #i] == #aliased_rule::#rule_name
+        ))
+    }
+    if let Some((rule_name, _)) = multiple {
+        conditions.push(quote!(
+            {
+                // We can't use .all() directly in the pattern guard; see
+                // https://github.com/rust-lang/rust/issues/59803.
+                let all_match = |slice: &[_]| {
+                    slice.iter().all(|r|
+                        *r == #aliased_rule::#rule_name
+                    )
+                };
+                all_match(&#i_input_rules[#start..#i_input_rules.len() - #end])
+            }
+        ))
+    } else {
+        // No variable-length pattern, so the size must be exactly the number of patterns
+        conditions.push(quote!(
+            #start + #end == #i_input_rules.len()
+        ))
+    }
+
+    // Once we have found a branch that matches, we need to parse the children.
     let mut parses = Vec::new();
     for (rule_name, binder) in singles_before_multiple.into_iter() {
         parses.push(quote!(
@@ -161,7 +176,7 @@ fn make_parser_branch(
         ))
     }
     // Note the `rev()`: we are taking inputs from the end of the iterator in reverse order, so that
-    // only the unmatched inputs are left for the variable-length pattern, if any.
+    // only the unmatched inputs are left in the iterator for the variable-length pattern, if any.
     for (rule_name, binder) in singles_after_multiple.into_iter().rev() {
         parses.push(quote!(
             let #binder = #parser::#rule_name(
@@ -179,7 +194,7 @@ fn make_parser_branch(
     }
 
     Ok(quote!(
-        [#(#match_pat),*] if #(#match_filter)* true => {
+        _ if #(#conditions &&)* true => {
             #(#parses)*
             #body
         }
@@ -199,7 +214,7 @@ pub fn match_nodes(
     let branches = input
         .branches
         .iter()
-        .map(|br| make_parser_branch(br, &i_inputs, parser))
+        .map(|br| make_parser_branch(br, &i_inputs, &i_input_rules, parser))
         .collect::<Result<Vec<_>>>()?;
 
     Ok(quote!({
@@ -208,9 +223,9 @@ pub fn match_nodes(
         let #i_input_rules = #i_inputs.aliased_rules::<#parser>();
 
         #[allow(unreachable_code)]
-        match #i_input_rules.as_slice() {
+        match () {
             #(#branches,)*
-            [..] => return ::std::result::Result::Err(#i_inputs.error(
+            _ => return ::std::result::Result::Err(#i_inputs.error(
                 std::format!("Unexpected children: {:?}", #i_input_rules)
             )),
         }
-- 
cgit v1.2.3


From 8958b9edd1c416d01d0501882ae13ce656195930 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 17 Sep 2019 18:42:53 +0200
Subject: Update terminology in match_nodes

---
 pest_consume_macros/src/match_nodes.rs | 72 +++++++++++++++++-----------------
 1 file changed, 36 insertions(+), 36 deletions(-)

diff --git a/pest_consume_macros/src/match_nodes.rs b/pest_consume_macros/src/match_nodes.rs
index e4cd1e6..4bf6025 100644
--- a/pest_consume_macros/src/match_nodes.rs
+++ b/pest_consume_macros/src/match_nodes.rs
@@ -9,26 +9,26 @@ use syn::{
 };
 
 #[derive(Debug, Clone)]
-struct ChildrenBranch {
+struct MatchBranch {
     pattern_span: Span,
-    pattern: Punctuated<ChildrenBranchPatternItem, Token![,]>,
+    pattern: Punctuated<MatchBranchPatternItem, Token![,]>,
     body: Expr,
 }
 
 #[derive(Debug, Clone)]
-enum ChildrenBranchPatternItem {
+enum MatchBranchPatternItem {
     Single { rule_name: Ident, binder: Pat },
     Multiple { rule_name: Ident, binder: Ident },
 }
 
 #[derive(Debug, Clone)]
-struct ParseChildrenInput {
+struct MacroInput {
     parser: Type,
     input_expr: Expr,
-    branches: Punctuated<ChildrenBranch, Token![,]>,
+    branches: Punctuated<MatchBranch, Token![,]>,
 }
 
-impl Parse for ChildrenBranch {
+impl Parse for MatchBranch {
     fn parse(input: ParseStream) -> Result<Self> {
         let contents;
         let _: token::Bracket = bracketed!(contents in input);
@@ -38,7 +38,7 @@ impl Parse for ChildrenBranch {
         let _: Token![=>] = input.parse()?;
         let body = input.parse()?;
 
-        Ok(ChildrenBranch {
+        Ok(MatchBranch {
             pattern_span,
             pattern,
             body,
@@ -46,7 +46,7 @@ impl Parse for ChildrenBranch {
     }
 }
 
-impl Parse for ChildrenBranchPatternItem {
+impl Parse for MatchBranchPatternItem {
     fn parse(input: ParseStream) -> Result<Self> {
         let contents;
         let rule_name = input.parse()?;
@@ -54,17 +54,17 @@ impl Parse for ChildrenBranchPatternItem {
         if input.peek(Token![..]) {
             let binder = contents.parse()?;
             let _: Token![..] = input.parse()?;
-            Ok(ChildrenBranchPatternItem::Multiple { rule_name, binder })
+            Ok(MatchBranchPatternItem::Multiple { rule_name, binder })
         } else if input.is_empty() || input.peek(Token![,]) {
             let binder = contents.parse()?;
-            Ok(ChildrenBranchPatternItem::Single { rule_name, binder })
+            Ok(MatchBranchPatternItem::Single { rule_name, binder })
         } else {
             Err(input.error("expected `..` or nothing"))
         }
     }
 }
 
-impl Parse for ParseChildrenInput {
+impl Parse for MacroInput {
     fn parse(input: ParseStream) -> Result<Self> {
         let parser = if input.peek(token::Lt) {
             let _: token::Lt = input.parse()?;
@@ -79,7 +79,7 @@ impl Parse for ParseChildrenInput {
         let _: Token![;] = input.parse()?;
         let branches = Punctuated::parse_terminated(input)?;
 
-        Ok(ParseChildrenInput {
+        Ok(MacroInput {
             parser,
             input_expr,
             branches,
@@ -87,13 +87,13 @@ impl Parse for ParseChildrenInput {
     }
 }
 
-fn make_parser_branch(
-    branch: &ChildrenBranch,
-    i_inputs: &Ident,
-    i_input_rules: &Ident,
+fn make_branch(
+    branch: &MatchBranch,
+    i_nodes: &Ident,
+    i_node_rules: &Ident,
     parser: &Type,
 ) -> Result<TokenStream> {
-    use ChildrenBranchPatternItem::{Multiple, Single};
+    use MatchBranchPatternItem::{Multiple, Single};
 
     let body = &branch.body;
     let aliased_rule = quote!(<#parser as ::pest_consume::Parser>::AliasedRule);
@@ -134,16 +134,16 @@ fn make_parser_branch(
     let start = singles_before_multiple.len();
     let end = singles_after_multiple.len();
     conditions.push(quote!(
-        #start + #end <= #i_input_rules.len()
+        #start + #end <= #i_node_rules.len()
     ));
     for (i, (rule_name, _)) in singles_before_multiple.iter().enumerate() {
         conditions.push(quote!(
-            #i_input_rules[#i] == #aliased_rule::#rule_name
+            #i_node_rules[#i] == #aliased_rule::#rule_name
         ))
     }
     for (i, (rule_name, _)) in singles_after_multiple.iter().enumerate() {
         conditions.push(quote!(
-            #i_input_rules[#i_input_rules.len()-1 - #i] == #aliased_rule::#rule_name
+            #i_node_rules[#i_node_rules.len()-1 - #i] == #aliased_rule::#rule_name
         ))
     }
     if let Some((rule_name, _)) = multiple {
@@ -156,37 +156,37 @@ fn make_parser_branch(
                         *r == #aliased_rule::#rule_name
                     )
                 };
-                all_match(&#i_input_rules[#start..#i_input_rules.len() - #end])
+                all_match(&#i_node_rules[#start..#i_node_rules.len() - #end])
             }
         ))
     } else {
         // No variable-length pattern, so the size must be exactly the number of patterns
         conditions.push(quote!(
-            #start + #end == #i_input_rules.len()
+            #start + #end == #i_node_rules.len()
         ))
     }
 
-    // Once we have found a branch that matches, we need to parse the children.
+    // Once we have found a branch that matches, we need to parse the nodes.
     let mut parses = Vec::new();
     for (rule_name, binder) in singles_before_multiple.into_iter() {
         parses.push(quote!(
             let #binder = #parser::#rule_name(
-                #i_inputs.next().unwrap()
+                #i_nodes.next().unwrap()
             )?;
         ))
     }
-    // Note the `rev()`: we are taking inputs from the end of the iterator in reverse order, so that
-    // only the unmatched inputs are left in the iterator for the variable-length pattern, if any.
+    // Note the `rev()`: we are taking nodes from the end of the iterator in reverse order, so that
+    // only the unmatched nodes are left in the iterator for the variable-length pattern, if any.
     for (rule_name, binder) in singles_after_multiple.into_iter().rev() {
         parses.push(quote!(
             let #binder = #parser::#rule_name(
-                #i_inputs.next_back().unwrap()
+                #i_nodes.next_back().unwrap()
             )?;
         ))
     }
     if let Some((rule_name, binder)) = multiple {
         parses.push(quote!(
-            let #binder = #i_inputs
+            let #binder = #i_nodes
                 .map(|i| #parser::#rule_name(i))
                 .collect::<::std::result::Result<::std::vec::Vec<_>, _>>()?
                 .into_iter();
@@ -204,29 +204,29 @@ fn make_parser_branch(
 pub fn match_nodes(
     input: proc_macro::TokenStream,
 ) -> Result<proc_macro2::TokenStream> {
-    let input: ParseChildrenInput = syn::parse(input)?;
+    let input: MacroInput = syn::parse(input)?;
 
-    let i_input_rules = Ident::new("___input_rules", Span::call_site());
-    let i_inputs = Ident::new("___inputs", Span::call_site());
+    let i_nodes = Ident::new("___nodes", input.input_expr.span());
+    let i_node_rules = Ident::new("___node_rules", Span::call_site());
 
     let input_expr = &input.input_expr;
     let parser = &input.parser;
     let branches = input
         .branches
         .iter()
-        .map(|br| make_parser_branch(br, &i_inputs, &i_input_rules, parser))
+        .map(|br| make_branch(br, &i_nodes, &i_node_rules, parser))
         .collect::<Result<Vec<_>>>()?;
 
     Ok(quote!({
         #[allow(unused_mut)]
-        let mut #i_inputs = #input_expr;
-        let #i_input_rules = #i_inputs.aliased_rules::<#parser>();
+        let mut #i_nodes = #input_expr;
+        let #i_node_rules = #i_nodes.aliased_rules::<#parser>();
 
         #[allow(unreachable_code)]
         match () {
             #(#branches,)*
-            _ => return ::std::result::Result::Err(#i_inputs.error(
-                std::format!("Unexpected children: {:?}", #i_input_rules)
+            _ => return ::std::result::Result::Err(#i_nodes.error(
+                std::format!("Nodes didn't match any pattern: {:?}", #i_node_rules)
             )),
         }
     }))
-- 
cgit v1.2.3


From f040f12e67f4da03773c4b28934ceefeb1c5b8b8 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 17 Sep 2019 18:58:32 +0200
Subject: Tweak match_nodes

---
 pest_consume_macros/Cargo.toml         |   2 +-
 pest_consume_macros/src/match_nodes.rs | 127 ++++++++++++++++++---------------
 2 files changed, 72 insertions(+), 57 deletions(-)

diff --git a/pest_consume_macros/Cargo.toml b/pest_consume_macros/Cargo.toml
index 317fd29..aaa0b10 100644
--- a/pest_consume_macros/Cargo.toml
+++ b/pest_consume_macros/Cargo.toml
@@ -16,4 +16,4 @@ doctest = false
 quote = "1.0.2"
 proc-macro2 = "1.0.2"
 proc-macro-hack = "0.5.9"
-syn = { version = "1.0.5", features = ["full", "extra-traits"] }
+syn = { version = "1.0.5", features = ["full"] }
diff --git a/pest_consume_macros/src/match_nodes.rs b/pest_consume_macros/src/match_nodes.rs
index 4bf6025..a91d1f4 100644
--- a/pest_consume_macros/src/match_nodes.rs
+++ b/pest_consume_macros/src/match_nodes.rs
@@ -8,20 +8,31 @@ use syn::{
     Token, Type,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 struct MatchBranch {
-    pattern_span: Span,
-    pattern: Punctuated<MatchBranchPatternItem, Token![,]>,
+    // Patterns all have the form [a, b, c.., d], with a bunch of simple patterns,
+    // optionally a multiple pattern, and then some more simple patterns.
+    singles_before_multiple: Vec<(Ident, Pat)>,
+    multiple: Option<(Ident, Ident)>,
+    singles_after_multiple: Vec<(Ident, Pat)>,
+
     body: Expr,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 enum MatchBranchPatternItem {
-    Single { rule_name: Ident, binder: Pat },
-    Multiple { rule_name: Ident, binder: Ident },
+    Single {
+        rule_name: Ident,
+        binder: Pat,
+    },
+    Multiple {
+        rule_name: Ident,
+        binder: Ident,
+        slice_token: Token![..],
+    },
 }
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 struct MacroInput {
     parser: Type,
     input_expr: Expr,
@@ -32,15 +43,46 @@ impl Parse for MatchBranch {
     fn parse(input: ParseStream) -> Result<Self> {
         let contents;
         let _: token::Bracket = bracketed!(contents in input);
-        let pattern_unparsed: TokenStream = contents.fork().parse()?;
-        let pattern_span = pattern_unparsed.span();
-        let pattern = Punctuated::parse_terminated(&contents)?;
+
+        let pattern: Punctuated<MatchBranchPatternItem, Token![,]> =
+            Punctuated::parse_terminated(&contents)?;
+        use MatchBranchPatternItem::{Multiple, Single};
+        let mut singles_before_multiple = Vec::new();
+        let mut multiple = None;
+        let mut singles_after_multiple = Vec::new();
+        for item in pattern.clone() {
+            match item {
+                Single { rule_name, binder } => {
+                    if multiple.is_none() {
+                        singles_before_multiple.push((rule_name, binder))
+                    } else {
+                        singles_after_multiple.push((rule_name, binder))
+                    }
+                }
+                Multiple {
+                    rule_name,
+                    binder,
+                    slice_token,
+                } => {
+                    if multiple.is_none() {
+                        multiple = Some((rule_name, binder))
+                    } else {
+                        return Err(Error::new(
+                            slice_token.span(),
+                            "multiple variable-length patterns are not allowed",
+                        ));
+                    }
+                }
+            }
+        }
+
         let _: Token![=>] = input.parse()?;
         let body = input.parse()?;
 
         Ok(MatchBranch {
-            pattern_span,
-            pattern,
+            singles_before_multiple,
+            multiple,
+            singles_after_multiple,
             body,
         })
     }
@@ -53,8 +95,12 @@ impl Parse for MatchBranchPatternItem {
         parenthesized!(contents in input);
         if input.peek(Token![..]) {
             let binder = contents.parse()?;
-            let _: Token![..] = input.parse()?;
-            Ok(MatchBranchPatternItem::Multiple { rule_name, binder })
+            let slice_token = input.parse()?;
+            Ok(MatchBranchPatternItem::Multiple {
+                rule_name,
+                binder,
+                slice_token,
+            })
         } else if input.is_empty() || input.peek(Token![,]) {
             let binder = contents.parse()?;
             Ok(MatchBranchPatternItem::Single { rule_name, binder })
@@ -93,60 +139,28 @@ fn make_branch(
     i_node_rules: &Ident,
     parser: &Type,
 ) -> Result<TokenStream> {
-    use MatchBranchPatternItem::{Multiple, Single};
-
-    let body = &branch.body;
     let aliased_rule = quote!(<#parser as ::pest_consume::Parser>::AliasedRule);
 
-    // Patterns all have the form [a, b, c.., d], with a bunch of simple patterns,
-    // optionally a multiple pattern, and then some more simple patterns.
-    let mut singles_before_multiple = Vec::new();
-    let mut multiple = None;
-    let mut singles_after_multiple = Vec::new();
-    for item in &branch.pattern {
-        match item {
-            Single {
-                rule_name, binder, ..
-            } => {
-                if multiple.is_none() {
-                    singles_before_multiple.push((rule_name, binder))
-                } else {
-                    singles_after_multiple.push((rule_name, binder))
-                }
-            }
-            Multiple {
-                rule_name, binder, ..
-            } => {
-                if multiple.is_none() {
-                    multiple = Some((rule_name, binder))
-                } else {
-                    return Err(Error::new(
-                        branch.pattern_span.clone(),
-                        "multiple variable-length patterns are not allowed",
-                    ));
-                }
-            }
-        }
-    }
-
     // Find which branch to take
     let mut conditions = Vec::new();
-    let start = singles_before_multiple.len();
-    let end = singles_after_multiple.len();
+    let start = branch.singles_before_multiple.len();
+    let end = branch.singles_after_multiple.len();
     conditions.push(quote!(
         #start + #end <= #i_node_rules.len()
     ));
-    for (i, (rule_name, _)) in singles_before_multiple.iter().enumerate() {
+    for (i, (rule_name, _)) in branch.singles_before_multiple.iter().enumerate()
+    {
         conditions.push(quote!(
             #i_node_rules[#i] == #aliased_rule::#rule_name
         ))
     }
-    for (i, (rule_name, _)) in singles_after_multiple.iter().enumerate() {
+    for (i, (rule_name, _)) in branch.singles_after_multiple.iter().enumerate()
+    {
         conditions.push(quote!(
             #i_node_rules[#i_node_rules.len()-1 - #i] == #aliased_rule::#rule_name
         ))
     }
-    if let Some((rule_name, _)) = multiple {
+    if let Some((rule_name, _)) = &branch.multiple {
         conditions.push(quote!(
             {
                 // We can't use .all() directly in the pattern guard; see
@@ -168,7 +182,7 @@ fn make_branch(
 
     // Once we have found a branch that matches, we need to parse the nodes.
     let mut parses = Vec::new();
-    for (rule_name, binder) in singles_before_multiple.into_iter() {
+    for (rule_name, binder) in branch.singles_before_multiple.iter() {
         parses.push(quote!(
             let #binder = #parser::#rule_name(
                 #i_nodes.next().unwrap()
@@ -177,14 +191,14 @@ fn make_branch(
     }
     // Note the `rev()`: we are taking nodes from the end of the iterator in reverse order, so that
     // only the unmatched nodes are left in the iterator for the variable-length pattern, if any.
-    for (rule_name, binder) in singles_after_multiple.into_iter().rev() {
+    for (rule_name, binder) in branch.singles_after_multiple.iter().rev() {
         parses.push(quote!(
             let #binder = #parser::#rule_name(
                 #i_nodes.next_back().unwrap()
             )?;
         ))
     }
-    if let Some((rule_name, binder)) = multiple {
+    if let Some((rule_name, binder)) = &branch.multiple {
         parses.push(quote!(
             let #binder = #i_nodes
                 .map(|i| #parser::#rule_name(i))
@@ -193,6 +207,7 @@ fn make_branch(
         ))
     }
 
+    let body = &branch.body;
     Ok(quote!(
         _ if #(#conditions &&)* true => {
             #(#parses)*
-- 
cgit v1.2.3


From f8341503c778db92f46fa9f6f368a2013e4c0c1a Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 17 Sep 2019 19:59:22 +0200
Subject: Change invocation syntax of pest_consume::parser macro

---
 dhall_syntax/src/parser.rs             |  2 +-
 pest_consume/examples/csv/main.rs      |  2 +-
 pest_consume/src/lib.rs                |  2 +-
 pest_consume_macros/src/make_parser.rs | 31 ++++++++++++++++++++++++++++---
 4 files changed, 31 insertions(+), 6 deletions(-)

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 8f6f423..2af2d92 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -149,7 +149,7 @@ lazy_static::lazy_static! {
 
 struct DhallParser;
 
-#[pest_consume::parser(dgp::DhallParser, dgp::Rule)]
+#[pest_consume::parser(parser = dgp::DhallParser, rule = dgp::Rule)]
 impl DhallParser {
     fn EOI(_input: ParseInput) -> ParseResult<()> {
         Ok(())
diff --git a/pest_consume/examples/csv/main.rs b/pest_consume/examples/csv/main.rs
index a045eb4..88621db 100644
--- a/pest_consume/examples/csv/main.rs
+++ b/pest_consume/examples/csv/main.rs
@@ -15,7 +15,7 @@ type Node<'i> = pest_consume::Node<'i, Rule, ()>;
 #[grammar = "../examples/csv/csv.pest"]
 struct CSVParser;
 
-#[pest_consume::parser(CSVParser, Rule)]
+#[pest_consume::parser]
 impl CSVParser {
     fn EOI(_input: Node) -> Result<()> {
         Ok(())
diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
index a161d3f..c1d62e5 100644
--- a/pest_consume/src/lib.rs
+++ b/pest_consume/src/lib.rs
@@ -32,7 +32,7 @@
 //! struct CSVParser;
 //!
 //! // This is the other half of the parser, using pest_consume.
-//! #[pest_consume::parser(CSVParser, Rule)]
+//! #[pest_consume::parser]
 //! impl CSVParser {
 //!     fn EOI(_input: Node) -> Result<()> {
 //!         Ok(())
diff --git a/pest_consume_macros/src/make_parser.rs b/pest_consume_macros/src/make_parser.rs
index c30b12f..5bf8fe3 100644
--- a/pest_consume_macros/src/make_parser.rs
+++ b/pest_consume_macros/src/make_parser.rs
@@ -37,6 +37,8 @@ impl<Item> VecPartitionFilterExt<Item> for Vec<Item> {
 
 mod kw {
     syn::custom_keyword!(shortcut);
+    syn::custom_keyword!(rule);
+    syn::custom_keyword!(parser);
 }
 
 struct MakeParserAttrs {
@@ -72,9 +74,32 @@ struct ParsedFn<'a> {
 
 impl Parse for MakeParserAttrs {
     fn parse(input: ParseStream) -> Result<Self> {
-        let parser = input.parse()?;
-        let _: Token![,] = input.parse()?;
-        let rule_enum = input.parse()?;
+        // By default, the pest parser is the same type as the pest_consume one
+        let mut parser = parse_quote!(Self);
+        // By default, use the `Rule` type in scope
+        let mut rule_enum = parse_quote!(Rule);
+
+        while !input.is_empty() {
+            let lookahead = input.lookahead1();
+            if lookahead.peek(kw::parser) {
+                let _: kw::parser = input.parse()?;
+                let _: Token![=] = input.parse()?;
+                parser = input.parse()?;
+            } else if lookahead.peek(kw::rule) {
+                let _: kw::rule = input.parse()?;
+                let _: Token![=] = input.parse()?;
+                rule_enum = input.parse()?;
+            } else {
+                return Err(lookahead.error());
+            }
+
+            if input.peek(Token![,]) {
+                let _: Token![,] = input.parse()?;
+            } else {
+                break;
+            }
+        }
+
         Ok(MakeParserAttrs { parser, rule_enum })
     }
 }
-- 
cgit v1.2.3


From bf417fadb206d6d2351a13cd7c6988977a46dd33 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Wed, 18 Sep 2019 22:37:30 +0200
Subject: Extract pest_consume into its own crate

---
 Cargo.lock                             |  13 +-
 Cargo.toml                             |   2 -
 dhall_syntax/Cargo.toml                |   3 +-
 dhall_syntax/src/parser.rs             |  62 +++--
 pest_consume/Cargo.toml                |  15 --
 pest_consume/examples/csv/csv.pest     |  15 --
 pest_consume/examples/csv/main.rs      |  69 ------
 pest_consume/src/lib.rs                | 325 -------------------------
 pest_consume_macros/Cargo.toml         |  19 --
 pest_consume_macros/src/lib.rs         |  27 ---
 pest_consume_macros/src/make_parser.rs | 424 ---------------------------------
 pest_consume_macros/src/match_nodes.rs | 248 -------------------
 12 files changed, 36 insertions(+), 1186 deletions(-)
 delete mode 100644 pest_consume/Cargo.toml
 delete mode 100644 pest_consume/examples/csv/csv.pest
 delete mode 100644 pest_consume/examples/csv/main.rs
 delete mode 100644 pest_consume/src/lib.rs
 delete mode 100644 pest_consume_macros/Cargo.toml
 delete mode 100644 pest_consume_macros/src/lib.rs
 delete mode 100644 pest_consume_macros/src/make_parser.rs
 delete mode 100644 pest_consume_macros/src/match_nodes.rs

diff --git a/Cargo.lock b/Cargo.lock
index 82212fe..5e81f7f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -116,8 +116,7 @@ dependencies = [
  "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "percent-encoding 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "pest 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "pest_consume 0.1.0",
- "pest_derive 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pest_consume 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "take_mut 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
@@ -240,17 +239,19 @@ dependencies = [
 
 [[package]]
 name = "pest_consume"
-version = "0.1.0"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "pest 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "pest_consume_macros 0.1.0",
+ "pest_consume_macros 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "pest_derive 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "proc-macro-hack 0.5.9 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "pest_consume_macros"
-version = "0.1.0"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "proc-macro-hack 0.5.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "proc-macro2 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -522,6 +523,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum output_vt100 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "53cdc5b785b7a58c5aad8216b3dfa114df64b0b06ae6e1501cef91df2fbdf8f9"
 "checksum percent-encoding 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
 "checksum pest 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7e4fb201c5c22a55d8b24fef95f78be52738e5e1361129be1b5e862ecdb6894a"
+"checksum pest_consume 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "db19e2b6df75694d2a73accd716c3e2b28d6241ad88ec140a5588eb4486eeb40"
+"checksum pest_consume_macros 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "36dc3a65f772c034446335f2a09fa4ea7a3cc471f130acdb06e96225f0ee6da0"
 "checksum pest_derive 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "833d1ae558dc601e9a60366421196a8d94bc0ac980476d0b67e1d0988d72b2d0"
 "checksum pest_generator 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7b9fcf299b5712d06ee128a556c94709aaa04512c4dffb8ead07c5c998447fc0"
 "checksum pest_meta 2.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "df43fd99896fd72c485fe47542c7b500e4ac1e8700bf995544d1317a60ded547"
diff --git a/Cargo.toml b/Cargo.toml
index ec6a760..1e40748 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,8 +8,6 @@ members = [
     "dhall_syntax",
     "dhall_proc_macros",
     "improved_slice_patterns",
-    "pest_consume",
-    "pest_consume_macros",
     "serde_dhall"
 ]
 
diff --git a/dhall_syntax/Cargo.toml b/dhall_syntax/Cargo.toml
index 8d9cca6..b98c4a4 100644
--- a/dhall_syntax/Cargo.toml
+++ b/dhall_syntax/Cargo.toml
@@ -12,11 +12,10 @@ doctest = false
 itertools = "0.8.0"
 percent-encoding = "2.1.0"
 pest = "2.1"
-pest_derive = "2.1"
 either = "1.5.2"
 take_mut = "0.2.2"
 hex = "0.3.2"
 lazy_static = "1.4.0"
 dhall_generated_parser = { path = "../dhall_generated_parser" }
 dhall_proc_macros = { path = "../dhall_proc_macros" }
-pest_consume = { path = "../pest_consume" }
+pest_consume = "1.0"
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 2af2d92..71fab0f 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -1,5 +1,4 @@
 use itertools::Itertools;
-use pest::iterators::Pair;
 use pest::prec_climber as pcl;
 use pest::prec_climber::PrecClimber;
 use std::rc::Rc;
@@ -167,7 +166,7 @@ impl DhallParser {
     fn double_quote_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ParsedText<E>> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [double_quote_chunk(chunks)..] => {
                 chunks.collect()
             }
@@ -177,7 +176,7 @@ impl DhallParser {
     fn double_quote_chunk<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ParsedTextContents<E>> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [expression(e)] => {
                 InterpolatedTextContents::Expr(e)
             },
@@ -264,7 +263,7 @@ impl DhallParser {
     fn single_quote_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ParsedText<E>> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [single_quote_continue(lines)] => {
                 let newline: ParsedText<E> = "\n".to_string().into();
 
@@ -301,7 +300,7 @@ impl DhallParser {
     fn single_quote_continue<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<Vec<Vec<ParsedTextContents<E>>>> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [expression(e), single_quote_continue(lines)] => {
                 let c = InterpolatedTextContents::Expr(e);
                 let mut lines = lines;
@@ -387,21 +386,15 @@ impl DhallParser {
     #[alias(expression, shortcut = true)]
     fn identifier<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
         Ok(match_nodes!(input.children();
-            [variable(v)] => {
-                spanned(input, Var(v))
-            },
+            [variable(v)] => spanned(input, Var(v)),
             [expression(e)] => e,
         ))
     }
 
     fn variable(input: ParseInput) -> ParseResult<V<Label>> {
-        Ok(match_nodes!(input.children();
-            [label(l), natural_literal(idx)] => {
-                V(l, idx)
-            },
-            [label(l)] => {
-                V(l, 0)
-            },
+        Ok(match_nodes!(input.into_children();
+            [label(l), natural_literal(idx)] => V(l, idx),
+            [label(l)] => V(l, 0),
         ))
     }
 
@@ -437,7 +430,7 @@ impl DhallParser {
             .collect())
     }
     fn path(input: ParseInput) -> ParseResult<Vec<String>> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [path_component(components)..] => {
                 components.collect()
             }
@@ -448,7 +441,7 @@ impl DhallParser {
     fn local<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [local_path((prefix, p))] => ImportLocation::Local(prefix, p),
         ))
     }
@@ -457,19 +450,19 @@ impl DhallParser {
     fn parent_path(
         input: ParseInput,
     ) -> ParseResult<(FilePrefix, Vec<String>)> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [path(p)] => (FilePrefix::Parent, p)
         ))
     }
     #[alias(local_path)]
     fn here_path(input: ParseInput) -> ParseResult<(FilePrefix, Vec<String>)> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [path(p)] => (FilePrefix::Here, p)
         ))
     }
     #[alias(local_path)]
     fn home_path(input: ParseInput) -> ParseResult<(FilePrefix, Vec<String>)> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [path(p)] => (FilePrefix::Home, p)
         ))
     }
@@ -477,7 +470,7 @@ impl DhallParser {
     fn absolute_path(
         input: ParseInput,
     ) -> ParseResult<(FilePrefix, Vec<String>)> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [path(p)] => (FilePrefix::Absolute, p)
         ))
     }
@@ -491,7 +484,7 @@ impl DhallParser {
     }
 
     fn http_raw<E: Clone>(input: ParseInput) -> ParseResult<URL<Expr<E>>> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [scheme(sch), authority(auth), path(p)] => URL {
                 scheme: sch,
                 authority: auth,
@@ -521,7 +514,7 @@ impl DhallParser {
     fn http<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
-        Ok(ImportLocation::Remote(match_nodes!(input.children();
+        Ok(ImportLocation::Remote(match_nodes!(input.into_children();
             [http_raw(url)] => url,
             [http_raw(url), expression(e)] => URL { headers: Some(e), ..url },
         )))
@@ -531,7 +524,7 @@ impl DhallParser {
     fn env<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [environment_variable(v)] => ImportLocation::Env(v),
         ))
     }
@@ -541,7 +534,7 @@ impl DhallParser {
     }
     #[alias(environment_variable)]
     fn posix_environment_variable(input: ParseInput) -> ParseResult<String> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [posix_environment_variable_character(chars)..] => {
                 chars.collect()
             },
@@ -586,7 +579,7 @@ impl DhallParser {
     ) -> ParseResult<crate::Import<Expr<E>>> {
         use crate::Import;
         let mode = ImportMode::Code;
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [import_type(location)] => Import { mode, location, hash: None },
             [import_type(location), hash(h)] => Import { mode, location, hash: Some(h) },
         ))
@@ -703,9 +696,8 @@ impl DhallParser {
     #[alias(expression, shortcut = true)]
     #[prec_climb(expression, PRECCLIMBER)]
     fn operator_expression<E: Clone>(
-        input: ParseInput,
         l: Expr<E>,
-        op: Pair<Rule>,
+        op: ParseInput,
         r: Expr<E>,
     ) -> ParseResult<Expr<E>> {
         use crate::BinOp::*;
@@ -724,7 +716,7 @@ impl DhallParser {
             bool_eq => BoolEQ,
             bool_ne => BoolNE,
             equivalent => Equivalence,
-            r => Err(input.error(format!("Rule {:?} isn't an operator", r)))?,
+            r => Err(op.error(format!("Rule {:?} isn't an operator", r)))?,
         };
 
         Ok(spanned_union(
@@ -812,7 +804,7 @@ impl DhallParser {
     }
 
     fn labels(input: ParseInput) -> ParseResult<DupTreeSet<Label>> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [label(ls)..] => ls.collect(),
         ))
     }
@@ -865,7 +857,7 @@ impl DhallParser {
     fn non_empty_record_type<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Expr<E>, DupTreeMap<Label, Expr<E>>)> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [expression(expr), record_type_entry(entries)..] => {
                 (expr, entries.collect())
             }
@@ -875,7 +867,7 @@ impl DhallParser {
     fn record_type_entry<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Label, Expr<E>)> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [label(name), expression(expr)] => (name, expr)
         ))
     }
@@ -883,7 +875,7 @@ impl DhallParser {
     fn non_empty_record_literal<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Expr<E>, DupTreeMap<Label, Expr<E>>)> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [expression(expr), record_literal_entry(entries)..] => {
                 (expr, entries.collect())
             }
@@ -893,7 +885,7 @@ impl DhallParser {
     fn record_literal_entry<E: Clone>(
         input: ParseInput,
     ) -> ParseResult<(Label, Expr<E>)> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [label(name), expression(expr)] => (name, expr)
         ))
     }
@@ -934,7 +926,7 @@ impl DhallParser {
 
     #[alias(expression)]
     fn final_expression<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
-        Ok(match_nodes!(input.children();
+        Ok(match_nodes!(input.into_children();
             [expression(e), EOI(_)] => e
         ))
     }
diff --git a/pest_consume/Cargo.toml b/pest_consume/Cargo.toml
deleted file mode 100644
index 1b8ebf6..0000000
--- a/pest_consume/Cargo.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[package]
-name = "pest_consume"
-version = "0.1.0"  # remember to update html_root_url
-authors = ["Nadrieril <nadrieril@users.noreply.github.com>"]
-license = "MIT OR Apache-2.0"
-edition = "2018"
-description = "A framework for processing the output of a pest-generated parser"
-readme = "README.md"
-repository = "https://github.com/Nadrieril/dhall-rust"
-
-[dependencies]
-pest = "2.1"
-pest_derive = "2.1"
-proc-macro-hack = "0.5.9"
-pest_consume_macros = { path = "../pest_consume_macros" }
diff --git a/pest_consume/examples/csv/csv.pest b/pest_consume/examples/csv/csv.pest
deleted file mode 100644
index a67af8c..0000000
--- a/pest_consume/examples/csv/csv.pest
+++ /dev/null
@@ -1,15 +0,0 @@
-WHITESPACE = _{ " "+ }
-newline = _{ "\r\n" | "\n" }
-number = { "-"? ~ (ASCII_DIGIT | ".")+ }
-string = { (!"'" ~ ASCII)* }
-field = ${
-      number
-    | "'" ~ string ~ "'"
-}
-record = {
-      field ~ ("," ~ field)*
-    | ""
-}
-file = {
-    SOI ~ record ~ (newline ~ record)* ~ newline? ~ EOI
-}
diff --git a/pest_consume/examples/csv/main.rs b/pest_consume/examples/csv/main.rs
deleted file mode 100644
index 88621db..0000000
--- a/pest_consume/examples/csv/main.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use pest_consume::{match_nodes, Error, Parser};
-
-#[derive(Debug)]
-enum CSVField<'a> {
-    Number(f64),
-    String(&'a str),
-}
-type CSVRecord<'a> = Vec<CSVField<'a>>;
-type CSVFile<'a> = Vec<CSVRecord<'a>>;
-
-type Result<T> = std::result::Result<T, Error<Rule>>;
-type Node<'i> = pest_consume::Node<'i, Rule, ()>;
-
-#[derive(Parser)]
-#[grammar = "../examples/csv/csv.pest"]
-struct CSVParser;
-
-#[pest_consume::parser]
-impl CSVParser {
-    fn EOI(_input: Node) -> Result<()> {
-        Ok(())
-    }
-
-    fn number(input: Node) -> Result<f64> {
-        input
-            .as_str()
-            .parse::<f64>()
-            // `input.error` links the error to the location in the input file where it occurred.
-            .map_err(|e| input.error(e.to_string()))
-    }
-
-    fn string(input: Node) -> Result<&str> {
-        Ok(input.as_str())
-    }
-
-    fn field(input: Node) -> Result<CSVField> {
-        Ok(match_nodes!(input.children();
-            [number(n)] => CSVField::Number(n),
-            [string(s)] => CSVField::String(s),
-        ))
-    }
-
-    fn record(input: Node) -> Result<CSVRecord> {
-        Ok(match_nodes!(input.children();
-            [field(fields)..] => fields.collect(),
-        ))
-    }
-
-    fn file(input: Node) -> Result<CSVFile> {
-        Ok(match_nodes!(input.children();
-            [record(records).., EOI(_)] => records.collect(),
-        ))
-    }
-}
-
-fn parse_csv(input_str: &str) -> Result<CSVFile> {
-    let inputs = CSVParser::parse(Rule::file, input_str)?;
-    Ok(match_nodes!(<CSVParser>; inputs;
-        [file(e)] => e,
-    ))
-}
-
-fn main() {
-    let successful_parse = parse_csv("-273.15, ' a string '\n\n42, 0");
-    println!("success: {:?}", successful_parse.unwrap());
-
-    let unsuccessful_parse = parse_csv("0, 273.15.12");
-    println!("failure: {}", unsuccessful_parse.unwrap_err());
-}
diff --git a/pest_consume/src/lib.rs b/pest_consume/src/lib.rs
deleted file mode 100644
index c1d62e5..0000000
--- a/pest_consume/src/lib.rs
+++ /dev/null
@@ -1,325 +0,0 @@
-//! `pest_consume` extends [pest] to make it easy to consume a pest parse tree.
-//! Given a grammar file, pest generates a parser that outputs an untyped parse tree. Then that
-//! parse tree needs to be transformed into whatever datastructures your application uses.
-//! `pest_consume` provides two macros to make this easy.
-//!
-//! Features of `pest_consume` include:
-//! - strong types;
-//! - consuming children uses an intuitive syntax;
-//! - error handling is well integrated.
-//!
-//! # Example
-//!
-//! Here is the [CSV example from the doc](https://pest.rs/book/examples/csv.html),
-//! using `pest_consume`.
-//!
-//! The pest grammar file contains:
-//! ```text
-//! field = { (ASCII_DIGIT | "." | "-")+ }
-//! record = { field ~ ("," ~ field)* }
-//! file = { SOI ~ (record ~ ("\r\n" | "\n"))* ~ EOI }
-//! ```
-//!
-//! ```no_run
-//! use pest_consume::{match_nodes, Error, Parser};
-//!
-//! type Result<T> = std::result::Result<T, Error<Rule>>;
-//! type Node<'i> = pest_consume::Node<'i, Rule, ()>;
-//!
-//! // Construct the first half of the parser using pest as usual.
-//! #[derive(Parser)]
-//! #[grammar = "../examples/csv/csv.pest"]
-//! struct CSVParser;
-//!
-//! // This is the other half of the parser, using pest_consume.
-//! #[pest_consume::parser]
-//! impl CSVParser {
-//!     fn EOI(_input: Node) -> Result<()> {
-//!         Ok(())
-//!     }
-//!     fn field(input: Node) -> Result<f64> {
-//!         input
-//!             .as_str()
-//!             .parse::<f64>()
-//!             .map_err(|e| input.error(e.to_string()))
-//!     }
-//!     fn record(input: Node) -> Result<Vec<f64>> {
-//!         Ok(match_nodes!(input.children();
-//!             [field(fields)..] => fields.collect(),
-//!         ))
-//!     }
-//!     fn file(input: Node) -> Result<Vec<Vec<f64>>> {
-//!         Ok(match_nodes!(input.children();
-//!             [record(records).., EOI(_)] => records.collect(),
-//!         ))
-//!     }
-//! }
-//!
-//! fn parse_csv(input_str: &str) -> Result<Vec<Vec<f64>>> {
-//!     let inputs = CSVParser::parse(Rule::file, input_str)?;
-//!     Ok(match_nodes!(<CSVParser>; inputs;
-//!         [file(e)] => e,
-//!     ))
-//! }
-//!
-//! fn main() {
-//!     let parsed = parse_csv("-273.15, 12\n42, 0").unwrap();
-//!     let mut sum = 0.;
-//!     for record in parsed {
-//!         for field in record {
-//!             sum += field;
-//!         }
-//!     }
-//!     println!("{}", sum);
-//! }
-//! ```
-//!
-//! There are several things to note:
-//! - we use two macros provided by `pest_consume`: `parser` and `match_nodes`;
-//! - there is one `fn` item per (non-silent) rule in the grammar;
-//! - we associate an output type to every rule;
-//! - there is no need to fiddle with `.into_inner()`, `.next()` or `.unwrap()`, as is common when using pest
-//!
-//! # How it works
-//!
-//! The main types of this crate ([Node], [Nodes] and [Parser]) are mostly wrappers around
-//! the corresponding [pest] types.
-//!
-//! The `pest_consume::parser` macro does almost nothing when not using advanced features;
-//! most of the magic happens in `match_nodes`.
-//! `match_nodes` desugars rather straightforwardly into calls to the `fn` items corresponding to
-//! the rules matched on.
-//! For example:
-//! ```ignore
-//! match_nodes!(input.children();
-//!     [field(fields)..] => fields.collect(),
-//! )
-//! ```
-//! desugars into:
-//! ```ignore
-//! let nodes = { input.children() };
-//! if ... { // check that all rules in `nodes` are the `field` rule
-//!     let fields = nodes
-//!         .map(|node| Self::field(node)) // Recursively parse children nodes
-//!         ... // Propagate errors
-//!     { fields.collect() }
-//! } else {
-//!     ... // error because we got unexpected rules
-//! }
-//! ```
-//!
-//! # Advanced features
-//!
-//! TODO
-//!
-//! - rule aliasing
-//! - rule shortcutting
-//! - user data
-
-pub use pest::error::Error;
-use pest::Parser as PestParser;
-use pest::RuleType;
-pub use pest_derive::Parser;
-
-#[proc_macro_hack::proc_macro_hack]
-pub use pest_consume_macros::match_nodes;
-pub use pest_consume_macros::parser;
-
-mod node {
-    use super::Parser;
-    use pest::error::{Error, ErrorVariant};
-    use pest::iterators::{Pair, Pairs};
-    use pest::Parser as PestParser;
-    use pest::{RuleType, Span};
-
-    /// Carries a pest Pair alongside custom user data.
-    #[derive(Debug, Clone)]
-    pub struct Node<'input, Rule: RuleType, Data> {
-        pair: Pair<'input, Rule>,
-        user_data: Data,
-    }
-
-    /// Iterator over `Node`s. It is created by `Node::children` or `Nodes::new`.
-    #[derive(Debug, Clone)]
-    pub struct Nodes<'input, Rule: RuleType, Data> {
-        pairs: Pairs<'input, Rule>,
-        span: Span<'input>,
-        user_data: Data,
-    }
-
-    impl<'i, R: RuleType, D> Node<'i, R, D> {
-        pub fn new(pair: Pair<'i, R>, user_data: D) -> Self {
-            Node { pair, user_data }
-        }
-        /// Create an error that points to the span of the input.
-        pub fn error(&self, message: String) -> Error<R> {
-            Error::new_from_span(
-                ErrorVariant::CustomError { message },
-                self.as_span(),
-            )
-        }
-        /// Reconstruct the input with a new pair, passing the user data along.
-        pub fn with_pair(&self, new_pair: Pair<'i, R>) -> Self
-        where
-            D: Clone,
-        {
-            Node {
-                pair: new_pair,
-                user_data: self.user_data.clone(),
-            }
-        }
-        /// If the contained pair has exactly one child, return a new Self containing it.
-        pub fn single_child(&self) -> Option<Self>
-        where
-            D: Clone,
-        {
-            let mut children = self.pair.clone().into_inner();
-            if let Some(child) = children.next() {
-                if children.next().is_none() {
-                    return Some(self.with_pair(child));
-                }
-            }
-            None
-        }
-        /// Return an iterator over the children of this input
-        // Can't use `-> impl Iterator` because of weird lifetime limitations
-        // (see https://github.com/rust-lang/rust/issues/61997).
-        pub fn children(&self) -> Nodes<'i, R, D>
-        where
-            D: Clone,
-        {
-            Nodes {
-                pairs: self.as_pair().clone().into_inner(),
-                span: self.as_span(),
-                user_data: self.user_data(),
-            }
-        }
-
-        pub fn user_data(&self) -> D
-        where
-            D: Clone,
-        {
-            self.user_data.clone()
-        }
-        pub fn as_pair(&self) -> &Pair<'i, R> {
-            &self.pair
-        }
-        pub fn into_pair(self) -> Pair<'i, R> {
-            self.pair
-        }
-        pub fn as_span(&self) -> Span<'i> {
-            self.pair.as_span()
-        }
-        pub fn as_str(&self) -> &'i str {
-            self.pair.as_str()
-        }
-        pub fn as_rule(&self) -> R {
-            self.pair.as_rule()
-        }
-        pub fn as_aliased_rule<C>(&self) -> C::AliasedRule
-        where
-            C: Parser<Rule = R>,
-            <C as Parser>::Parser: PestParser<R>,
-        {
-            C::rule_alias(self.as_rule())
-        }
-    }
-
-    impl<'i, R: RuleType, D> Nodes<'i, R, D> {
-        /// `input` must be the _original_ input that `pairs` is pointing to.
-        pub fn new(input: &'i str, pairs: Pairs<'i, R>, user_data: D) -> Self {
-            let span = Span::new(input, 0, input.len()).unwrap();
-            Nodes {
-                pairs,
-                span,
-                user_data,
-            }
-        }
-        /// Create an error that points to the span of the input.
-        pub fn error(&self, message: String) -> Error<R> {
-            Error::new_from_span(
-                ErrorVariant::CustomError { message },
-                self.span.clone(),
-            )
-        }
-        pub fn aliased_rules<C>(&self) -> Vec<C::AliasedRule>
-        where
-            D: Clone,
-            C: Parser<Rule = R>,
-            <C as Parser>::Parser: PestParser<R>,
-        {
-            self.clone().map(|p| p.as_aliased_rule::<C>()).collect()
-        }
-        /// Reconstruct the input with a new pair, passing the user data along.
-        fn with_pair(&self, new_pair: Pair<'i, R>) -> Node<'i, R, D>
-        where
-            D: Clone,
-        {
-            Node::new(new_pair, self.user_data.clone())
-        }
-
-        pub fn as_pairs(&self) -> &Pairs<'i, R> {
-            &self.pairs
-        }
-        pub fn into_pairs(self) -> Pairs<'i, R> {
-            self.pairs
-        }
-    }
-
-    impl<'i, R, D> Iterator for Nodes<'i, R, D>
-    where
-        R: RuleType,
-        D: Clone,
-    {
-        type Item = Node<'i, R, D>;
-
-        fn next(&mut self) -> Option<Self::Item> {
-            let child_pair = self.pairs.next()?;
-            let child = self.with_pair(child_pair);
-            Some(child)
-        }
-    }
-
-    impl<'i, R, D> DoubleEndedIterator for Nodes<'i, R, D>
-    where
-        R: RuleType,
-        D: Clone,
-    {
-        fn next_back(&mut self) -> Option<Self::Item> {
-            let child_pair = self.pairs.next_back()?;
-            let child = self.with_pair(child_pair);
-            Some(child)
-        }
-    }
-}
-
-pub use node::{Node, Nodes};
-
-/// Used by the macros.
-/// Do not implement manually.
-pub trait Parser {
-    type Rule: RuleType;
-    type AliasedRule: RuleType;
-    type Parser: PestParser<Self::Rule>;
-
-    fn rule_alias(rule: Self::Rule) -> Self::AliasedRule;
-    fn allows_shortcut(rule: Self::Rule) -> bool;
-
-    /// Parses a `&str` starting from `rule`
-    fn parse<'i>(
-        rule: Self::Rule,
-        input_str: &'i str,
-    ) -> Result<Nodes<'i, Self::Rule, ()>, Error<Self::Rule>> {
-        Self::parse_with_userdata(rule, input_str, ())
-    }
-
-    /// Parses a `&str` starting from `rule`, carrying `user_data` through the parser methods.
-    fn parse_with_userdata<'i, D>(
-        rule: Self::Rule,
-        input_str: &'i str,
-        user_data: D,
-    ) -> Result<Nodes<'i, Self::Rule, D>, Error<Self::Rule>> {
-        let pairs = Self::Parser::parse(rule, input_str)?;
-        Ok(Nodes::new(input_str, pairs, user_data))
-    }
-}
diff --git a/pest_consume_macros/Cargo.toml b/pest_consume_macros/Cargo.toml
deleted file mode 100644
index aaa0b10..0000000
--- a/pest_consume_macros/Cargo.toml
+++ /dev/null
@@ -1,19 +0,0 @@
-[package]
-name = "pest_consume_macros"
-version = "0.1.0"  # remember to update html_root_url
-authors = ["Nadrieril <nadrieril@users.noreply.github.com>"]
-license = "MIT OR Apache-2.0"
-edition = "2018"
-description = "Macros for pest_consume"
-readme = "README.md"
-repository = "https://github.com/Nadrieril/dhall-rust"
-
-[lib]
-proc-macro = true
-doctest = false
-
-[dependencies]
-quote = "1.0.2"
-proc-macro2 = "1.0.2"
-proc-macro-hack = "0.5.9"
-syn = { version = "1.0.5", features = ["full"] }
diff --git a/pest_consume_macros/src/lib.rs b/pest_consume_macros/src/lib.rs
deleted file mode 100644
index d726b5d..0000000
--- a/pest_consume_macros/src/lib.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//! This crate contains the code-generation primitives for the [dhall-rust][dhall-rust] crate.
-//! This is highly unstable and breaks regularly; use at your own risk.
-//!
-//! [dhall-rust]: https://github.com/Nadrieril/dhall-rust
-
-extern crate proc_macro;
-
-mod make_parser;
-mod match_nodes;
-
-use proc_macro::TokenStream;
-
-#[proc_macro_attribute]
-pub fn parser(attrs: TokenStream, input: TokenStream) -> TokenStream {
-    TokenStream::from(match make_parser::make_parser(attrs, input) {
-        Ok(tokens) => tokens,
-        Err(err) => err.to_compile_error(),
-    })
-}
-
-#[proc_macro_hack::proc_macro_hack]
-pub fn match_nodes(input: TokenStream) -> TokenStream {
-    TokenStream::from(match match_nodes::match_nodes(input) {
-        Ok(tokens) => tokens,
-        Err(err) => err.to_compile_error(),
-    })
-}
diff --git a/pest_consume_macros/src/make_parser.rs b/pest_consume_macros/src/make_parser.rs
deleted file mode 100644
index 5bf8fe3..0000000
--- a/pest_consume_macros/src/make_parser.rs
+++ /dev/null
@@ -1,424 +0,0 @@
-use std::collections::HashMap;
-use std::iter;
-
-use quote::quote;
-use syn::parse::{Parse, ParseStream, Result};
-use syn::spanned::Spanned;
-use syn::{
-    parse_quote, Error, Expr, FnArg, Ident, ImplItem, ImplItemMethod, ItemImpl,
-    LitBool, Pat, Path, Token,
-};
-
-/// Ext. trait adding `partition_filter` to `Vec`. Would like to use `Vec::drain_filter`
-/// but it's unstable for now.
-pub trait VecPartitionFilterExt<Item> {
-    fn partition_filter<F>(&mut self, predicate: F) -> Vec<Item>
-    where
-        F: FnMut(&mut Item) -> bool;
-}
-
-impl<Item> VecPartitionFilterExt<Item> for Vec<Item> {
-    fn partition_filter<F>(&mut self, mut predicate: F) -> Vec<Item>
-    where
-        F: FnMut(&mut Item) -> bool,
-    {
-        let mut ret = Vec::new();
-        let mut i = 0;
-        while i != self.len() {
-            if predicate(&mut self[i]) {
-                ret.push(self.remove(i))
-            } else {
-                i += 1;
-            }
-        }
-        ret
-    }
-}
-
-mod kw {
-    syn::custom_keyword!(shortcut);
-    syn::custom_keyword!(rule);
-    syn::custom_keyword!(parser);
-}
-
-struct MakeParserAttrs {
-    parser: Path,
-    rule_enum: Path,
-}
-
-struct AliasArgs {
-    target: Ident,
-    is_shortcut: bool,
-}
-
-struct PrecClimbArgs {
-    child_rule: Ident,
-    climber: Expr,
-}
-
-struct AliasSrc {
-    ident: Ident,
-    is_shortcut: bool,
-}
-
-struct ParsedFn<'a> {
-    // Body of the function
-    function: &'a mut ImplItemMethod,
-    // Name of the function.
-    fn_name: Ident,
-    // Name of the first argument of the function, which should be of type `Node`.
-    input_arg: Ident,
-    // List of aliases pointing to this function
-    alias_srcs: Vec<AliasSrc>,
-}
-
-impl Parse for MakeParserAttrs {
-    fn parse(input: ParseStream) -> Result<Self> {
-        // By default, the pest parser is the same type as the pest_consume one
-        let mut parser = parse_quote!(Self);
-        // By default, use the `Rule` type in scope
-        let mut rule_enum = parse_quote!(Rule);
-
-        while !input.is_empty() {
-            let lookahead = input.lookahead1();
-            if lookahead.peek(kw::parser) {
-                let _: kw::parser = input.parse()?;
-                let _: Token![=] = input.parse()?;
-                parser = input.parse()?;
-            } else if lookahead.peek(kw::rule) {
-                let _: kw::rule = input.parse()?;
-                let _: Token![=] = input.parse()?;
-                rule_enum = input.parse()?;
-            } else {
-                return Err(lookahead.error());
-            }
-
-            if input.peek(Token![,]) {
-                let _: Token![,] = input.parse()?;
-            } else {
-                break;
-            }
-        }
-
-        Ok(MakeParserAttrs { parser, rule_enum })
-    }
-}
-
-impl Parse for AliasArgs {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let target = input.parse()?;
-        let is_shortcut = if input.peek(Token![,]) {
-            // #[alias(rule, shortcut = true)]
-            let _: Token![,] = input.parse()?;
-            let _: kw::shortcut = input.parse()?;
-            let _: Token![=] = input.parse()?;
-            let b: LitBool = input.parse()?;
-            b.value
-        } else {
-            // #[alias(rule)]
-            false
-        };
-        Ok(AliasArgs {
-            target,
-            is_shortcut,
-        })
-    }
-}
-
-impl Parse for PrecClimbArgs {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let child_rule = input.parse()?;
-        let _: Token![,] = input.parse()?;
-        let climber = input.parse()?;
-        Ok(PrecClimbArgs {
-            child_rule,
-            climber,
-        })
-    }
-}
-
-fn collect_aliases(
-    imp: &mut ItemImpl,
-) -> Result<HashMap<Ident, Vec<AliasSrc>>> {
-    let functions = imp.items.iter_mut().flat_map(|item| match item {
-        ImplItem::Method(m) => Some(m),
-        _ => None,
-    });
-
-    let mut alias_map = HashMap::new();
-    for function in functions {
-        let fn_name = function.sig.ident.clone();
-        let mut alias_attrs = function
-            .attrs
-            .partition_filter(|attr| attr.path.is_ident("alias"))
-            .into_iter();
-
-        if let Some(attr) = alias_attrs.next() {
-            let args: AliasArgs = attr.parse_args()?;
-            alias_map.entry(args.target).or_insert_with(Vec::new).push(
-                AliasSrc {
-                    ident: fn_name,
-                    is_shortcut: args.is_shortcut,
-                },
-            );
-        } else {
-            // Self entry
-            alias_map
-                .entry(fn_name.clone())
-                .or_insert_with(Vec::new)
-                .push(AliasSrc {
-                    ident: fn_name,
-                    is_shortcut: false,
-                });
-        }
-        if let Some(attr) = alias_attrs.next() {
-            return Err(Error::new(
-                attr.span(),
-                "expected at most one alias attribute",
-            ));
-        }
-    }
-
-    Ok(alias_map)
-}
-
-fn parse_fn<'a>(
-    function: &'a mut ImplItemMethod,
-    alias_map: &mut HashMap<Ident, Vec<AliasSrc>>,
-) -> Result<ParsedFn<'a>> {
-    let fn_name = function.sig.ident.clone();
-    // Get the name of the first (`input`) function argument
-    let input_arg = function.sig.inputs.first().ok_or_else(|| {
-        Error::new(
-            function.sig.inputs.span(),
-            "a rule function needs an `input` argument",
-        )
-    })?;
-    let input_arg = match &input_arg {
-        FnArg::Receiver(_) => return Err(Error::new(
-            input_arg.span(),
-            "a rule function should not have a `self` argument",
-        )),
-        FnArg::Typed(input_arg) => match &*input_arg.pat{
-            Pat::Ident(ident) => ident.ident.clone(),
-            _ => return Err(Error::new(
-                input_arg.span(),
-                "this argument should be a plain identifier instead of a pattern",
-            )),
-        }
-    };
-
-    let alias_srcs = alias_map.remove(&fn_name).unwrap_or_else(Vec::new);
-
-    Ok(ParsedFn {
-        function,
-        fn_name,
-        input_arg,
-        alias_srcs,
-    })
-}
-
-fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Path) -> Result<()> {
-    let function = &mut *f.function;
-    let fn_name = &f.fn_name;
-    let input_arg = &f.input_arg;
-
-    *function = parse_quote!(
-        #[allow(non_snake_case)]
-        #function
-    );
-
-    // `prec_climb` attr
-    let prec_climb_attrs: Vec<_> = function
-        .attrs
-        .partition_filter(|attr| attr.path.is_ident("prec_climb"));
-
-    if prec_climb_attrs.len() > 1 {
-        return Err(Error::new(
-            prec_climb_attrs[1].span(),
-            "expected at most one prec_climb attribute",
-        ));
-    } else if prec_climb_attrs.is_empty() {
-        // do nothing
-    } else {
-        let attr = prec_climb_attrs.into_iter().next().unwrap();
-        let PrecClimbArgs {
-            child_rule,
-            climber,
-        } = attr.parse_args()?;
-
-        function.block = parse_quote!({
-            #function
-
-            #climber.climb(
-                #input_arg.as_pair().clone().into_inner(),
-                |p| Self::#child_rule(#input_arg.with_pair(p)),
-                |l, op, r| {
-                    #fn_name(#input_arg.clone(), l?, op, r?)
-                },
-            )
-        });
-        // Remove the 3 last arguments to keep only the `input` one
-        function.sig.inputs.pop();
-        function.sig.inputs.pop();
-        function.sig.inputs.pop();
-        // Check that an argument remains
-        function.sig.inputs.first().ok_or_else(|| {
-            Error::new(
-                function.sig.inputs.span(),
-                "a prec_climb function needs 4 arguments",
-            )
-        })?;
-    }
-
-    // `alias` attr
-    // f.alias_srcs has always at least 1 element because it has an entry pointing from itself.
-    if f.alias_srcs.len() > 1 {
-        let aliases = f
-            .alias_srcs
-            .iter()
-            .map(|src| &src.ident)
-            .filter(|i| i != &fn_name);
-        let block = &function.block;
-        let self_ty = quote!(<Self as ::pest_consume::Parser>);
-        function.block = parse_quote!({
-            let mut #input_arg = #input_arg;
-            // While the current rule allows shortcutting, and there is a single child, and the
-            // child can still be parsed by the current function, then skip to that child.
-            while #self_ty::allows_shortcut(#input_arg.as_rule()) {
-                if let ::std::option::Option::Some(child) = #input_arg.single_child() {
-                    if child.as_aliased_rule::<Self>() == #self_ty::AliasedRule::#fn_name {
-                        #input_arg = child;
-                        continue;
-                    }
-                }
-                break
-            }
-
-            match #input_arg.as_rule() {
-                #(#rule_enum::#aliases => Self::#aliases(#input_arg),)*
-                #rule_enum::#fn_name => #block,
-                r => ::std::unreachable!(
-                    "make_parser: called {} on {:?}",
-                    ::std::stringify!(#fn_name),
-                    r
-                )
-            }
-        });
-    }
-
-    Ok(())
-}
-
-pub fn make_parser(
-    attrs: proc_macro::TokenStream,
-    input: proc_macro::TokenStream,
-) -> Result<proc_macro2::TokenStream> {
-    let attrs: MakeParserAttrs = syn::parse(attrs)?;
-    let parser = &attrs.parser;
-    let rule_enum = &attrs.rule_enum;
-    let mut imp: ItemImpl = syn::parse(input)?;
-
-    let mut alias_map = collect_aliases(&mut imp)?;
-    let rule_alias_branches: Vec<_> = alias_map
-        .iter()
-        .flat_map(|(tgt, srcs)| iter::repeat(tgt).zip(srcs))
-        .map(|(tgt, src)| {
-            let ident = &src.ident;
-            quote!(
-                #rule_enum::#ident => Self::AliasedRule::#tgt,
-            )
-        })
-        .collect();
-    let aliased_rule_variants: Vec<_> =
-        alias_map.iter().map(|(tgt, _)| tgt.clone()).collect();
-    let shortcut_branches: Vec<_> = alias_map
-        .iter()
-        .flat_map(|(_tgt, srcs)| srcs)
-        .map(|AliasSrc { ident, is_shortcut }| {
-            quote!(
-                #rule_enum::#ident => #is_shortcut,
-            )
-        })
-        .collect();
-
-    let fn_map: HashMap<Ident, ParsedFn> = imp
-        .items
-        .iter_mut()
-        .flat_map(|item| match item {
-            ImplItem::Method(m) => Some(m),
-            _ => None,
-        })
-        .map(|method| {
-            let mut f = parse_fn(method, &mut alias_map)?;
-            apply_special_attrs(&mut f, &rule_enum)?;
-            Ok((f.fn_name.clone(), f))
-        })
-        .collect::<Result<_>>()?;
-
-    // Entries that remain in the alias map don't have a matching method, so we create one.
-    let extra_fns: Vec<_> = alias_map
-        .iter()
-        .map(|(tgt, srcs)| {
-            // Get the signature of one of the functions that has this alias. They should all have
-            // essentially the same signature anyways.
-            let f = fn_map.get(&srcs.first().unwrap().ident).unwrap();
-            let input_arg = f.input_arg.clone();
-            let mut sig = f.function.sig.clone();
-            sig.ident = tgt.clone();
-            let srcs = srcs.iter().map(|src| &src.ident);
-
-            Ok(parse_quote!(
-                #sig {
-                    match #input_arg.as_rule() {
-                        #(#rule_enum::#srcs => Self::#srcs(#input_arg),)*
-                        // We can't match on #rule_enum::#tgt since `tgt` might be an arbitrary
-                        // identifier.
-                        r if &::std::format!("{:?}", r) == ::std::stringify!(#tgt) =>
-                            return ::std::result::Result::Err(#input_arg.error(::std::format!(
-                                "make_parser: missing method for rule {}",
-                                ::std::stringify!(#tgt),
-                            ))),
-                        r => ::std::unreachable!(
-                            "make_parser: called {} on {:?}",
-                            ::std::stringify!(#tgt),
-                            r
-                        )
-                    }
-                }
-            ))
-        })
-        .collect::<Result<_>>()?;
-    imp.items.extend(extra_fns);
-
-    let ty = &imp.self_ty;
-    let (impl_generics, _, where_clause) = imp.generics.split_for_impl();
-    Ok(quote!(
-        #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-        #[allow(non_camel_case_types)]
-        enum AliasedRule {
-            #(#aliased_rule_variants,)*
-        }
-
-        impl #impl_generics ::pest_consume::Parser for #ty #where_clause {
-            type Rule = #rule_enum;
-            type AliasedRule = AliasedRule;
-            type Parser = #parser;
-            fn rule_alias(rule: Self::Rule) -> Self::AliasedRule {
-                match rule {
-                    #(#rule_alias_branches)*
-                    // TODO: return a proper error ?
-                    r => ::std::unreachable!("Rule {:?} does not have a corresponding parsing method", r),
-                }
-            }
-            fn allows_shortcut(rule: Self::Rule) -> bool {
-                match rule {
-                    #(#shortcut_branches)*
-                    _ => false,
-                }
-            }
-        }
-
-        #imp
-    ))
-}
diff --git a/pest_consume_macros/src/match_nodes.rs b/pest_consume_macros/src/match_nodes.rs
deleted file mode 100644
index a91d1f4..0000000
--- a/pest_consume_macros/src/match_nodes.rs
+++ /dev/null
@@ -1,248 +0,0 @@
-use proc_macro2::{Span, TokenStream};
-use quote::quote;
-use syn::parse::{Parse, ParseStream, Result};
-use syn::punctuated::Punctuated;
-use syn::spanned::Spanned;
-use syn::{
-    bracketed, parenthesized, parse_quote, token, Error, Expr, Ident, Pat,
-    Token, Type,
-};
-
-#[derive(Clone)]
-struct MatchBranch {
-    // Patterns all have the form [a, b, c.., d], with a bunch of simple patterns,
-    // optionally a multiple pattern, and then some more simple patterns.
-    singles_before_multiple: Vec<(Ident, Pat)>,
-    multiple: Option<(Ident, Ident)>,
-    singles_after_multiple: Vec<(Ident, Pat)>,
-
-    body: Expr,
-}
-
-#[derive(Clone)]
-enum MatchBranchPatternItem {
-    Single {
-        rule_name: Ident,
-        binder: Pat,
-    },
-    Multiple {
-        rule_name: Ident,
-        binder: Ident,
-        slice_token: Token![..],
-    },
-}
-
-#[derive(Clone)]
-struct MacroInput {
-    parser: Type,
-    input_expr: Expr,
-    branches: Punctuated<MatchBranch, Token![,]>,
-}
-
-impl Parse for MatchBranch {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let contents;
-        let _: token::Bracket = bracketed!(contents in input);
-
-        let pattern: Punctuated<MatchBranchPatternItem, Token![,]> =
-            Punctuated::parse_terminated(&contents)?;
-        use MatchBranchPatternItem::{Multiple, Single};
-        let mut singles_before_multiple = Vec::new();
-        let mut multiple = None;
-        let mut singles_after_multiple = Vec::new();
-        for item in pattern.clone() {
-            match item {
-                Single { rule_name, binder } => {
-                    if multiple.is_none() {
-                        singles_before_multiple.push((rule_name, binder))
-                    } else {
-                        singles_after_multiple.push((rule_name, binder))
-                    }
-                }
-                Multiple {
-                    rule_name,
-                    binder,
-                    slice_token,
-                } => {
-                    if multiple.is_none() {
-                        multiple = Some((rule_name, binder))
-                    } else {
-                        return Err(Error::new(
-                            slice_token.span(),
-                            "multiple variable-length patterns are not allowed",
-                        ));
-                    }
-                }
-            }
-        }
-
-        let _: Token![=>] = input.parse()?;
-        let body = input.parse()?;
-
-        Ok(MatchBranch {
-            singles_before_multiple,
-            multiple,
-            singles_after_multiple,
-            body,
-        })
-    }
-}
-
-impl Parse for MatchBranchPatternItem {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let contents;
-        let rule_name = input.parse()?;
-        parenthesized!(contents in input);
-        if input.peek(Token![..]) {
-            let binder = contents.parse()?;
-            let slice_token = input.parse()?;
-            Ok(MatchBranchPatternItem::Multiple {
-                rule_name,
-                binder,
-                slice_token,
-            })
-        } else if input.is_empty() || input.peek(Token![,]) {
-            let binder = contents.parse()?;
-            Ok(MatchBranchPatternItem::Single { rule_name, binder })
-        } else {
-            Err(input.error("expected `..` or nothing"))
-        }
-    }
-}
-
-impl Parse for MacroInput {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let parser = if input.peek(token::Lt) {
-            let _: token::Lt = input.parse()?;
-            let parser = input.parse()?;
-            let _: token::Gt = input.parse()?;
-            let _: Token![;] = input.parse()?;
-            parser
-        } else {
-            parse_quote!(Self)
-        };
-        let input_expr = input.parse()?;
-        let _: Token![;] = input.parse()?;
-        let branches = Punctuated::parse_terminated(input)?;
-
-        Ok(MacroInput {
-            parser,
-            input_expr,
-            branches,
-        })
-    }
-}
-
-fn make_branch(
-    branch: &MatchBranch,
-    i_nodes: &Ident,
-    i_node_rules: &Ident,
-    parser: &Type,
-) -> Result<TokenStream> {
-    let aliased_rule = quote!(<#parser as ::pest_consume::Parser>::AliasedRule);
-
-    // Find which branch to take
-    let mut conditions = Vec::new();
-    let start = branch.singles_before_multiple.len();
-    let end = branch.singles_after_multiple.len();
-    conditions.push(quote!(
-        #start + #end <= #i_node_rules.len()
-    ));
-    for (i, (rule_name, _)) in branch.singles_before_multiple.iter().enumerate()
-    {
-        conditions.push(quote!(
-            #i_node_rules[#i] == #aliased_rule::#rule_name
-        ))
-    }
-    for (i, (rule_name, _)) in branch.singles_after_multiple.iter().enumerate()
-    {
-        conditions.push(quote!(
-            #i_node_rules[#i_node_rules.len()-1 - #i] == #aliased_rule::#rule_name
-        ))
-    }
-    if let Some((rule_name, _)) = &branch.multiple {
-        conditions.push(quote!(
-            {
-                // We can't use .all() directly in the pattern guard; see
-                // https://github.com/rust-lang/rust/issues/59803.
-                let all_match = |slice: &[_]| {
-                    slice.iter().all(|r|
-                        *r == #aliased_rule::#rule_name
-                    )
-                };
-                all_match(&#i_node_rules[#start..#i_node_rules.len() - #end])
-            }
-        ))
-    } else {
-        // No variable-length pattern, so the size must be exactly the number of patterns
-        conditions.push(quote!(
-            #start + #end == #i_node_rules.len()
-        ))
-    }
-
-    // Once we have found a branch that matches, we need to parse the nodes.
-    let mut parses = Vec::new();
-    for (rule_name, binder) in branch.singles_before_multiple.iter() {
-        parses.push(quote!(
-            let #binder = #parser::#rule_name(
-                #i_nodes.next().unwrap()
-            )?;
-        ))
-    }
-    // Note the `rev()`: we are taking nodes from the end of the iterator in reverse order, so that
-    // only the unmatched nodes are left in the iterator for the variable-length pattern, if any.
-    for (rule_name, binder) in branch.singles_after_multiple.iter().rev() {
-        parses.push(quote!(
-            let #binder = #parser::#rule_name(
-                #i_nodes.next_back().unwrap()
-            )?;
-        ))
-    }
-    if let Some((rule_name, binder)) = &branch.multiple {
-        parses.push(quote!(
-            let #binder = #i_nodes
-                .map(|i| #parser::#rule_name(i))
-                .collect::<::std::result::Result<::std::vec::Vec<_>, _>>()?
-                .into_iter();
-        ))
-    }
-
-    let body = &branch.body;
-    Ok(quote!(
-        _ if #(#conditions &&)* true => {
-            #(#parses)*
-            #body
-        }
-    ))
-}
-
-pub fn match_nodes(
-    input: proc_macro::TokenStream,
-) -> Result<proc_macro2::TokenStream> {
-    let input: MacroInput = syn::parse(input)?;
-
-    let i_nodes = Ident::new("___nodes", input.input_expr.span());
-    let i_node_rules = Ident::new("___node_rules", Span::call_site());
-
-    let input_expr = &input.input_expr;
-    let parser = &input.parser;
-    let branches = input
-        .branches
-        .iter()
-        .map(|br| make_branch(br, &i_nodes, &i_node_rules, parser))
-        .collect::<Result<Vec<_>>>()?;
-
-    Ok(quote!({
-        #[allow(unused_mut)]
-        let mut #i_nodes = #input_expr;
-        let #i_node_rules = #i_nodes.aliased_rules::<#parser>();
-
-        #[allow(unreachable_code)]
-        match () {
-            #(#branches,)*
-            _ => return ::std::result::Result::Err(#i_nodes.error(
-                std::format!("Nodes didn't match any pattern: {:?}", #i_node_rules)
-            )),
-        }
-    }))
-}
-- 
cgit v1.2.3