Merge branch 'master' into fintan/canonicalize

10 files changed, 241 insertions, 921 deletions

diff --git a/dhall_generated_parser/Cargo.toml b/dhall_generated_parser/Cargo.toml
index 0730f60..b1f0d02 100644
--- a/dhall_generated_parser/Cargo.toml
+++ b/dhall_generated_parser/Cargo.toml
@@ -12,8 +12,7 @@ doctest = false
 
 [build-dependencies]
 abnf_to_pest = { version = "0.1.1", path = "../abnf_to_pest" }
-pest_generator = "2.1"
-quote = "1.0.2"
 
 [dependencies]
 pest = "2.1"
+pest_derive = "2.1"
diff --git a/dhall_generated_parser/build.rs b/dhall_generated_parser/build.rs
index c562fad..68895dd 100644
--- a/dhall_generated_parser/build.rs
+++ b/dhall_generated_parser/build.rs
@@ -1,7 +1,5 @@
-use std::env;
 use std::fs::File;
 use std::io::{BufRead, BufReader, Read, Write};
-use std::path::Path;
 
 use abnf_to_pest::render_rules_to_pest;
 
@@ -90,20 +88,5 @@ fn main() -> std::io::Result<()> {
     writeln!(&mut file)?;
     writeln!(&mut file, "{}", render_rules_to_pest(rules).pretty(80))?;
 
-    // Generate pest parser manually to avoid spurious recompilations
-    let derived = {
-        let pest_path = "dhall.pest";
-        let pest = quote::quote! {
-            #[grammar = #pest_path]
-            pub struct DhallParser;
-        };
-        pest_generator::derive_parser(pest, false)
-    };
-
-    let out_dir = env::var("OUT_DIR").unwrap();
-    let grammar_path = Path::new(&out_dir).join("grammar.rs");
-    let mut file = File::create(grammar_path)?;
-    writeln!(file, "pub struct DhallParser;\n{}", derived,)?;
-
     Ok(())
 }
diff --git a/dhall_generated_parser/src/lib.rs b/dhall_generated_parser/src/lib.rs
index 280b75e..fbb9ccd 100644
--- a/dhall_generated_parser/src/lib.rs
+++ b/dhall_generated_parser/src/lib.rs
@@ -14,4 +14,9 @@
 // additional overrides are done in ../build.rs.
 // The lines that are commented out in ./dhall.pest.visibility are marked as
 // silent (see pest docs for what that means) in the generated pest file.
-include!(concat!(env!("OUT_DIR"), "/grammar.rs"));
+
+use pest_derive::Parser;
+
+#[derive(Parser)]
+#[grammar = "dhall.pest"]
+pub struct DhallParser;
diff --git a/dhall_proc_macros/src/lib.rs b/dhall_proc_macros/src/lib.rs
index 37e8f9f..5304429 100644
--- a/dhall_proc_macros/src/lib.rs
+++ b/dhall_proc_macros/src/lib.rs
@@ -1,4 +1,3 @@
-#![feature(drain_filter)]
 //! This crate contains the code-generation primitives for the [dhall-rust][dhall-rust] crate.
 //! This is highly unstable and breaks regularly; use at your own risk.
 //!
@@ -7,8 +6,6 @@
 extern crate proc_macro;
 
 mod derive;
-mod make_parser;
-mod parse_children;
 
 use proc_macro::TokenStream;
 
@@ -16,19 +13,3 @@ use proc_macro::TokenStream;
 pub fn derive_static_type(input: TokenStream) -> TokenStream {
     derive::derive_static_type(input)
 }
