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(-)

(limited to 'dhall_syntax')

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_syntax/src/core/expr.rs |   8 +-
 dhall_syntax/src/parser.rs    | 508 +++++++++++++++++++++---------------------
 2 files changed, 261 insertions(+), 255 deletions(-)

(limited to 'dhall_syntax')

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

---
 dhall_syntax/Cargo.toml    |   1 +
 dhall_syntax/src/parser.rs | 132 ++-------------------------------------------
 2 files changed, 4 insertions(+), 129 deletions(-)

(limited to 'dhall_syntax')

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),
-- 
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 +++++++++++++++++++++++-----------------------
 1 file changed, 36 insertions(+), 36 deletions(-)

(limited to 'dhall_syntax')

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
         ))
     }
-- 
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 +++++++++++++++++++++++-----------------------
 1 file changed, 37 insertions(+), 37 deletions(-)

(limited to 'dhall_syntax')

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
         ))
     }
-- 
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 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

(limited to 'dhall_syntax')

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)
 }
-- 
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 +
 1 file changed, 1 insertion(+)

(limited to 'dhall_syntax')

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();
-- 
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 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'dhall_syntax')

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,
         ))
-- 
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 ++++++++++++++------------------
 1 file changed, 14 insertions(+), 18 deletions(-)

(limited to 'dhall_syntax')

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,
+    ))
 }
-- 
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

---
 dhall_syntax/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

(limited to 'dhall_syntax')

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,
-- 
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
---
 dhall_syntax/Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

(limited to 'dhall_syntax')

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 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 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'dhall_syntax')

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(())
-- 
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 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

(limited to 'dhall_syntax')

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,
-- 
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 +++++++++++++++++++++++-----------------------
 1 file changed, 38 insertions(+), 38 deletions(-)

(limited to 'dhall_syntax')

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,
     ))
 }
-- 
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 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

(limited to 'dhall_syntax')

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() {
             "\\\"" => "\"",
             "\\\\" => "\\",
-- 
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 -
 1 file changed, 1 deletion(-)

(limited to 'dhall_syntax')

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,
-- 
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 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'dhall_syntax')

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(())
-- 
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

---
 dhall_syntax/Cargo.toml    |  3 +--
 dhall_syntax/src/parser.rs | 62 ++++++++++++++++++++--------------------------
 2 files changed, 28 insertions(+), 37 deletions(-)

(limited to 'dhall_syntax')

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