-
-#[proc_macro_attribute]
-pub fn make_parser(attrs: TokenStream, input: TokenStream) -> TokenStream {
-    TokenStream::from(match make_parser::make_parser(attrs, input) {
-        Ok(tokens) => tokens,
-        Err(err) => err.to_compile_error(),
-    })
-}
-
-#[proc_macro]
-pub fn parse_children(input: TokenStream) -> TokenStream {
-    TokenStream::from(match parse_children::parse_children(input) {
-        Ok(tokens) => tokens,
-        Err(err) => err.to_compile_error(),
-    })
-}
diff --git a/dhall_proc_macros/src/make_parser.rs b/dhall_proc_macros/src/make_parser.rs
deleted file mode 100644
index a17ab61..0000000
--- a/dhall_proc_macros/src/make_parser.rs
+++ /dev/null
@@ -1,334 +0,0 @@
-use std::collections::HashMap;
-use std::iter;
-
-use quote::quote;
-use syn::parse::{Parse, ParseStream, Result};
-use syn::spanned::Spanned;
-use syn::{
-    parse_quote, Error, Expr, FnArg, Ident, ImplItem, ImplItemMethod, ItemImpl,
-    LitBool, Pat, Token,
-};
-
-mod kw {
-    syn::custom_keyword!(shortcut);
-}
-
-struct AliasArgs {
-    target: Ident,
-    is_shortcut: bool,
-}
-
-struct PrecClimbArgs {
-    child_rule: Ident,
-    climber: Expr,
-}
-
-struct AliasSrc {
-    ident: Ident,
-    is_shortcut: bool,
-}
-
-struct ParsedFn<'a> {
-    // Body of the function
-    function: &'a mut ImplItemMethod,
-    // Name of the function.
-    fn_name: Ident,
-    // Name of the first argument of the function, which should be of type `ParseInput`.
-    input_arg: Ident,
-    // List of aliases pointing to this function
-    alias_srcs: Vec<AliasSrc>,
-}
-
-impl Parse for AliasArgs {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let target = input.parse()?;
-        let is_shortcut = if input.peek(Token![,]) {
-            // #[alias(rule, shortcut = true)]
-            let _: Token![,] = input.parse()?;
-            let _: kw::shortcut = input.parse()?;
-            let _: Token![=] = input.parse()?;
-            let b: LitBool = input.parse()?;
-            b.value
-        } else {
-            // #[alias(rule)]
-            false
-        };
-        Ok(AliasArgs {
-            target,
-            is_shortcut,
-        })
-    }
-}
-
-impl Parse for PrecClimbArgs {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let child_rule = input.parse()?;
-        let _: Token![,] = input.parse()?;
-        let climber = input.parse()?;
-        Ok(PrecClimbArgs {
-            child_rule,
-            climber,
-        })
-    }
-}
-
-fn collect_aliases(
-    imp: &mut ItemImpl,
-) -> Result<HashMap<Ident, Vec<AliasSrc>>> {
-    let functions = imp.items.iter_mut().flat_map(|item| match item {
-        ImplItem::Method(m) => Some(m),
-        _ => None,
-    });
-
-    let mut alias_map = HashMap::new();
-    for function in functions {
-        let fn_name = function.sig.ident.clone();
-        let mut alias_attrs = function
-            .attrs
-            .drain_filter(|attr| attr.path.is_ident("alias"))
-            .collect::<Vec<_>>()
-            .into_iter();
-
-        if let Some(attr) = alias_attrs.next() {
-            let args: AliasArgs = attr.parse_args()?;
-            alias_map.entry(args.target).or_insert_with(Vec::new).push(
-                AliasSrc {
-                    ident: fn_name,
-                    is_shortcut: args.is_shortcut,
-                },
-            );
-        }
-        if let Some(attr) = alias_attrs.next() {
-            return Err(Error::new(
-                attr.span(),
-                "expected at most one alias attribute",
-            ));
-        }
-    }
-
-    Ok(alias_map)
-}
-
-fn parse_fn<'a>(
-    function: &'a mut ImplItemMethod,
-    alias_map: &mut HashMap<Ident, Vec<AliasSrc>>,
-) -> Result<ParsedFn<'a>> {
-    let fn_name = function.sig.ident.clone();
-    // Get the name of the first (`input`) function argument
-    let input_arg = function.sig.inputs.first().ok_or_else(|| {
-        Error::new(
-            function.sig.inputs.span(),
-            "a rule function needs an `input` argument",
-        )
-    })?;
-    let input_arg = match &input_arg {
-        FnArg::Receiver(_) => return Err(Error::new(
-            input_arg.span(),
-            "a rule function should not have a `self` argument",
-        )),
-        FnArg::Typed(input_arg) => match &*input_arg.pat{
-            Pat::Ident(ident) => ident.ident.clone(),
-            _ => return Err(Error::new(
-                input_arg.span(),
-                "this argument should be a plain identifier instead of a pattern",
-            )),
-        }
-    };
-
-    let alias_srcs = alias_map.remove(&fn_name).unwrap_or_else(Vec::new);
-
-    Ok(ParsedFn {
-        function,
-        fn_name,
-        input_arg,
-        alias_srcs,
-    })
-}
-
-fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Ident) -> Result<()> {
-    let function = &mut *f.function;
-    let fn_name = &f.fn_name;
-    let input_arg = &f.input_arg;
-
-    *function = parse_quote!(
-        #[allow(non_snake_case)]
-        #function
-    );
-
-    // `prec_climb` attr
-    let prec_climb_attrs: Vec<_> = function
-        .attrs
-        .drain_filter(|attr| attr.path.is_ident("prec_climb"))
-        .collect();
-
-    if prec_climb_attrs.len() > 1 {
-        return Err(Error::new(
-            prec_climb_attrs[1].span(),
-            "expected at most one prec_climb attribute",
-        ));
-    } else if prec_climb_attrs.is_empty() {
-        // do nothing
-    } else {
-        let attr = prec_climb_attrs.into_iter().next().unwrap();
-        let PrecClimbArgs {
-            child_rule,
-            climber,
-        } = attr.parse_args()?;
-
-        function.block = parse_quote!({
-            #function
-
-            #climber.climb(
-                #input_arg.pair.clone().into_inner(),
-                |p| Self::#child_rule(#input_arg.with_pair(p)),
-                |l, op, r| {
-                    #fn_name(#input_arg.clone(), l?, op, r?)
-                },
-            )
-        });
-        // Remove the 3 last arguments to keep only the `input` one
-        function.sig.inputs.pop();
-        function.sig.inputs.pop();
-        function.sig.inputs.pop();
-        // Check that an argument remains
-        function.sig.inputs.first().ok_or_else(|| {
-            Error::new(
-                function.sig.inputs.span(),
-                "a prec_climb function needs 4 arguments",
-            )
-        })?;
-    }
-
-    // `alias` attr
-    if !f.alias_srcs.is_empty() {
-        let aliases = f.alias_srcs.iter().map(|src| &src.ident);
-        let block = &function.block;
-        function.block = parse_quote!({
-            let mut #input_arg = #input_arg;
-            // While the current rule allows shortcutting, and there is a single child, and the
-            // child can still be parsed by the current function, then skip to that child.
-            while <Self as PestConsumer>::allows_shortcut(#input_arg.as_rule()) {
-                if let Some(child) = #input_arg.single_child() {
-                    if &<Self as PestConsumer>::rule_alias(child.as_rule())
-                            == stringify!(#fn_name) {
-                        #input_arg = child;
-                        continue;
-                    }
-                }
-                break
-            }
-
-            match #input_arg.as_rule() {
-                #(#rule_enum::#aliases => Self::#aliases(#input_arg),)*
-                #rule_enum::#fn_name => #block,
-                r => unreachable!(
-                    "make_parser: called {} on {:?}",
-                    stringify!(#fn_name),
-                    r
-                )
-            }
-        });
-    }
-
-    Ok(())
-}
-
-pub fn make_parser(
-    attrs: proc_macro::TokenStream,
-    input: proc_macro::TokenStream,
-) -> Result<proc_macro2::TokenStream> {
-    let rule_enum: Ident = syn::parse(attrs)?;
-    let mut imp: ItemImpl = syn::parse(input)?;
-
-    let mut alias_map = collect_aliases(&mut imp)?;
-    let rule_alias_branches: Vec<_> = alias_map
-        .iter()
-        .flat_map(|(tgt, srcs)| iter::repeat(tgt).zip(srcs))
-        .map(|(tgt, src)| {
-            let ident = &src.ident;
-            quote!(
-                #rule_enum::#ident => stringify!(#tgt).to_string(),
-            )
-        })
-        .collect();
-    let shortcut_branches: Vec<_> = alias_map
-        .iter()
-        .flat_map(|(_tgt, srcs)| srcs)
-        .map(|AliasSrc { ident, is_shortcut }| {
-            quote!(
-                #rule_enum::#ident => #is_shortcut,
-            )
-        })
-        .collect();
-
-    let fn_map: HashMap<Ident, ParsedFn> = imp
-        .items
-        .iter_mut()
-        .flat_map(|item| match item {
-            ImplItem::Method(m) => Some(m),
-            _ => None,
-        })
-        .map(|method| {
-            let mut f = parse_fn(method, &mut alias_map)?;
-            apply_special_attrs(&mut f, &rule_enum)?;
-            Ok((f.fn_name.clone(), f))
-        })
-        .collect::<Result<_>>()?;
-
-    // Entries that remain in the alias map don't have a matching method, so we create one.
-    let extra_fns: Vec<_> = alias_map
-        .iter()
-        .map(|(tgt, srcs)| {
-            // Get the signature of one of the functions that has this alias. They should all have
-            // essentially the same signature anyways.
-            let f = fn_map.get(&srcs.first().unwrap().ident).unwrap();
-            let input_arg = f.input_arg.clone();
-            let mut sig = f.function.sig.clone();
-            sig.ident = tgt.clone();
-            let srcs = srcs.iter().map(|src| &src.ident);
-
-            Ok(parse_quote!(
-                #sig {
-                    match #input_arg.as_rule() {
-                        #(#rule_enum::#srcs => Self::#srcs(#input_arg),)*
-                        // We can't match on #rule_enum::#tgt since `tgt` might be an arbitrary
-                        // identifier.
-                        r if &format!("{:?}", r) == stringify!(#tgt) =>
-                            return Err(#input_arg.error(format!(
-                                "make_parser: missing method for rule {}",
-                                stringify!(#tgt),
-                            ))),
-                        r => unreachable!(
-                            "make_parser: called {} on {:?}",
-                            stringify!(#tgt),
-                            r
-                        )
-                    }
-                }
-            ))
-        })
-        .collect::<Result<_>>()?;
-    imp.items.extend(extra_fns);
-
-    let ty = &imp.self_ty;
-    let (impl_generics, _, where_clause) = imp.generics.split_for_impl();
-    Ok(quote!(
-        impl #impl_generics PestConsumer for #ty #where_clause {
-            type Rule = #rule_enum;
-            fn rule_alias(rule: Self::Rule) -> String {
-                match rule {
-                    #(#rule_alias_branches)*
-                    r => format!("{:?}", r),
-                }
-            }
-            fn allows_shortcut(rule: Self::Rule) -> bool {
-                match rule {
-                    #(#shortcut_branches)*
-                    _ => false,
-                }
-            }
-        }
-
-        #imp
-    ))
-}
diff --git a/dhall_proc_macros/src/parse_children.rs b/dhall_proc_macros/src/parse_children.rs
deleted file mode 100644
index a35c03f..0000000
--- a/dhall_proc_macros/src/parse_children.rs
+++ /dev/null
@@ -1,215 +0,0 @@
-use proc_macro2::{Span, TokenStream};
-use quote::quote;
-use syn::parse::{Parse, ParseStream, Result};
-use syn::punctuated::Punctuated;
-use syn::spanned::Spanned;
-use syn::{bracketed, parenthesized, token, Error, Expr, Ident, Pat, Token};
-
-#[derive(Debug, Clone)]
-struct ChildrenBranch {
-    pattern_span: Span,
-    pattern: Punctuated<ChildrenBranchPatternItem, Token![,]>,
-    body: Expr,
-}
-
-#[derive(Debug, Clone)]
-enum ChildrenBranchPatternItem {
-    Single { rule_name: Ident, binder: Pat },
-    Multiple { rule_name: Ident, binder: Ident },
-}
-
-#[derive(Debug, Clone)]
-struct ParseChildrenInput {
-    input_expr: Expr,
-    branches: Punctuated<ChildrenBranch, Token![,]>,
-}
-
-impl Parse for ChildrenBranch {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let contents;
-        let _: token::Bracket = bracketed!(contents in input);
-        let pattern_unparsed: TokenStream = contents.fork().parse()?;
-        let pattern_span = pattern_unparsed.span();
-        let pattern = Punctuated::parse_terminated(&contents)?;
-        let _: Token![=>] = input.parse()?;
-        let body = input.parse()?;
-
-        Ok(ChildrenBranch {
-            pattern_span,
-            pattern,
-            body,
-        })
-    }
-}
-
-impl Parse for ChildrenBranchPatternItem {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let contents;
-        let rule_name = input.parse()?;
-        parenthesized!(contents in input);
-        if input.peek(Token![..]) {
-            let binder = contents.parse()?;
-            let _: Token![..] = input.parse()?;
-            Ok(ChildrenBranchPatternItem::Multiple { rule_name, binder })
-        } else if input.is_empty() || input.peek(Token![,]) {
-            let binder = contents.parse()?;
-            Ok(ChildrenBranchPatternItem::Single { rule_name, binder })
-        } else {
-            Err(input.error("expected `..` or nothing"))
-        }
-    }
-}
-
-impl Parse for ParseChildrenInput {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let input_expr = input.parse()?;
-        let _: Token![;] = input.parse()?;
-        let branches = Punctuated::parse_terminated(input)?;
-
-        Ok(ParseChildrenInput {
-            input_expr,
-            branches,
-        })
-    }
-}
-
-fn make_parser_branch(
-    branch: &ChildrenBranch,
-    i_inputs: &Ident,
-) -> Result<TokenStream> {
-    use ChildrenBranchPatternItem::{Multiple, Single};
-
-    let body = &branch.body;
-
-    // Convert the input pattern into a pattern-match on the Rules of the children. This uses
-    // slice_patterns.
-    // A single pattern just checks that the rule matches; a variable-length pattern binds the
-    // subslice and checks, in the if-guard, that its elements all match the chosen Rule.
-    let i_variable_pattern =
-        Ident::new("___variable_pattern", Span::call_site());
-    let match_pat = branch.pattern.iter().map(|item| match item {
-        Single { rule_name, .. } => quote!(stringify!(#rule_name)),
-        Multiple { .. } => quote!(#i_variable_pattern @ ..),
-    });
-    let match_filter = branch.pattern.iter().map(|item| match item {
-        Single { .. } => quote!(),
-        Multiple { rule_name, .. } => quote!(
-            {
-                // We can't use .all() directly in the pattern guard; see
-                // https://github.com/rust-lang/rust/issues/59803.
-                let all_match = |slice: &[_]| {
-                    slice.iter().all(|r|
-                        *r == stringify!(#rule_name)
-                    )
-                };
-                all_match(#i_variable_pattern)
-            } &&
-        ),
-    });
-
-    // Once we have found a branch that matches, we need to parse the children.
-    let mut singles_before_multiple = Vec::new();
-    let mut multiple = None;
-    let mut singles_after_multiple = Vec::new();
-    for item in &branch.pattern {
-        match item {
-            Single {
-                rule_name, binder, ..
-            } => {
-                if multiple.is_none() {
-                    singles_before_multiple.push((rule_name, binder))
-                } else {
-                    singles_after_multiple.push((rule_name, binder))
-                }
-            }
-            Multiple {
-                rule_name, binder, ..
-            } => {
-                if multiple.is_none() {
-                    multiple = Some((rule_name, binder))
-                } else {
-                    return Err(Error::new(
-                        branch.pattern_span.clone(),
-                        "multiple variable-length patterns are not allowed",
-                    ));
-                }
-            }
-        }
-    }
-    let mut parses = Vec::new();
-    for (rule_name, binder) in singles_before_multiple.into_iter() {
-        parses.push(quote!(
-            let #binder = Self::#rule_name(
-                #i_inputs.next().unwrap()
-            )?;
-        ))
-    }
-    // Note the `rev()`: we are taking inputs from the end of the iterator in reverse order, so that
-    // only the unmatched inputs are left for the variable-length pattern, if any.
-    for (rule_name, binder) in singles_after_multiple.into_iter().rev() {
-        parses.push(quote!(
-            let #binder = Self::#rule_name(
-                #i_inputs.next_back().unwrap()
-            )?;
-        ))
-    }
-    if let Some((rule_name, binder)) = multiple {
-        parses.push(quote!(
-            let #binder = #i_inputs
-                .map(|i| Self::#rule_name(i))
-                .collect::<Result<Vec<_>, _>>()?
-                .into_iter();
-        ))
-    }
-
-    Ok(quote!(
-        [#(#match_pat),*] if #(#match_filter)* true => {
-            #(#parses)*
-            #body
-        }
-    ))
-}
-
-pub fn parse_children(
-    input: proc_macro::TokenStream,
-) -> Result<proc_macro2::TokenStream> {
-    let input: ParseChildrenInput = syn::parse(input)?;
-
-    let i_children_rules = Ident::new("___children_rules", Span::call_site());
-    let i_inputs = Ident::new("___inputs", Span::call_site());
-
-    let input_expr = &input.input_expr;
-    let branches = input
-        .branches
-        .iter()
-        .map(|br| make_parser_branch(br, &i_inputs))
-        .collect::<Result<Vec<_>>>()?;
-
-    Ok(quote!({
-        let #i_children_rules: Vec<_> = #input_expr.pair
-            .clone()
-            .into_inner()
-            .map(|p| p.as_rule())
-            .map(<Self as PestConsumer>::rule_alias)
-            .collect();
-        let #i_children_rules: Vec<&str> = #i_children_rules
-            .iter()
-            .map(String::as_str)
-            .collect();
-
-        #[allow(unused_mut)]
-        let mut #i_inputs = #input_expr
-            .pair
-            .clone()
-            .into_inner()
-            .map(|p| #input_expr.with_pair(p));
-
-        #[allow(unreachable_code)]
-        match #i_children_rules.as_slice() {
-            #(#branches,)*
-            [..] => return Err(#input_expr.error(
-                format!("Unexpected children: {:?}", #i_children_rules)
-            )),
-        }
-    }))
-}
diff --git a/dhall_syntax/Cargo.toml b/dhall_syntax/Cargo.toml
index eb492d0..b98c4a4 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 = "1.0"
diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index 2cb23c9..74b481f 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.clone()
+    }
 
-    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))))
     }
 
@@ -384,13 +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)
-}
-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
 fn add_ui(u: usize, i: isize) -> Option<usize> {
diff --git a/dhall_syntax/src/lib.rs b/dhall_syntax/src/lib.rs
index 95f40c2..b8fa19f 100644
--- a/dhall_syntax/src/lib.rs
+++ b/dhall_syntax/src/lib.rs
@@ -1,7 +1,5 @@
 #![feature(trace_macros)]
-#![feature(slice_patterns)]
 #![feature(never_type)]
-#![feature(proc_macro_hygiene)]
 #![allow(
     clippy::many_single_char_names,
     clippy::should_implement_trait,
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 41d6d04..f2dea53 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -1,13 +1,11 @@
 use itertools::Itertools;
-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};
-use dhall_proc_macros::{make_parser, parse_children};
+use dgp::Rule;
+use dhall_generated_parser as dgp;
+use pest_consume::{match_nodes, Parser};
 
 use crate::map::{DupTreeMap, DupTreeSet};
 use crate::ExprF::*;
@@ -20,115 +18,11 @@ use crate::*;
 
 type ParsedText<E> = InterpolatedText<Expr<E>>;
 type ParsedTextContents<E> = InterpolatedTextContents<Expr<E>>;
+type ParseInput<'input> = pest_consume::Node<'input, Rule, Rc<str>>;
 
 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(),
-        }
-    }
-    /// 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));
-            }
-        }
-        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()
-    }
-}
-
-// Used by the macros.
-trait PestConsumer {
-    type Rule: pest::RuleType;
-    fn rule_alias(rule: Self::Rule) -> String;
-    fn allows_shortcut(rule: Self::Rule) -> bool;
-}
-
-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();
-                }
-            }
-            aux(s, indent + 1, "".into(), p);
-        }
-        if first {
-            writeln!(
-                s,
-                r#"{}{}{:?}: "{}""#,
-                indent_str, prefix, rule, contents
-            )
-            .unwrap();
-        }
-    }
-    aux(&mut s, 0, "".into(), pair);
-    s
-}
-
 #[derive(Debug)]
 enum Either<A, B> {
     Left(A),
@@ -173,6 +67,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>>) {
@@ -242,27 +146,27 @@ lazy_static::lazy_static! {
     };
 }
 
-struct Parsers;
+struct DhallParser;
 
-#[make_parser(Rule)]
-impl Parsers {
-    fn EOI(_input: ParseInput<Rule>) -> ParseResult<()> {
+#[pest_consume::parser(parser = dgp::DhallParser, rule = dgp::Rule)]
+impl DhallParser {
+    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;
+        Ok(match_nodes!(input.into_children();
             [double_quote_chunk(chunks)..] => {
                 chunks.collect()
             }
@@ -270,9 +174,9 @@ impl Parsers {
     }
 
     fn double_quote_chunk<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<ParsedTextContents<E>> {
-        Ok(parse_children!(input;
+        Ok(match_nodes!(input.into_children();
             [expression(e)] => {
                 InterpolatedTextContents::Expr(e)
             },
@@ -282,7 +186,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,16 +256,14 @@ 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;
+        Ok(match_nodes!(input.into_children();
             [single_quote_continue(lines)] => {
                 let newline: ParsedText<E> = "\n".to_string().into();
 
@@ -382,29 +284,23 @@ impl Parsers {
             }
         ))
     }
-    fn single_quote_char<'a>(
-        input: ParseInput<'a, Rule>,
-    ) -> 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, Rule>,
-    ) -> ParseResult<&'a str> {
+    fn escaped_quote_pair(_input: ParseInput) -> ParseResult<&str> {
         Ok("''")
     }
     #[alias(single_quote_char)]
-    fn escaped_interpolation<'a>(
-        _input: ParseInput<'a, Rule>,
-    ) -> ParseResult<&'a str> {
+    fn escaped_interpolation(_input: ParseInput) -> ParseResult<&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;
+        Ok(match_nodes!(input.into_children();
             [expression(e), single_quote_continue(lines)] => {
                 let c = InterpolatedTextContents::Expr(e);
                 let mut lines = lines;
@@ -429,7 +325,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 +338,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 +367,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 +375,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,36 +384,26 @@ impl Parsers {
     }
 
     #[alias(expression, shortcut = true)]
-    fn identifier<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input;
-            [variable(v)] => {
-                spanned(input.as_span(), Var(v))
-            },
+    fn identifier<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
+        Ok(match_nodes!(input.children();
+            [variable(v)] => spanned(input, Var(v)),
             [expression(e)] => e,
         ))
     }
 
-    fn variable(input: ParseInput<Rule>) -> ParseResult<V<Label>> {
-        Ok(parse_children!(input;
-            [label(l), natural_literal(idx)] => {
-                V(l, idx)
-            },
-            [label(l)] => {
-                V(l, 0)
-            },
+    fn variable(input: ParseInput) -> ParseResult<V<Label>> {
+        Ok(match_nodes!(input.into_children();
+            [label(l), natural_literal(idx)] => V(l, idx),
+            [label(l)] => V(l, 0),
         ))
     }
 
     #[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,8 +429,8 @@ impl Parsers {
             })
             .collect())
     }
-    fn path(input: ParseInput<Rule>) -> ParseResult<FilePath> {
-        Ok(parse_children!(input;
+    fn path(input: ParseInput) -> ParseResult<FilePath> {
+        Ok(match_nodes!(input.into_children();
             [path_component(components)..] => {
                 FilePath { file_path: components.collect() }
             }
@@ -559,47 +439,43 @@ impl Parsers {
 
     #[alias(import_type)]
     fn local<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
-        Ok(parse_children!(input;
+        Ok(match_nodes!(input.into_children();
             [local_path((prefix, p))] => ImportLocation::Local(prefix, p),
         ))
     }
 
     #[alias(local_path)]
     fn parent_path(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<(FilePrefix, FilePath)> {
-        Ok(parse_children!(input;
+        Ok(match_nodes!(input.into_children();
             [path(p)] => (FilePrefix::Parent, p)
         ))
     }
     #[alias(local_path)]
-    fn here_path(
-        input: ParseInput<Rule>,
-    ) -> ParseResult<(FilePrefix, FilePath)> {
-        Ok(parse_children!(input;
+    fn here_path(input: ParseInput) -> ParseResult<(FilePrefix, FilePath)> {
+        Ok(match_nodes!(input.into_children();
             [path(p)] => (FilePrefix::Here, p)
         ))
     }
     #[alias(local_path)]
-    fn home_path(
-        input: ParseInput<Rule>,
-    ) -> ParseResult<(FilePrefix, FilePath)> {
-        Ok(parse_children!(input;
+    fn home_path(input: ParseInput) -> ParseResult<(FilePrefix, FilePath)> {
+        Ok(match_nodes!(input.into_children();
             [path(p)] => (FilePrefix::Home, p)
         ))
     }
     #[alias(local_path)]
     fn absolute_path(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<(FilePrefix, FilePath)> {
-        Ok(parse_children!(input;
+        Ok(match_nodes!(input.into_children();
             [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,10 +483,8 @@ impl Parsers {
         })
     }
 
-    fn http_raw<E: Clone>(
-        input: ParseInput<Rule>,
-    ) -> ParseResult<URL<Expr<E>>> {
-        Ok(parse_children!(input;
+    fn http_raw<E: Clone>(input: ParseInput) -> ParseResult<URL<Expr<E>>> {
+        Ok(match_nodes!(input.into_children();
             [scheme(sch), authority(auth), path(p)] => URL {
                 scheme: sch,
                 authority: auth,
@@ -628,19 +502,19 @@ 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;
+        Ok(ImportLocation::Remote(match_nodes!(input.into_children();
             [http_raw(url)] => url,
             [http_raw(url), expression(e)] => URL { headers: Some(e), ..url },
         )))
@@ -648,53 +522,49 @@ impl Parsers {
 
     #[alias(import_type)]
     fn env<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
-        Ok(parse_children!(input;
+        Ok(match_nodes!(input.into_children();
             [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> {
-        Ok(parse_children!(input;
+    fn posix_environment_variable(input: ParseInput) -> ParseResult<String> {
+        Ok(match_nodes!(input.into_children();
             [posix_environment_variable_character(chars)..] => {
                 chars.collect()
             },
         ))
     }
-    fn posix_environment_variable_character<'a>(
-        input: ParseInput<'a, Rule>,
-    ) -> ParseResult<Cow<'a, str>> {
+    fn posix_environment_variable_character(
+        input: ParseInput,
+    ) -> ParseResult<&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,29 +575,29 @@ impl Parsers {
     }
 
     fn import_hashed<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<crate::Import<Expr<E>>> {
         use crate::Import;
         let mode = ImportMode::Code;
-        Ok(parse_children!(input;
+        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) },
         ))
     }
 
     #[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;
+        let import = match_nodes!(input.children();
             [import_hashed(imp)] => {
                 Import { mode: ImportMode::Code, ..imp }
             },
@@ -735,97 +605,99 @@ 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>> {
-        Ok(parse_children!(input;
-            [expression(e)] => spanned(input.as_span(), EmptyListLit(e)),
+    fn empty_list_literal<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
+        Ok(match_nodes!(input.children();
+            [expression(e)] => spanned(input, EmptyListLit(e)),
         ))
     }
 
-    fn expression<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
-        let span = input.as_span();
-        Ok(parse_children!(input;
+    fn expression<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
+        Ok(match_nodes!(input.children();
             [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| unspanned(Let(x.0, x.1, x.2, acc))
+                    |acc, x| {
+                        spanned_union(
+                            acc.span().unwrap(),
+                            x.3,
+                            Let(x.0, x.1, x.2, acc)
+                        )
+                    }
                 )
             },
             [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>,
-    ) -> ParseResult<(Label, Option<Expr<E>>, Expr<E>)> {
-        Ok(parse_children!(input;
+        input: ParseInput,
+    ) -> ParseResult<(Label, Option<Expr<E>>, Expr<E>, Span)> {
+        Ok(match_nodes!(input.children();
             [label(name), expression(annot), expression(expr)] =>
-                (name, Some(annot), expr),
+                (name, Some(annot), expr, input_to_span(input)),
             [label(name), expression(expr)] =>
-                (name, None, expr),
+                (name, None, expr, input_to_span(input)),
         ))
     }
 
     #[alias(expression, shortcut = true)]
     #[prec_climb(expression, PRECCLIMBER)]
     fn operator_expression<E: Clone>(
-        input: ParseInput<Rule>,
         l: Expr<E>,
-        op: Pair<Rule>,
+        op: ParseInput,
         r: Expr<E>,
     ) -> ParseResult<Expr<E>> {
         use crate::BinOp::*;
@@ -844,42 +716,54 @@ impl Parsers {
             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(unspanned(BinOp(op, l, r)))
+        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;
+        Ok(match_nodes!(input.children();
             [expression(e)] => e,
             [expression(first), expression(rest)..] => {
-                rest.fold(first, |acc, e| unspanned(App(acc, e)))
+                rest.fold(
+                    first,
+                    |acc, e| {
+                        spanned_union(
+                            acc.span().unwrap(),
+                            e.span().unwrap(),
+                            App(acc, e)
+                        )
+                    }
+                )
             },
         ))
     }
 
     #[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;
+        Ok(match_nodes!(input.children();
             [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,
         ))
@@ -887,69 +771,75 @@ impl Parsers {
 
     #[alias(expression, shortcut = true)]
     fn selector_expression<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input;
+        Ok(match_nodes!(input.children();
             [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_union(
+                            acc.span().unwrap(),
+                            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>>> {
-        Ok(parse_children!(input;
-            [label(l)] => Either::Left(l),
-            [labels(ls)] => Either::Right(ls),
+        input: ParseInput,
+    ) -> ParseResult<(Either<Label, DupTreeSet<Label>>, Span)> {
+        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
         ))
     }
 
-    fn labels(input: ParseInput<Rule>) -> ParseResult<DupTreeSet<Label>> {
-        Ok(parse_children!(input;
+    fn labels(input: ParseInput) -> ParseResult<DupTreeSet<Label>> {
+        Ok(match_nodes!(input.into_children();
             [label(ls)..] => ls.collect(),
         ))
     }
 
     #[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)),
+        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)),
+            [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;
+        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);
@@ -961,13 +851,13 @@ 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;
+        Ok(match_nodes!(input.into_children();
             [expression(expr), record_type_entry(entries)..] => {
                 (expr, entries.collect())
             }
@@ -975,17 +865,17 @@ impl Parsers {
     }
 
     fn record_type_entry<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<(Label, Expr<E>)> {
-        Ok(parse_children!(input;
+        Ok(match_nodes!(input.into_children();
             [label(name), expression(expr)] => (name, expr)
         ))
     }
 
     fn non_empty_record_literal<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<(Expr<E>, DupTreeMap<Label, Expr<E>>)> {
-        Ok(parse_children!(input;
+        Ok(match_nodes!(input.into_children();
             [expression(expr), record_literal_entry(entries)..] => {
                 (expr, entries.collect())
             }
@@ -993,30 +883,30 @@ impl Parsers {
     }
 
     fn record_literal_entry<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<(Label, Expr<E>)> {
-        Ok(parse_children!(input;
+        Ok(match_nodes!(input.into_children();
             [label(name), expression(expr)] => (name, expr)
         ))
     }
 
     #[alias(expression)]
-    fn union_type<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
-        let map = parse_children!(input;
+    fn union_type<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
+        let map = match_nodes!(input.children();
             [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;
+        Ok(match_nodes!(input.children();
             [label(name), expression(expr)] => (name, Some(expr)),
             [label(name)] => (name, None),
         ))
@@ -1024,26 +914,32 @@ impl Parsers {
 
     #[alias(expression)]
     fn non_empty_list_literal<E: Clone>(
-        input: ParseInput<Rule>,
+        input: ParseInput,
     ) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input;
+        Ok(match_nodes!(input.children();
             [expression(items)..] => spanned(
-                input.as_span(),
+                input,
                 NEListLit(items.collect())
             )
         ))
     }
 
-    fn final_expression<E: Clone>(
-        input: ParseInput<Rule>,
-    ) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input;
+    #[alias(expression)]
+    fn final_expression<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> {
+        Ok(match_nodes!(input.into_children();
             [expression(e), EOI(_)] => e
         ))
     }
 }
 
-pub fn parse_expr<E: Clone>(s: &str) -> ParseResult<Expr<E>> {
-    let input = ParseInput::parse(s, Rule::final_expression)?;
-    Parsers::final_expression(input)
+pub fn parse_expr<E: Clone>(input_str: &str) -> ParseResult<Expr<E>> {
+    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_nodes!(<DhallParser>; inputs;
+        [expression(e)] => e,
+    ))
 }