From be51899f7d5f1f9ede689ca0a9707a0aca3d31c4 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 1 Sep 2019 13:51:12 +0200
Subject: Rewrite the make_parser macro as a proc_macro

---
 Cargo.lock                      |  42 ++++-
 dhall_proc_macros/Cargo.toml    |   6 +-
 dhall_proc_macros/src/lib.rs    |   9 +
 dhall_proc_macros/src/parser.rs | 398 ++++++++++++++++++++++++++++++++++++++++
 dhall_syntax/Cargo.toml         |   1 +
 dhall_syntax/src/parser.rs      | 209 +--------------------
 6 files changed, 456 insertions(+), 209 deletions(-)
 create mode 100644 dhall_proc_macros/src/parser.rs

diff --git a/Cargo.lock b/Cargo.lock
index 9bd7adc..360168a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -95,9 +95,9 @@ name = "dhall_proc_macros"
 version = "0.1.0"
 dependencies = [
  "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.31 (registry+https://github.com/rust-lang/crates.io-index)",
+ "proc-macro2 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -105,6 +105,7 @@ name = "dhall_syntax"
 version = "0.1.0"
 dependencies = [
  "dhall_generated_parser 0.1.0",
+ "dhall_proc_macros 0.1.0",
  "either 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "hex 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -269,6 +270,14 @@ dependencies = [
  "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "proc-macro2"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "unicode-xid 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "quote"
 version = "0.6.12"
@@ -277,6 +286,14 @@ dependencies = [
  "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "quote"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "same-file"
 version = "1.0.4"
@@ -344,6 +361,16 @@ dependencies = [
  "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "syn"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-xid 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "take_mut"
 version = "0.2.2"
@@ -386,6 +413,11 @@ name = "unicode-xid"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
+[[package]]
+name = "unicode-xid"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
 [[package]]
 name = "version_check"
 version = "0.1.5"
@@ -468,13 +500,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum pretty 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f60c0d9f6fc88ecdd245d90c1920ff76a430ab34303fc778d33b1d0a4c3bf6d3"
 "checksum pretty_assertions 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3f81e1644e1b54f5a68959a29aa86cde704219254669da328ecfdf6a1f09d427"
 "checksum proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4d317f9caece796be1980837fd5cb3dfec5613ebdb04ad0956deea83ce168915"
+"checksum proc-macro2 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "175a40b9cf564ce9bf050654633dbf339978706b8ead1a907bb970b63185dd95"
 "checksum quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faf4799c5d274f3868a4aae320a0a182cbd2baee377b378f080e16a23e9d80db"
+"checksum quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "053a8c8bcc71fcce321828dc897a98ab9760bef03a4fc36693c231e5b3216cfe"
 "checksum same-file 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "8f20c4be53a8a1ff4c1f1b2bd14570d2f634628709752f0702ecdd2b3f9a5267"
 "checksum serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "aa5f7c20820475babd2c077c3ab5f8c77a31c15e16ea38687b4c02d3e48680f4"
 "checksum serde_cbor 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "45cd6d95391b16cd57e88b68be41d504183b7faae22030c0cc3b3f73dd57b2fd"
 "checksum serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "58fc82bec244f168b23d1963b45c8bf5726e9a15a9d146a067f9081aeed2de79"
 "checksum sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "51b9d1f3b5de8a167ab06834a7c883bd197f2191e1dda1a22d9ccfeedbf9aded"
 "checksum syn 0.15.31 (registry+https://github.com/rust-lang/crates.io-index)" = "d2b4cfac95805274c6afdb12d8f770fa2d27c045953e7b630a81801953699a9a"
+"checksum syn 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "66850e97125af79138385e9b88339cbcd037e3f28ceab8c5ad98e64f0f1f80bf"
 "checksum take_mut 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f764005d11ee5f36500a149ace24e00e3da98b0158b3e2d53a7495660d3f4d60"
 "checksum term 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "fa63644f74ce96fbeb9b794f66aff2a52d601cbd5e80f4b97123e3899f4570f1"
 "checksum term-painter 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "dcaa948f0e3e38470cd8dc8dcfe561a75c9e43f28075bb183845be2b9b3c08cf"
@@ -482,6 +517,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum typenum 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "612d636f949607bdf9b123b4a6f6d966dedf3ff669f7f045890d3a4a73948169"
 "checksum ucd-trie 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "71a9c5b1fe77426cf144cc30e49e955270f5086e31a6441dfa8b32efc09b9d77"
 "checksum unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc"
+"checksum unicode-xid 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c"
 "checksum version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"
 "checksum walkdir 2.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "9d9d7ed3431229a144296213105a390676cc49c9b6a72bd19f3176c98e129fa1"
 "checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
diff --git a/dhall_proc_macros/Cargo.toml b/dhall_proc_macros/Cargo.toml
index df1eda8..b641a39 100644
--- a/dhall_proc_macros/Cargo.toml
+++ b/dhall_proc_macros/Cargo.toml
@@ -11,6 +11,6 @@ doctest = false
 
 [dependencies]
 itertools = "0.8.0"
-quote = "0.6.11"
-proc-macro2 = "0.4.27"
-syn = "0.15.29"
+quote = "1.0.2"
+proc-macro2 = "1.0.2"
+syn = { version = "1.0.5", features = ["full", "extra-traits"] }
diff --git a/dhall_proc_macros/src/lib.rs b/dhall_proc_macros/src/lib.rs
index 5304429..37c9985 100644
--- a/dhall_proc_macros/src/lib.rs
+++ b/dhall_proc_macros/src/lib.rs
@@ -6,6 +6,7 @@
 extern crate proc_macro;
 
 mod derive;
+mod parser;
 
 use proc_macro::TokenStream;
 
@@ -13,3 +14,11 @@ use proc_macro::TokenStream;
 pub fn derive_static_type(input: TokenStream) -> TokenStream {
     derive::derive_static_type(input)
 }
+
+#[proc_macro]
+pub fn make_parser(input: TokenStream) -> TokenStream {
+    TokenStream::from(match parser::make_parser(input) {
+        Ok(tokens) => tokens,
+        Err(err) => err.to_compile_error(),
+    })
+}
diff --git a/dhall_proc_macros/src/parser.rs b/dhall_proc_macros/src/parser.rs
new file mode 100644
index 0000000..bb4e894
--- /dev/null
+++ b/dhall_proc_macros/src/parser.rs
@@ -0,0 +1,398 @@
+use proc_macro2::{Span, TokenStream};
+use quote::quote;
+use syn::parse::{Parse, ParseStream, Result};
+use syn::punctuated::Punctuated;
+use syn::{bracketed, parenthesized, token, Expr, Ident, Pat, Token, Type};
+
+mod rule_kw {
+    syn::custom_keyword!(rule);
+    syn::custom_keyword!(captured_str);
+    syn::custom_keyword!(children);
+    syn::custom_keyword!(prec_climb);
+}
+
+#[derive(Debug, Clone)]
+struct Rules(Vec<Rule>);
+
+#[derive(Debug, Clone)]
+struct Rule {
+    rule_token: rule_kw::rule,
+    bang_token: Token![!],
+    paren_token: token::Paren,
+    name: Ident,
+    lt_token: token::Lt,
+    output_type: Type,
+    gt_token: token::Gt,
+    contents: RuleContents,
+    semi_token: Token![;],
+}
+
+#[derive(Debug, Clone)]
+enum RuleContents {
+    Empty,
+    CapturedString {
+        span: Option<Ident>,
+        captured_str_token: rule_kw::captured_str,
+        bang_token: Token![!],
+        paren_token: token::Paren,
+        pattern: Pat,
+        fat_arrow_token: Token![=>],
+        body: Expr,
+    },
+    Children {
+        span: Option<Ident>,
+        children_token: rule_kw::children,
+        bang_token: Token![!],
+        paren_token: token::Paren,
+        branches: Punctuated<ChildrenBranch, Token![,]>,
+    },
+    PrecClimb {
+        span: Option<Ident>,
+        prec_climb_token: rule_kw::prec_climb,
+        bang_token: Token![!],
+        paren_token: token::Paren,
+        child_rule: Ident,
+        comma_token: Token![,],
+        climber: Expr,
+        comma_token2: Token![,],
+        pattern: Pat,
+        fat_arrow_token: Token![=>],
+        body: Expr,
+    },
+}
+
+#[derive(Debug, Clone)]
+struct ChildrenBranch {
+    bracket_token: token::Bracket,
+    pattern_unparsed: TokenStream,
+    pattern: Punctuated<ChildrenBranchPatternItem, Token![,]>,
+    fat_arrow_token: Token![=>],
+    body: Expr,
+}
+
+#[derive(Debug, Clone)]
+enum ChildrenBranchPatternItem {
+    Single {
+        rule_name: Ident,
+        paren_token: token::Paren,
+        binder: Pat,
+    },
+    Multiple {
+        rule_name: Ident,
+        paren_token: token::Paren,
+        binder: Ident,
+        slice_token: Token![..],
+    },
+}
+
+impl Parse for Rules {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let mut rules = Vec::new();
+        while !input.is_empty() {
+            rules.push(input.parse()?)
+        }
+        Ok(Rules(rules))
+    }
+}
+
+impl Parse for Rule {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let contents;
+        Ok(Rule {
+            rule_token: input.parse()?,
+            bang_token: input.parse()?,
+            paren_token: parenthesized!(contents in input),
+            name: contents.parse()?,
+            lt_token: contents.parse()?,
+            output_type: contents.parse()?,
+            gt_token: contents.parse()?,
+            contents: contents.parse()?,
+            semi_token: input.parse()?,
+        })
+    }
+}
+
+impl Parse for RuleContents {
+    fn parse(input: ParseStream) -> Result<Self> {
+        if input.is_empty() {
+            return Ok(RuleContents::Empty);
+        }
+        let _: Token![;] = input.parse()?;
+        let span = if input.peek(Ident) && input.peek2(Token![;]) {
+            let span: Ident = input.parse()?;
+            let _: Token![;] = input.parse()?;
+            Some(span)
+        } else {
+            None
+        };
+
+        let lookahead = input.lookahead1();
+        if lookahead.peek(rule_kw::captured_str) {
+            let contents;
+            Ok(RuleContents::CapturedString {
+                span,
+                captured_str_token: input.parse()?,
+                bang_token: input.parse()?,
+                paren_token: parenthesized!(contents in input),
+                pattern: contents.parse()?,
+                fat_arrow_token: input.parse()?,
+                body: input.parse()?,
+            })
+        } else if lookahead.peek(rule_kw::children) {
+            let contents;
+            Ok(RuleContents::Children {
+                span,
+                children_token: input.parse()?,
+                bang_token: input.parse()?,
+                paren_token: parenthesized!(contents in input),
+                branches: Punctuated::parse_terminated(&contents)?,
+            })
+        } else if lookahead.peek(rule_kw::prec_climb) {
+            let contents;
+            Ok(RuleContents::PrecClimb {
+                span,
+                prec_climb_token: input.parse()?,
+                bang_token: input.parse()?,
+                paren_token: parenthesized!(contents in input),
+                child_rule: contents.parse()?,
+                comma_token: contents.parse()?,
+                climber: contents.parse()?,
+                comma_token2: contents.parse()?,
+                pattern: contents.parse()?,
+                fat_arrow_token: contents.parse()?,
+                body: contents.parse()?,
+            })
+        } else {
+            Err(lookahead.error())
+        }
+    }
+}
+
+impl Parse for ChildrenBranch {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let contents;
+        Ok(ChildrenBranch {
+            bracket_token: bracketed!(contents in input),
+            pattern_unparsed: contents.fork().parse()?,
+            pattern: Punctuated::parse_terminated(&contents)?,
+            fat_arrow_token: input.parse()?,
+            body: input.parse()?,
+        })
+    }
+}
+
+impl Parse for ChildrenBranchPatternItem {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let rule_name = input.parse()?;
+        let contents;
+        let paren_token = parenthesized!(contents in input);
+        if input.peek(Token![..]) {
+            Ok(ChildrenBranchPatternItem::Multiple {
+                rule_name,
+                paren_token,
+                binder: contents.parse()?,
+                slice_token: input.parse()?,
+            })
+        } else if input.is_empty() || input.peek(Token![,]) {
+            Ok(ChildrenBranchPatternItem::Single {
+                rule_name,
+                paren_token,
+                binder: contents.parse()?,
+            })
+        } else {
+            Err(input.error("expected `..` or nothing"))
+        }
+    }
+}
+
+fn make_construct_precclimbers(rules: &Rules) -> Result<TokenStream> {
+    let mut entries: Vec<TokenStream> = Vec::new();
+    for rule in &rules.0 {
+        if let RuleContents::PrecClimb { climber, .. } = &rule.contents {
+            let name = &rule.name;
+            entries.push(quote!(
+                map.insert(Rule::#name, #climber);
+            ))
+        }
+    }
+
+    Ok(quote!(
+        fn construct_precclimbers() -> HashMap<Rule, PrecClimber<Rule>> {
+            let mut map = HashMap::new();
+            #(#entries)*
+            map
+        }
+    ))
+}
+
+fn make_entrypoints(rules: &Rules) -> Result<TokenStream> {
+    let mut entries: Vec<TokenStream> = Vec::new();
+    for rule in &rules.0 {
+        let name = &rule.name;
+        let output_type = &rule.output_type;
+        entries.push(quote!(
+            #[allow(non_snake_case, dead_code)]
+            fn #name<'a>(
+                input: Rc<str>,
+                pair: Pair<'a, Rule>,
+            ) -> ParseResult<#output_type> {
+                let climbers = construct_precclimbers();
+                Parsers::#name((&climbers, input), pair)
+            }
+        ))
+    }
+
+    Ok(quote!(
+        struct EntryPoint;
+        impl EntryPoint {
+            #(#entries)*
+        }
+    ))
+}
+
+fn make_parser_branch(branch: &ChildrenBranch) -> TokenStream {
+    let ChildrenBranch {
+        pattern,
+        body,
+        pattern_unparsed,
+        ..
+    } = branch;
+    let variable_pattern = Ident::new("variable_pattern", Span::call_site());
+    let match_pat = pattern.iter().map(|item| match item {
+        ChildrenBranchPatternItem::Single { rule_name, .. } => {
+            quote!(Rule::#rule_name)
+        }
+        ChildrenBranchPatternItem::Multiple { .. } => {
+            quote!(#variable_pattern..)
+        }
+    });
+    let match_filter = pattern.iter().map(|item| match item {
+        ChildrenBranchPatternItem::Single { .. } => quote!(true &&),
+        ChildrenBranchPatternItem::Multiple { rule_name, .. } => {
+            quote!(#variable_pattern.iter().all(|r| r == &Rule::#rule_name) &&)
+        }
+    });
+    quote!(
+        [#(#match_pat),*] if #(#match_filter)* true => {
+            parse_children!((climbers, input.clone()), iter;
+                [#pattern_unparsed] => {
+                    #[allow(unused_variables)]
+                    let res: Result<_, String> = try { #body };
+                    res.map_err(|msg|
+                        custom_parse_error(&pair, msg)
+                    )
+                }
+            )
+        }
+    )
+}
+
+fn make_parser_expr(rule: &Rule) -> Result<TokenStream> {
+    let name = &rule.name;
+    let expr = match &rule.contents {
+        RuleContents::Empty => quote!(Ok(())),
+        RuleContents::CapturedString { pattern, body, .. } => quote!(
+            let #pattern = pair.as_str();
+            let res: Result<_, String> = try { #body };
+            res.map_err(|msg| custom_parse_error(&pair, msg))
+        ),
+        RuleContents::PrecClimb {
+            child_rule,
+            pattern,
+            body,
+            ..
+        } => quote!(
+            let climber = climbers.get(&Rule::#name).unwrap();
+            climber.climb(
+                pair.clone().into_inner(),
+                |p| Parsers::#child_rule((climbers, input.clone()), p),
+                |l, op, r| {
+                    let #pattern = (l?, op, r?);
+                    let res: Result<_, String> = try { #body };
+                    res.map_err(|msg| custom_parse_error(&pair, msg))
+                },
+            )
+        ),
+        RuleContents::Children { branches, .. } => {
+            let branches = branches.iter().map(make_parser_branch);
+            quote!(
+                let children_rules: Vec<Rule> = pair
+                    .clone()
+                    .into_inner()
+                    .map(|p| p.as_rule())
+                    .collect();
+
+                #[allow(unused_mut)]
+                let mut iter = pair.clone().into_inner();
+
+                #[allow(unreachable_code)]
+                match children_rules.as_slice() {
+                    #(#branches,)*
+                    [..] => Err(custom_parse_error(
+                        &pair,
+                        format!("Unexpected children: {:?}", children_rules)
+                    )),
+                }
+            )
+        }
+    };
+    Ok(expr)
+}
+
+fn make_parsers(rules: &Rules) -> Result<TokenStream> {
+    let mut entries: Vec<TokenStream> = Vec::new();
+    for rule in &rules.0 {
+        let span_def = match &rule.contents {
+            RuleContents::CapturedString {
+                span: Some(span), ..
+            }
+            | RuleContents::Children {
+                span: Some(span), ..
+            }
+            | RuleContents::PrecClimb {
+                span: Some(span), ..
+            } => Some(quote!(
+                let #span = Span::make(input.clone(), pair.as_span());
+            )),
+            _ => None,
+        };
+
+        let name = &rule.name;
+        let output_type = &rule.output_type;
+        let expr = make_parser_expr(rule)?;
+
+        entries.push(quote!(
+            #[allow(non_snake_case, dead_code)]
+            fn #name<'a>(
+                (climbers, input): (&HashMap<Rule, PrecClimber<Rule>>, Rc<str>),
+                pair: Pair<'a, Rule>,
+            ) -> ParseResult<#output_type> {
+                #span_def
+                #expr
+            }
+        ))
+    }
+
+    Ok(quote!(
+        struct Parsers;
+        impl Parsers {
+            #(#entries)*
+        }
+    ))
+}
+
+pub fn make_parser(
+    input: proc_macro::TokenStream,
+) -> Result<proc_macro2::TokenStream> {
+    let rules: Rules = syn::parse_macro_input::parse(input.clone())?;
+
+    let construct_precclimbers = make_construct_precclimbers(&rules)?;
+    let entrypoints = make_entrypoints(&rules)?;
+    let parsers = make_parsers(&rules)?;
+
+    Ok(quote!(
+        #construct_precclimbers
+        #entrypoints
+        #parsers
+    ))
+}
diff --git a/dhall_syntax/Cargo.toml b/dhall_syntax/Cargo.toml
index 1da10c7..62ecced 100644
--- a/dhall_syntax/Cargo.toml
+++ b/dhall_syntax/Cargo.toml
@@ -16,3 +16,4 @@ either = "1.5.2"
 take_mut = "0.2.2"
 hex = "0.3.2"
 dhall_generated_parser = { path = "../dhall_generated_parser" }
+dhall_proc_macros = { path = "../dhall_proc_macros" }
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 53fd68a..4fd6f57 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -189,203 +189,6 @@ macro_rules! parse_children {
     };
 }
 
-macro_rules! make_parser {
-    (@children_pattern,
-        $varpat:ident,
-        ($($acc:tt)*),
-        [$variant:ident ($x:pat), $($rest:tt)*]
-    ) => (
-        make_parser!(@children_pattern,
-            $varpat,
-            ($($acc)* , Rule::$variant),
-            [$($rest)*]
-        )
-    );
-    (@children_pattern,
-        $varpat:ident,
-        ($($acc:tt)*),
-        [$variant:ident ($x:ident).., $($rest:tt)*]
-    ) => (
-        make_parser!(@children_pattern,
-            $varpat,
-            ($($acc)* , $varpat..),
-            [$($rest)*]
-        )
-    );
-    (@children_pattern,
-        $varpat:ident,
-        (, $($acc:tt)*), [$(,)*]
-    ) => ([$($acc)*]);
-    (@children_pattern,
-        $varpat:ident,
-        ($($acc:tt)*), [$(,)*]
-    ) => ([$($acc)*]);
-
-    (@children_filter,
-        $varpat:ident,
-        [$variant:ident ($x:pat), $($rest:tt)*]
-    ) => (
-        make_parser!(@children_filter, $varpat, [$($rest)*])
-    );
-    (@children_filter,
-        $varpat:ident,
-        [$variant:ident ($x:ident).., $($rest:tt)*]
-    ) => (
-        $varpat.iter().all(|r| r == &Rule::$variant) &&
-        make_parser!(@children_filter, $varpat, [$($rest)*])
-    );
-    (@children_filter, $varpat:ident, [$(,)*]) => (true);
-
-    (@body,
-        ($climbers:expr, $input:expr, $pair:expr),
-        rule!(
-            $name:ident<$o:ty>;
-            $span:ident;
-            captured_str!($x:pat) => $body:expr
-        )
-    ) => ({
-        let $span = Span::make($input.clone(), $pair.as_span());
-        let $x = $pair.as_str();
-        let res: Result<_, String> = try { $body };
-        res.map_err(|msg| custom_parse_error(&$pair, msg))
-    });
-    (@body,
-        ($climbers:expr, $input:expr, $pair:expr),
-        rule!(
-            $name:ident<$o:ty>;
-            $span:ident;
-            children!( $( [$($args:tt)*] => $body:expr ),* $(,)* )
-        )
-    ) => ({
-        let children_rules: Vec<Rule> = $pair
-            .clone()
-            .into_inner()
-            .map(|p| p.as_rule())
-            .collect();
-
-        let $span = Span::make($input.clone(), $pair.as_span());
-        #[allow(unused_mut)]
-        let mut iter = $pair.clone().into_inner();
-
-        #[allow(unreachable_code)]
-        match children_rules.as_slice() {
-            $(
-                make_parser!(@children_pattern, x, (), [$($args)*,])
-                if make_parser!(@children_filter, x, [$($args)*,])
-                => {
-                    parse_children!(($climbers, $input.clone()), iter;
-                        [$($args)*] => {
-                            let res: Result<_, String> = try { $body };
-                            res.map_err(|msg| custom_parse_error(&$pair, msg))
-                        }
-                    )
-                }
-                ,
-            )*
-            [..] => Err(custom_parse_error(
-                &$pair,
-                format!("Unexpected children: {:?}", children_rules)
-            )),
-        }
-    });
-    (@body,
-        ($climbers:expr, $input:expr, $pair:expr),
-        rule!(
-            $name:ident<$o:ty>;
-            prec_climb!(
-                $other_rule:ident,
-                $_climber:expr,
-                $args:pat => $body:expr $(,)*
-            )
-        )
-    ) => ({
-        let climber = $climbers.get(&Rule::$name).unwrap();
-        climber.climb(
-            $pair.clone().into_inner(),
-            |p| Parsers::$other_rule(($climbers, $input.clone()), p),
-            |l, op, r| {
-                let $args = (l?, op, r?);
-                let res: Result<_, String> = try { $body };
-                res.map_err(|msg| custom_parse_error(&$pair, msg))
-            },
-        )
-    });
-    (@body,
-        ($($things:tt)*),
-        rule!(
-            $name:ident<$o:ty>;
-            $($args:tt)*
-        )
-    ) => ({
-        make_parser!(@body,
-            ($($things)*),
-            rule!(
-                $name<$o>;
-                _span;
-                $($args)*
-            )
-        )
-    });
-    (@body,
-        ($($things:tt)*),
-        rule!($name:ident<$o:ty>)
-    ) => ({
-        Ok(())
-    });
-
-    (@construct_climber,
-        ($map:expr),
-        rule!(
-            $name:ident<$o:ty>;
-            prec_climb!($other_rule:ident, $climber:expr, $($_rest:tt)* )
-        )
-    ) => ({
-        $map.insert(Rule::$name, $climber)
-    });
-    (@construct_climber, ($($things:tt)*), $($args:tt)*) => (());
-
-    ($( $submac:ident!( $name:ident<$o:ty> $($args:tt)* ); )*) => (
-        struct Parsers;
-
-        impl Parsers {
-            $(
-            #[allow(non_snake_case, unused_variables, clippy::let_unit_value)]
-            fn $name<'a>(
-                (climbers, input): (&HashMap<Rule, PrecClimber<Rule>>, Rc<str>),
-                pair: Pair<'a, Rule>,
-            ) -> ParseResult<$o> {
-                make_parser!(@body, (climbers, input, pair),
-                               $submac!( $name<$o> $($args)* ))
-            }
-            )*
-        }
-
-        fn construct_precclimbers() -> HashMap<Rule, PrecClimber<Rule>> {
-            let mut map = HashMap::new();
-            $(
-                make_parser!(@construct_climber, (map),
-                        $submac!( $name<$o> $($args)* ));
-            )*
-            map
-        }
-
-        struct EntryPoint;
-
-        impl EntryPoint {
-            $(
-            #[allow(non_snake_case, dead_code)]
-            fn $name<'a>(
-                input: Rc<str>,
-                pair: Pair<'a, Rule>,
-            ) -> ParseResult<$o> {
-                let climbers = construct_precclimbers();
-                Parsers::$name((&climbers, input), pair)
-            }
-            )*
-        }
-    );
-}
-
 // Trim the shared indent off of a vec of lines, as defined by the Dhall semantics of multiline
 // literals.
 fn trim_indent(lines: &mut Vec<ParsedText>) {
@@ -427,7 +230,7 @@ fn trim_indent(lines: &mut Vec<ParsedText>) {
     }
 }
 
-make_parser! {
+dhall_proc_macros::make_parser! {
     rule!(EOI<()>);
 
     rule!(simple_label<Label>;
@@ -629,9 +432,9 @@ make_parser! {
 
     rule!(double_literal<core::Double>; children!(
         [numeric_double_literal(n)] => n,
-        [minus_infinity_literal(n)] => std::f64::NEG_INFINITY.into(),
-        [plus_infinity_literal(n)] => std::f64::INFINITY.into(),
-        [NaN(n)] => std::f64::NAN.into(),
+        [minus_infinity_literal(_)] => std::f64::NEG_INFINITY.into(),
+        [plus_infinity_literal(_)] => std::f64::INFINITY.into(),
+        [NaN(_)] => std::f64::NAN.into(),
     ));
 
     rule!(natural_literal<core::Natural>;
@@ -977,7 +780,7 @@ make_parser! {
         [import_expression(e)] => e,
     ));
 
-    rule!(import_expression<ParsedExpr>; span;
+    rule!(import_expression<ParsedExpr>;
             children!(
         [selector_expression(e)] => e,
         [import(e)] => e,
@@ -996,7 +799,7 @@ make_parser! {
     rule!(selector<Either<Label, DupTreeSet<Label>>>; children!(
         [label(l)] => Either::Left(l),
         [labels(ls)] => Either::Right(ls),
-        [expression(e)] => unimplemented!("selection by expression"), // TODO
+        [expression(_e)] => unimplemented!("selection by expression"), // TODO
     ));
 
     rule!(labels<DupTreeSet<Label>>; children!(
-- 
cgit v1.2.3


From 1baef509afe52ab285e73469fc597de8f4e166b6 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 1 Sep 2019 18:38:39 +0200
Subject: Change parser macros to use a function-like syntax

This makes the parser code look much less magical.
---
 Cargo.lock                      |    7 +
 dhall_proc_macros/src/lib.rs    |    8 +
 dhall_proc_macros/src/parser.rs |  494 ++++++------
 dhall_syntax/Cargo.toml         |    1 +
 dhall_syntax/src/lib.rs         |    1 +
 dhall_syntax/src/parser.rs      | 1675 ++++++++++++++++++++++-----------------
 6 files changed, 1188 insertions(+), 998 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 360168a..976b3c5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -109,6 +109,7 @@ dependencies = [
  "either 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "hex 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "percent-encoding 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "pest 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "take_mut 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -181,6 +182,11 @@ dependencies = [
  "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
 [[package]]
 name = "maplit"
 version = "1.0.1"
@@ -489,6 +495,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum indexmap 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7e81a7c05f79578dbc15793d8b619db9ba32b4577003ef3af1a91c416798c58d"
 "checksum itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5b8467d9c1cebe26feb08c640139247fac215782d35371ade9a2136ed6085358"
 "checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
+"checksum lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 "checksum maplit 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "08cbb6b4fef96b6d77bfc40ec491b1690c779e77b05cd9f07f787ed376fd4c43"
 "checksum memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2efc7bc57c883d4a4d6e3246905283d8dae951bb3bd32f49d6ef297f546e1c39"
 "checksum nom 4.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2ad2a91a8e869eeb30b9cb3119ae87773a8f4ae617f41b1eb9c154b2905f7bd6"
diff --git a/dhall_proc_macros/src/lib.rs b/dhall_proc_macros/src/lib.rs
index 37c9985..46d93e9 100644
--- a/dhall_proc_macros/src/lib.rs
+++ b/dhall_proc_macros/src/lib.rs
@@ -22,3 +22,11 @@ pub fn make_parser(input: TokenStream) -> TokenStream {
         Err(err) => err.to_compile_error(),
     })
 }
+
+#[proc_macro]
+pub fn parse_children(input: TokenStream) -> TokenStream {
+    TokenStream::from(match parser::parse_children(input) {
+        Ok(tokens) => tokens,
+        Err(err) => err.to_compile_error(),
+    })
+}
diff --git a/dhall_proc_macros/src/parser.rs b/dhall_proc_macros/src/parser.rs
index bb4e894..2618bec 100644
--- a/dhall_proc_macros/src/parser.rs
+++ b/dhall_proc_macros/src/parser.rs
@@ -2,7 +2,11 @@ use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::parse::{Parse, ParseStream, Result};
 use syn::punctuated::Punctuated;
-use syn::{bracketed, parenthesized, token, Expr, Ident, Pat, Token, Type};
+use syn::spanned::Spanned;
+use syn::{
+    bracketed, parenthesized, parse_quote, token, Error, Expr, Ident, ItemFn,
+    Pat, ReturnType, Token, Type,
+};
 
 mod rule_kw {
     syn::custom_keyword!(rule);
@@ -16,73 +20,40 @@ struct Rules(Vec<Rule>);
 
 #[derive(Debug, Clone)]
 struct Rule {
-    rule_token: rule_kw::rule,
-    bang_token: Token![!],
-    paren_token: token::Paren,
     name: Ident,
-    lt_token: token::Lt,
     output_type: Type,
-    gt_token: token::Gt,
     contents: RuleContents,
-    semi_token: Token![;],
 }
 
 #[derive(Debug, Clone)]
 enum RuleContents {
-    Empty,
-    CapturedString {
-        span: Option<Ident>,
-        captured_str_token: rule_kw::captured_str,
-        bang_token: Token![!],
-        paren_token: token::Paren,
-        pattern: Pat,
-        fat_arrow_token: Token![=>],
-        body: Expr,
-    },
-    Children {
-        span: Option<Ident>,
-        children_token: rule_kw::children,
-        bang_token: Token![!],
-        paren_token: token::Paren,
-        branches: Punctuated<ChildrenBranch, Token![,]>,
-    },
     PrecClimb {
-        span: Option<Ident>,
-        prec_climb_token: rule_kw::prec_climb,
-        bang_token: Token![!],
-        paren_token: token::Paren,
         child_rule: Ident,
-        comma_token: Token![,],
         climber: Expr,
-        comma_token2: Token![,],
-        pattern: Pat,
-        fat_arrow_token: Token![=>],
-        body: Expr,
+        function: ItemFn,
+    },
+    Function {
+        function: ItemFn,
     },
 }
 
 #[derive(Debug, Clone)]
 struct ChildrenBranch {
-    bracket_token: token::Bracket,
-    pattern_unparsed: TokenStream,
+    pattern_span: Span,
     pattern: Punctuated<ChildrenBranchPatternItem, Token![,]>,
-    fat_arrow_token: Token![=>],
     body: Expr,
 }
 
 #[derive(Debug, Clone)]
 enum ChildrenBranchPatternItem {
-    Single {
-        rule_name: Ident,
-        paren_token: token::Paren,
-        binder: Pat,
-    },
-    Multiple {
-        rule_name: Ident,
-        paren_token: token::Paren,
-        binder: Ident,
-        slice_token: Token![..],
-    },
+    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 Rules {
@@ -97,73 +68,50 @@ impl Parse for Rules {
 
 impl Parse for Rule {
     fn parse(input: ParseStream) -> Result<Self> {
-        let contents;
-        Ok(Rule {
-            rule_token: input.parse()?,
-            bang_token: input.parse()?,
-            paren_token: parenthesized!(contents in input),
-            name: contents.parse()?,
-            lt_token: contents.parse()?,
-            output_type: contents.parse()?,
-            gt_token: contents.parse()?,
-            contents: contents.parse()?,
-            semi_token: input.parse()?,
-        })
-    }
-}
+        let function: ItemFn = input.parse()?;
+        let (recognized_attrs, remaining_attrs) = function
+            .attrs
+            .iter()
+            .cloned()
+            .partition::<Vec<_>, _>(|attr| attr.path.is_ident("prec_climb"));
+        let function = ItemFn {
+            attrs: remaining_attrs,
+            ..(function.clone())
+        };
 
-impl Parse for RuleContents {
-    fn parse(input: ParseStream) -> Result<Self> {
-        if input.is_empty() {
-            return Ok(RuleContents::Empty);
-        }
-        let _: Token![;] = input.parse()?;
-        let span = if input.peek(Ident) && input.peek2(Token![;]) {
-            let span: Ident = input.parse()?;
-            let _: Token![;] = input.parse()?;
-            Some(span)
-        } else {
-            None
+        let name = function.sig.ident.clone();
+        let output_type = match &function.sig.output {
+            ReturnType::Default => parse_quote!(()),
+            ReturnType::Type(_, t) => (**t).clone(),
         };
 
-        let lookahead = input.lookahead1();
-        if lookahead.peek(rule_kw::captured_str) {
-            let contents;
-            Ok(RuleContents::CapturedString {
-                span,
-                captured_str_token: input.parse()?,
-                bang_token: input.parse()?,
-                paren_token: parenthesized!(contents in input),
-                pattern: contents.parse()?,
-                fat_arrow_token: input.parse()?,
-                body: input.parse()?,
-            })
-        } else if lookahead.peek(rule_kw::children) {
-            let contents;
-            Ok(RuleContents::Children {
-                span,
-                children_token: input.parse()?,
-                bang_token: input.parse()?,
-                paren_token: parenthesized!(contents in input),
-                branches: Punctuated::parse_terminated(&contents)?,
-            })
-        } else if lookahead.peek(rule_kw::prec_climb) {
-            let contents;
-            Ok(RuleContents::PrecClimb {
-                span,
-                prec_climb_token: input.parse()?,
-                bang_token: input.parse()?,
-                paren_token: parenthesized!(contents in input),
-                child_rule: contents.parse()?,
-                comma_token: contents.parse()?,
-                climber: contents.parse()?,
-                comma_token2: contents.parse()?,
-                pattern: contents.parse()?,
-                fat_arrow_token: contents.parse()?,
-                body: contents.parse()?,
+        if recognized_attrs.is_empty() {
+            Ok(Rule {
+                name,
+                output_type,
+                contents: RuleContents::Function { function },
             })
+        } else if recognized_attrs.len() != 1 {
+            Err(input.error("expected a prec_climb attribute"))
         } else {
-            Err(lookahead.error())
+            let attr = recognized_attrs.into_iter().next().unwrap();
+            let (child_rule, climber) =
+                attr.parse_args_with(|input: ParseStream| {
+                    let child_rule: Ident = input.parse()?;
+                    let _: Token![,] = input.parse()?;
+                    let climber: Expr = input.parse()?;
+                    Ok((child_rule, climber))
+                })?;
+
+            Ok(Rule {
+                name,
+                output_type,
+                contents: RuleContents::PrecClimb {
+                    child_rule,
+                    climber,
+                    function,
+                },
+            })
         }
     }
 }
@@ -171,40 +119,52 @@ impl Parse for RuleContents {
 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 {
-            bracket_token: bracketed!(contents in input),
-            pattern_unparsed: contents.fork().parse()?,
-            pattern: Punctuated::parse_terminated(&contents)?,
-            fat_arrow_token: input.parse()?,
-            body: input.parse()?,
+            pattern_span,
+            pattern,
+            body,
         })
     }
 }
 
 impl Parse for ChildrenBranchPatternItem {
     fn parse(input: ParseStream) -> Result<Self> {
-        let rule_name = input.parse()?;
         let contents;
-        let paren_token = parenthesized!(contents in input);
+        let rule_name = input.parse()?;
+        parenthesized!(contents in input);
         if input.peek(Token![..]) {
-            Ok(ChildrenBranchPatternItem::Multiple {
-                rule_name,
-                paren_token,
-                binder: contents.parse()?,
-                slice_token: input.parse()?,
-            })
+            let binder = contents.parse()?;
+            let _: Token![..] = input.parse()?;
+            Ok(ChildrenBranchPatternItem::Multiple { rule_name, binder })
         } else if input.is_empty() || input.peek(Token![,]) {
-            Ok(ChildrenBranchPatternItem::Single {
-                rule_name,
-                paren_token,
-                binder: contents.parse()?,
-            })
+            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_construct_precclimbers(rules: &Rules) -> Result<TokenStream> {
     let mut entries: Vec<TokenStream> = Vec::new();
     for rule in &rules.0 {
@@ -233,11 +193,16 @@ fn make_entrypoints(rules: &Rules) -> Result<TokenStream> {
         entries.push(quote!(
             #[allow(non_snake_case, dead_code)]
             fn #name<'a>(
-                input: Rc<str>,
+                input_str: &str,
                 pair: Pair<'a, Rule>,
-            ) -> ParseResult<#output_type> {
+            ) -> #output_type {
                 let climbers = construct_precclimbers();
-                Parsers::#name((&climbers, input), pair)
+                let input = ParseInput {
+                    climbers: &climbers,
+                    original_input_str: input_str.to_string().into(),
+                    pair
+                };
+                Parsers::#name(input)
             }
         ))
     }
@@ -250,128 +215,37 @@ fn make_entrypoints(rules: &Rules) -> Result<TokenStream> {
     ))
 }
 
-fn make_parser_branch(branch: &ChildrenBranch) -> TokenStream {
-    let ChildrenBranch {
-        pattern,
-        body,
-        pattern_unparsed,
-        ..
-    } = branch;
-    let variable_pattern = Ident::new("variable_pattern", Span::call_site());
-    let match_pat = pattern.iter().map(|item| match item {
-        ChildrenBranchPatternItem::Single { rule_name, .. } => {
-            quote!(Rule::#rule_name)
-        }
-        ChildrenBranchPatternItem::Multiple { .. } => {
-            quote!(#variable_pattern..)
-        }
-    });
-    let match_filter = pattern.iter().map(|item| match item {
-        ChildrenBranchPatternItem::Single { .. } => quote!(true &&),
-        ChildrenBranchPatternItem::Multiple { rule_name, .. } => {
-            quote!(#variable_pattern.iter().all(|r| r == &Rule::#rule_name) &&)
-        }
-    });
-    quote!(
-        [#(#match_pat),*] if #(#match_filter)* true => {
-            parse_children!((climbers, input.clone()), iter;
-                [#pattern_unparsed] => {
-                    #[allow(unused_variables)]
-                    let res: Result<_, String> = try { #body };
-                    res.map_err(|msg|
-                        custom_parse_error(&pair, msg)
-                    )
-                }
-            )
-        }
-    )
-}
-
-fn make_parser_expr(rule: &Rule) -> Result<TokenStream> {
-    let name = &rule.name;
-    let expr = match &rule.contents {
-        RuleContents::Empty => quote!(Ok(())),
-        RuleContents::CapturedString { pattern, body, .. } => quote!(
-            let #pattern = pair.as_str();
-            let res: Result<_, String> = try { #body };
-            res.map_err(|msg| custom_parse_error(&pair, msg))
-        ),
-        RuleContents::PrecClimb {
-            child_rule,
-            pattern,
-            body,
-            ..
-        } => quote!(
-            let climber = climbers.get(&Rule::#name).unwrap();
-            climber.climb(
-                pair.clone().into_inner(),
-                |p| Parsers::#child_rule((climbers, input.clone()), p),
-                |l, op, r| {
-                    let #pattern = (l?, op, r?);
-                    let res: Result<_, String> = try { #body };
-                    res.map_err(|msg| custom_parse_error(&pair, msg))
-                },
-            )
-        ),
-        RuleContents::Children { branches, .. } => {
-            let branches = branches.iter().map(make_parser_branch);
-            quote!(
-                let children_rules: Vec<Rule> = pair
-                    .clone()
-                    .into_inner()
-                    .map(|p| p.as_rule())
-                    .collect();
-
-                #[allow(unused_mut)]
-                let mut iter = pair.clone().into_inner();
-
-                #[allow(unreachable_code)]
-                match children_rules.as_slice() {
-                    #(#branches,)*
-                    [..] => Err(custom_parse_error(
-                        &pair,
-                        format!("Unexpected children: {:?}", children_rules)
-                    )),
-                }
-            )
-        }
-    };
-    Ok(expr)
-}
-
 fn make_parsers(rules: &Rules) -> Result<TokenStream> {
-    let mut entries: Vec<TokenStream> = Vec::new();
-    for rule in &rules.0 {
-        let span_def = match &rule.contents {
-            RuleContents::CapturedString {
-                span: Some(span), ..
-            }
-            | RuleContents::Children {
-                span: Some(span), ..
-            }
-            | RuleContents::PrecClimb {
-                span: Some(span), ..
-            } => Some(quote!(
-                let #span = Span::make(input.clone(), pair.as_span());
-            )),
-            _ => None,
-        };
-
+    let entries = rules.0.iter().map(|rule| {
         let name = &rule.name;
         let output_type = &rule.output_type;
-        let expr = make_parser_expr(rule)?;
-
-        entries.push(quote!(
-            #[allow(non_snake_case, dead_code)]
-            fn #name<'a>(
-                (climbers, input): (&HashMap<Rule, PrecClimber<Rule>>, Rc<str>),
-                pair: Pair<'a, Rule>,
-            ) -> ParseResult<#output_type> {
-                #span_def
-                #expr
-            }
-        ))
-    }
+        match &rule.contents {
+            RuleContents::PrecClimb {
+                child_rule,
+                function,
+                ..
+            } => quote!(
+                #[allow(non_snake_case, dead_code)]
+                fn #name<'a, 'climbers>(
+                    input: ParseInput<'a, 'climbers, Rule>,
+                ) -> #output_type {
+                    #function
+                    let climber = input.climbers.get(&Rule::#name).unwrap();
+                    climber.climb(
+                        input.pair.clone().into_inner(),
+                        |p| Parsers::#child_rule(input.with_pair(p)),
+                        |l, op, r| {
+                            #name(input.clone(), l?, op, r?)
+                        },
+                    )
+                }
+            ),
+            RuleContents::Function { function } => quote!(
+                #[allow(non_snake_case, dead_code)]
+                #function
+            ),
+        }
+    });
 
     Ok(quote!(
         struct Parsers;
@@ -384,7 +258,7 @@ fn make_parsers(rules: &Rules) -> Result<TokenStream> {
 pub fn make_parser(
     input: proc_macro::TokenStream,
 ) -> Result<proc_macro2::TokenStream> {
-    let rules: Rules = syn::parse_macro_input::parse(input.clone())?;
+    let rules: Rules = syn::parse(input.clone())?;
 
     let construct_precclimbers = make_construct_precclimbers(&rules)?;
     let entrypoints = make_entrypoints(&rules)?;
@@ -396,3 +270,123 @@ pub fn make_parser(
         #parsers
     ))
 }
+
+fn make_parser_branch(branch: &ChildrenBranch) -> 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 that they all match the chosen Rule in the `if`-condition.
+    let variable_pattern_ident =
+        Ident::new("variable_pattern", Span::call_site());
+    let match_pat = branch.pattern.iter().map(|item| match item {
+        Single { rule_name, .. } => quote!(Rule::#rule_name),
+        Multiple { .. } => quote!(#variable_pattern_ident..),
+    });
+    let match_filter = branch.pattern.iter().map(|item| match item {
+        Single { .. } => quote!(),
+        Multiple { rule_name, .. } => quote!(
+            #variable_pattern_ident.iter().all(|r| r == &Rule::#rule_name) &&
+        ),
+    });
+
+    // 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 = Parsers::#rule_name(
+                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 = Parsers::#rule_name(
+                inputs.next_back().unwrap()
+            )?;
+        ))
+    }
+    if let Some((rule_name, binder)) = multiple {
+        parses.push(quote!(
+            let #binder = inputs
+                .map(|i| Parsers::#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 input_expr = &input.input_expr;
+    let branches = input
+        .branches
+        .iter()
+        .map(make_parser_branch)
+        .collect::<Result<Vec<_>>>()?;
+    Ok(quote!({
+        let children_rules: Vec<Rule> = #input_expr.pair
+            .clone()
+            .into_inner()
+            .map(|p| p.as_rule())
+            .collect();
+
+        #[allow(unused_mut)]
+        let mut inputs = #input_expr
+            .pair
+            .clone()
+            .into_inner()
+            .map(|p| #input_expr.with_pair(p));
+
+        #[allow(unreachable_code)]
+        match children_rules.as_slice() {
+            #(#branches,)*
+            [..] => return Err(#input_expr.error(
+                format!("Unexpected children: {:?}", children_rules)
+            )),
+        }
+    }))
+}
diff --git a/dhall_syntax/Cargo.toml b/dhall_syntax/Cargo.toml
index 62ecced..eb492d0 100644
--- a/dhall_syntax/Cargo.toml
+++ b/dhall_syntax/Cargo.toml
@@ -15,5 +15,6 @@ pest = "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" }
diff --git a/dhall_syntax/src/lib.rs b/dhall_syntax/src/lib.rs
index e4a6077..290f53c 100644
--- a/dhall_syntax/src/lib.rs
+++ b/dhall_syntax/src/lib.rs
@@ -3,6 +3,7 @@
 #![feature(try_blocks)]
 #![feature(never_type)]
 #![feature(bind_by_move_pattern_guards)]
+#![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 4fd6f57..fa2d7c5 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -8,6 +8,7 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 use dhall_generated_parser::{DhallParser, Rule};
+use dhall_proc_macros::{make_parser, parse_children};
 
 use crate::map::{DupTreeMap, DupTreeSet};
 use crate::ExprF::*;
@@ -27,55 +28,39 @@ pub type ParseError = pest::error::Error<Rule>;
 
 pub type ParseResult<T> = Result<T, ParseError>;
 
-#[derive(Debug)]
-enum Either<A, B> {
-    Left(A),
-    Right(B),
+#[derive(Debug, Clone)]
+struct ParseInput<'input, 'climbers, Rule>
+where
+    Rule: std::fmt::Debug + Copy + std::hash::Hash + Ord,
+{
+    pair: Pair<'input, Rule>,
+    climbers: &'climbers HashMap<Rule, PrecClimber<Rule>>,
+    original_input_str: Rc<str>,
 }
 
-impl crate::Builtin {
-    pub fn parse(s: &str) -> Option<Self> {
-        use crate::Builtin::*;
-        match s {
-            "Bool" => Some(Bool),
-            "Natural" => Some(Natural),
-            "Integer" => Some(Integer),
-            "Double" => Some(Double),
-            "Text" => Some(Text),
-            "List" => Some(List),
-            "Optional" => Some(Optional),
-            "None" => Some(OptionalNone),
-            "Natural/build" => Some(NaturalBuild),
-            "Natural/fold" => Some(NaturalFold),
-            "Natural/isZero" => Some(NaturalIsZero),
-            "Natural/even" => Some(NaturalEven),
-            "Natural/odd" => Some(NaturalOdd),
-            "Natural/toInteger" => Some(NaturalToInteger),
-            "Natural/show" => Some(NaturalShow),
-            "Natural/subtract" => Some(NaturalSubtract),
-            "Integer/toDouble" => Some(IntegerToDouble),
-            "Integer/show" => Some(IntegerShow),
-            "Double/show" => Some(DoubleShow),
-            "List/build" => Some(ListBuild),
-            "List/fold" => Some(ListFold),
-            "List/length" => Some(ListLength),
-            "List/head" => Some(ListHead),
-            "List/last" => Some(ListLast),
-            "List/indexed" => Some(ListIndexed),
-            "List/reverse" => Some(ListReverse),
-            "Optional/fold" => Some(OptionalFold),
-            "Optional/build" => Some(OptionalBuild),
-            "Text/show" => Some(TextShow),
-            _ => None,
+impl<'input, 'climbers> ParseInput<'input, 'climbers, 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 with_pair(&self, new_pair: Pair<'input, Rule>) -> Self {
+        ParseInput {
+            pair: new_pair,
+            climbers: self.climbers,
+            original_input_str: self.original_input_str.clone(),
         }
     }
-}
-
-pub fn custom_parse_error(pair: &Pair<Rule>, msg: String) -> ParseError {
-    let msg =
-        format!("{} while matching on:\n{}", msg, debug_pair(pair.clone()));
-    let e = pest::error::ErrorVariant::CustomError { message: msg };
-    pest::error::Error::new_from_span(e, pair.as_span())
+    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 debug_pair(pair: Pair<Rule>) -> String {
@@ -119,74 +104,48 @@ fn debug_pair(pair: Pair<Rule>) -> String {
     s
 }
 
-macro_rules! parse_children {
-    // Variable length pattern with a common unary variant
-    (@match_forwards,
-        $parse_args:expr,
-        $iter:expr,
-        ($body:expr),
-        $variant:ident ($x:ident)..,
-        $($rest:tt)*
-    ) => {
-        parse_children!(@match_backwards,
-            $parse_args, $iter,
-            ({
-                let $x = $iter
-                    .map(|x| Parsers::$variant($parse_args, x))
-                    .collect::<Result<Vec<_>, _>>()?
-                    .into_iter();
-                $body
-            }),
-            $($rest)*
-        )
-    };
-    // Single item pattern
-    (@match_forwards,
-        $parse_args:expr,
-        $iter:expr,
-        ($body:expr),
-        $variant:ident ($x:pat),
-        $($rest:tt)*
-    ) => {{
-        let p = $iter.next().unwrap();
-        let $x = Parsers::$variant($parse_args, p)?;
-        parse_children!(@match_forwards,
-            $parse_args, $iter,
-            ($body),
-            $($rest)*
-        )
-    }};
-    // Single item pattern after a variable length one: declare reversed and take from the end
-    (@match_backwards,
-        $parse_args:expr,
-        $iter:expr,
-        ($body:expr),
-        $variant:ident ($x:pat),
-        $($rest:tt)*
-    ) => {
-        parse_children!(@match_backwards, $parse_args, $iter, ({
-            let p = $iter.next_back().unwrap();
-            let $x = Parsers::$variant($parse_args, p)?;
-            $body
-        }), $($rest)*)
-    };
-
-    // Check no elements remain
-    (@match_forwards, $parse_args:expr, $iter:expr, ($body:expr) $(,)*) => {
-        $body
-    };
-    // After a variable length pattern, everything has already been consumed
-    (@match_backwards, $parse_args:expr, $iter:expr, ($body:expr) $(,)*) => {
-        $body
-    };
+#[derive(Debug)]
+enum Either<A, B> {
+    Left(A),
+    Right(B),
+}
 
-    ($parse_args:expr, $iter:expr; [$($args:tt)*] => $body:expr) => {
-        parse_children!(@match_forwards,
-            $parse_args, $iter,
-            ($body),
-            $($args)*,
-        )
-    };
+impl crate::Builtin {
+    pub fn parse(s: &str) -> Option<Self> {
+        use crate::Builtin::*;
+        match s {
+            "Bool" => Some(Bool),
+            "Natural" => Some(Natural),
+            "Integer" => Some(Integer),
+            "Double" => Some(Double),
+            "Text" => Some(Text),
+            "List" => Some(List),
+            "Optional" => Some(Optional),
+            "None" => Some(OptionalNone),
+            "Natural/build" => Some(NaturalBuild),
+            "Natural/fold" => Some(NaturalFold),
+            "Natural/isZero" => Some(NaturalIsZero),
+            "Natural/even" => Some(NaturalEven),
+            "Natural/odd" => Some(NaturalOdd),
+            "Natural/toInteger" => Some(NaturalToInteger),
+            "Natural/show" => Some(NaturalShow),
+            "Natural/subtract" => Some(NaturalSubtract),
+            "Integer/toDouble" => Some(IntegerToDouble),
+            "Integer/show" => Some(IntegerShow),
+            "Double/show" => Some(DoubleShow),
+            "List/build" => Some(ListBuild),
+            "List/fold" => Some(ListFold),
+            "List/length" => Some(ListLength),
+            "List/head" => Some(ListHead),
+            "List/last" => Some(ListLast),
+            "List/indexed" => Some(ListIndexed),
+            "List/reverse" => Some(ListReverse),
+            "Optional/fold" => Some(OptionalFold),
+            "Optional/build" => Some(OptionalBuild),
+            "Text/show" => Some(TextShow),
+            _ => None,
+        }
+    }
 }
 
 // Trim the shared indent off of a vec of lines, as defined by the Dhall semantics of multiline
@@ -230,674 +189,894 @@ fn trim_indent(lines: &mut Vec<ParsedText>) {
     }
 }
 
-dhall_proc_macros::make_parser! {
-    rule!(EOI<()>);
-
-    rule!(simple_label<Label>;
-        captured_str!(s) => Label::from(s.trim().to_owned())
-    );
-    rule!(quoted_label<Label>;
-        captured_str!(s) => Label::from(s.trim().to_owned())
-    );
-    rule!(label<Label>; children!(
-        [simple_label(l)] => l,
-        [quoted_label(l)] => l,
-    ));
-
-    rule!(double_quote_literal<ParsedText>; children!(
-        [double_quote_chunk(chunks)..] => {
-            chunks.collect()
-        }
-    ));
-
-    rule!(double_quote_chunk<ParsedTextContents>; children!(
-        [interpolation(e)] => {
-            InterpolatedTextContents::Expr(e)
-        },
-        [double_quote_escaped(s)] => {
-            InterpolatedTextContents::Text(s)
-        },
-        [double_quote_char(s)] => {
-            InterpolatedTextContents::Text(s.to_owned())
-        },
-    ));
-    rule!(double_quote_escaped<String>;
-        captured_str!(s) => {
-            match s {
-                "\"" => "\"".to_owned(),
-                "$" => "$".to_owned(),
-                "\\" => "\\".to_owned(),
-                "/" => "/".to_owned(),
-                "b" => "\u{0008}".to_owned(),
-                "f" => "\u{000C}".to_owned(),
-                "n" => "\n".to_owned(),
-                "r" => "\r".to_owned(),
-                "t" => "\t".to_owned(),
-                // "uXXXX" or "u{XXXXX}"
-                _ => {
-                    use std::convert::{TryFrom, TryInto};
-
-                    let s = &s[1..];
-                    let s = if &s[0..1] == "{" {
-                        &s[1..s.len()-1]
-                    } else {
-                        &s[0..s.len()]
-                    };
-
-                    if s.len() > 8 {
-                        Err(format!("Escape sequences can't have more than 8 chars: \"{}\"", s))?
-                    }
+fn make_precclimber() -> PrecClimber<Rule> {
+    use Rule::*;
+    // In order of precedence
+    let operators = vec![
+        import_alt,
+        bool_or,
+        natural_plus,
+        text_append,
+        list_append,
+        bool_and,
+        combine,
+        prefer,
+        combine_types,
+        natural_times,
+        bool_eq,
+        bool_ne,
+        equivalent,
+    ];
+    PrecClimber::new(
+        operators
+            .into_iter()
+            .map(|op| pcl::Operator::new(op, pcl::Assoc::Left))
+            .collect(),
+    )
+}
+
+make_parser! {
+    fn EOI(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+
+    fn simple_label(input: ParseInput<Rule>) -> ParseResult<Label> {
+        Ok(Label::from(input.as_str().trim().to_owned()))
+    }
+    fn quoted_label(input: ParseInput<Rule>) -> ParseResult<Label> {
+        Ok(Label::from(input.as_str().trim().to_owned()))
+    }
+    fn label(input: ParseInput<Rule>) -> ParseResult<Label> {
+        Ok(parse_children!(input;
+            [simple_label(l)] => l,
+            [quoted_label(l)] => l,
+        ))
+    }
+
+    fn double_quote_literal(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<ParsedText> {
+        Ok(parse_children!(input;
+            [double_quote_chunk(chunks)..] => {
+                chunks.collect()
+            }
+        ))
+    }
 
-                    // pad with zeroes
-                    let s: String = std::iter::repeat('0')
-                        .take(8 - s.len())
-                        .chain(s.chars())
-                        .collect();
-
-                    // `s` has length 8, so `bytes` has length 4
-                    let bytes: &[u8] = &hex::decode(s).unwrap();
-                    let i = u32::from_be_bytes(bytes.try_into().unwrap());
-                    let c = char::try_from(i).unwrap();
-                    match i {
-                        0xD800..=0xDFFF => {
-                            let c_ecapsed = c.escape_unicode();
-                            Err(format!("Escape sequences can't contain surrogate pairs: \"{}\"", c_ecapsed))?
-                        },
-                        0x0FFFE..=0x0FFFF | 0x1FFFE..=0x1FFFF |
-                        0x2FFFE..=0x2FFFF | 0x3FFFE..=0x3FFFF |
-                        0x4FFFE..=0x4FFFF | 0x5FFFE..=0x5FFFF |
-                        0x6FFFE..=0x6FFFF | 0x7FFFE..=0x7FFFF |
-                        0x8FFFE..=0x8FFFF | 0x9FFFE..=0x9FFFF |
-                        0xAFFFE..=0xAFFFF | 0xBFFFE..=0xBFFFF |
-                        0xCFFFE..=0xCFFFF | 0xDFFFE..=0xDFFFF |
-                        0xEFFFE..=0xEFFFF | 0xFFFFE..=0xFFFFF |
-                        0x10_FFFE..=0x10_FFFF => {
-                            let c_ecapsed = c.escape_unicode();
-                            Err(format!("Escape sequences can't contain non-characters: \"{}\"", c_ecapsed))?
-                        },
-                        _ => {}
+    fn double_quote_chunk(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<ParsedTextContents> {
+        Ok(parse_children!(input;
+            [interpolation(e)] => {
+                InterpolatedTextContents::Expr(e)
+            },
+            [double_quote_escaped(s)] => {
+                InterpolatedTextContents::Text(s)
+            },
+            [double_quote_char(s)] => {
+                InterpolatedTextContents::Text(s.to_owned())
+            },
+        ))
+    }
+    fn double_quote_escaped(input: ParseInput<Rule>) -> ParseResult<String> {
+        Ok(match input.as_str() {
+            "\"" => "\"".to_owned(),
+            "$" => "$".to_owned(),
+            "\\" => "\\".to_owned(),
+            "/" => "/".to_owned(),
+            "b" => "\u{0008}".to_owned(),
+            "f" => "\u{000C}".to_owned(),
+            "n" => "\n".to_owned(),
+            "r" => "\r".to_owned(),
+            "t" => "\t".to_owned(),
+            // "uXXXX" or "u{XXXXX}"
+            s => {
+                use std::convert::{TryFrom, TryInto};
+
+                let s = &s[1..];
+                let s = if &s[0..1] == "{" {
+                    &s[1..s.len() - 1]
+                } else {
+                    &s[0..s.len()]
+                };
+
+                if s.len() > 8 {
+                    Err(input.error(format!(
+                        "Escape sequences can't have more than 8 chars: \"{}\"",
+                        s
+                    )))?
+                }
+
+                // pad with zeroes
+                let s: String = std::iter::repeat('0')
+                    .take(8 - s.len())
+                    .chain(s.chars())
+                    .collect();
+
+                // `s` has length 8, so `bytes` has length 4
+                let bytes: &[u8] = &hex::decode(s).unwrap();
+                let i = u32::from_be_bytes(bytes.try_into().unwrap());
+                let c = char::try_from(i).unwrap();
+                match i {
+                    0xD800..=0xDFFF => {
+                        let c_ecapsed = c.escape_unicode();
+                        Err(input.error(format!("Escape sequences can't contain surrogate pairs: \"{}\"", c_ecapsed)))?
+                    }
+                    0x0FFFE..=0x0FFFF
+                    | 0x1FFFE..=0x1FFFF
+                    | 0x2FFFE..=0x2FFFF
+                    | 0x3FFFE..=0x3FFFF
+                    | 0x4FFFE..=0x4FFFF
+                    | 0x5FFFE..=0x5FFFF
+                    | 0x6FFFE..=0x6FFFF
+                    | 0x7FFFE..=0x7FFFF
+                    | 0x8FFFE..=0x8FFFF
+                    | 0x9FFFE..=0x9FFFF
+                    | 0xAFFFE..=0xAFFFF
+                    | 0xBFFFE..=0xBFFFF
+                    | 0xCFFFE..=0xCFFFF
+                    | 0xDFFFE..=0xDFFFF
+                    | 0xEFFFE..=0xEFFFF
+                    | 0xFFFFE..=0xFFFFF
+                    | 0x10_FFFE..=0x10_FFFF => {
+                        let c_ecapsed = c.escape_unicode();
+                        Err(input.error(format!("Escape sequences can't contain non-characters: \"{}\"", c_ecapsed)))?
                     }
-                    std::iter::once(c).collect()
+                    _ => {}
                 }
+                std::iter::once(c).collect()
             }
-        }
-    );
-    rule!(double_quote_char<&'a str>;
-        captured_str!(s) => s
-    );
-
-    rule!(single_quote_literal<ParsedText>; children!(
-        [single_quote_continue(lines)] => {
-            let newline: ParsedText = "\n".to_string().into();
-
-            let mut lines: Vec<ParsedText> = lines
-                .into_iter()
-                .rev()
-                .map(|l| l.into_iter().rev().collect::<ParsedText>())
-                .collect();
-
-            trim_indent(&mut lines);
-
-            lines
-                .into_iter()
-                .intersperse(newline)
-                .flat_map(InterpolatedText::into_iter)
-                .collect::<ParsedText>()
-        }
-    ));
-    rule!(single_quote_char<&'a str>;
-        captured_str!(s) => s
-    );
-    rule!(escaped_quote_pair<&'a str>;
-        captured_str!(_) => "''"
-    );
-    rule!(escaped_interpolation<&'a str>;
-        captured_str!(_) => "${"
-    );
-    rule!(interpolation<ParsedExpr>; children!(
-        [expression(e)] => e
-    ));
+        })
+    }
+    fn double_quote_char<'a>(
+        input: ParseInput<'a, '_, Rule>,
+    ) -> ParseResult<&'a str> {
+        Ok(input.as_str())
+    }
+
+    fn single_quote_literal(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<ParsedText> {
+        Ok(parse_children!(input;
+            [single_quote_continue(lines)] => {
+                let newline: ParsedText = "\n".to_string().into();
+
+                let mut lines: Vec<ParsedText> = lines
+                    .into_iter()
+                    .rev()
+                    .map(|l| l.into_iter().rev().collect::<ParsedText>())
+                    .collect();
+
+                trim_indent(&mut lines);
+
+                lines
+                    .into_iter()
+                    .intersperse(newline)
+                    .flat_map(InterpolatedText::into_iter)
+                    .collect::<ParsedText>()
+            }
+        ))
+    }
+    fn single_quote_char<'a>(
+        input: ParseInput<'a, '_, Rule>,
+    ) -> ParseResult<&'a str> {
+        Ok(input.as_str())
+    }
+    fn escaped_quote_pair<'a>(
+        _: ParseInput<'a, '_, Rule>,
+    ) -> ParseResult<&'a str> {
+        Ok("''")
+    }
+    fn escaped_interpolation<'a>(
+        _: ParseInput<'a, '_, Rule>,
+    ) -> ParseResult<&'a str> {
+        Ok("${")
+    }
+    fn interpolation(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+        Ok(parse_children!(input;
+            [expression(e)] => e
+        ))
+    }
 
     // Returns a vec of lines in reversed order, where each line is also in reversed order.
-    rule!(single_quote_continue<Vec<Vec<ParsedTextContents>>>; children!(
-        [interpolation(c), single_quote_continue(lines)] => {
-            let c = InterpolatedTextContents::Expr(c);
-            let mut lines = lines;
-            lines.last_mut().unwrap().push(c);
-            lines
-        },
-        [escaped_quote_pair(c), single_quote_continue(lines)] => {
-            let mut lines = lines;
-            // TODO: don't allocate for every char
-            let c = InterpolatedTextContents::Text(c.to_owned());
-            lines.last_mut().unwrap().push(c);
-            lines
-        },
-        [escaped_interpolation(c), single_quote_continue(lines)] => {
-            let mut lines = lines;
-            // TODO: don't allocate for every char
-            let c = InterpolatedTextContents::Text(c.to_owned());
-            lines.last_mut().unwrap().push(c);
-            lines
-        },
-        [single_quote_char(c), single_quote_continue(lines)] => {
-            let mut lines = lines;
-            if c == "\n" || c == "\r\n" {
-                lines.push(vec![]);
-            } else {
+    fn single_quote_continue(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<Vec<Vec<ParsedTextContents>>> {
+        Ok(parse_children!(input;
+            [interpolation(c), single_quote_continue(lines)] => {
+                let c = InterpolatedTextContents::Expr(c);
+                let mut lines = lines;
+                lines.last_mut().unwrap().push(c);
+                lines
+            },
+            [escaped_quote_pair(c), single_quote_continue(lines)] => {
+                let mut lines = lines;
                 // TODO: don't allocate for every char
                 let c = InterpolatedTextContents::Text(c.to_owned());
                 lines.last_mut().unwrap().push(c);
-            }
-            lines
-        },
-        [] => {
-            vec![vec![]]
-        },
-    ));
-
-    rule!(builtin<ParsedExpr>; span;
-        captured_str!(s) => {
-            spanned(span, match crate::Builtin::parse(s) {
+                lines
+            },
+            [escaped_interpolation(c), single_quote_continue(lines)] => {
+                let mut lines = lines;
+                // TODO: don't allocate for every char
+                let c = InterpolatedTextContents::Text(c.to_owned());
+                lines.last_mut().unwrap().push(c);
+                lines
+            },
+            [single_quote_char(c), single_quote_continue(lines)] => {
+                let mut lines = lines;
+                if c == "\n" || c == "\r\n" {
+                    lines.push(vec![]);
+                } else {
+                    // TODO: don't allocate for every char
+                    let c = InterpolatedTextContents::Text(c.to_owned());
+                    lines.last_mut().unwrap().push(c);
+                }
+                lines
+            },
+            [] => {
+                vec![vec![]]
+            },
+        ))
+    }
+
+    fn builtin(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+        let s = input.as_str();
+        let span = input.as_span();
+        Ok(spanned(
+            span,
+            match crate::Builtin::parse(s) {
                 Some(b) => Builtin(b),
-                None => match s {
-                    "True" => BoolLit(true),
-                    "False" => BoolLit(false),
-                    "Type" => Const(crate::Const::Type),
-                    "Kind" => Const(crate::Const::Kind),
-                    "Sort" => Const(crate::Const::Sort),
-                    _ => Err(
-                        format!("Unrecognized builtin: '{}'", s)
-                    )?,
+                None => {
+                    match s {
+                        "True" => BoolLit(true),
+                        "False" => BoolLit(false),
+                        "Type" => Const(crate::Const::Type),
+                        "Kind" => Const(crate::Const::Kind),
+                        "Sort" => Const(crate::Const::Sort),
+                        _ => Err(input
+                            .error(format!("Unrecognized builtin: '{}'", s)))?,
+                    }
                 }
-            })
+            },
+        ))
+    }
+
+    fn NaN(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+    fn minus_infinity_literal(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+    fn plus_infinity_literal(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+
+    fn numeric_double_literal(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<core::Double> {
+        let s = input.as_str().trim();
+        match s.parse::<f64>() {
+            Ok(x) if x.is_infinite() => Err(input.error(format!(
+                "Overflow while parsing double literal '{}'",
+                s
+            ))),
+            Ok(x) => Ok(NaiveDouble::from(x)),
+            Err(e) => Err(input.error(format!("{}", e))),
         }
-    );
-
-    rule!(NaN<()>);
-    rule!(minus_infinity_literal<()>);
-    rule!(plus_infinity_literal<()>);
-
-    rule!(numeric_double_literal<core::Double>;
-        captured_str!(s) => {
-            let s = s.trim();
-            match s.parse::<f64>() {
-                Ok(x) if x.is_infinite() =>
-                    Err(format!("Overflow while parsing double literal '{}'", s))?,
-                Ok(x) => NaiveDouble::from(x),
-                Err(e) => Err(format!("{}", e))?,
+    }
+
+    fn double_literal(input: ParseInput<Rule>) -> ParseResult<core::Double> {
+        Ok(parse_children!(input;
+            [numeric_double_literal(n)] => n,
+            [minus_infinity_literal(_)] => std::f64::NEG_INFINITY.into(),
+            [plus_infinity_literal(_)] => std::f64::INFINITY.into(),
+            [NaN(_)] => std::f64::NAN.into(),
+        ))
+    }
+
+    fn natural_literal(input: ParseInput<Rule>) -> ParseResult<core::Natural> {
+        input
+            .as_str()
+            .trim()
+            .parse()
+            .map_err(|e| input.error(format!("{}", e)))
+    }
+
+    fn integer_literal(input: ParseInput<Rule>) -> ParseResult<core::Integer> {
+        input
+            .as_str()
+            .trim()
+            .parse()
+            .map_err(|e| input.error(format!("{}", e)))
+    }
+
+    fn identifier(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+        let span = input.as_span();
+        Ok(parse_children!(input;
+            [variable(v)] => {
+                spanned(span, Var(v))
+            },
+            [builtin(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 unquoted_path_component<'a>(
+        input: ParseInput<'a, '_, Rule>,
+    ) -> ParseResult<&'a str> {
+        Ok(input.as_str())
+    }
+    fn quoted_path_component<'a>(
+        input: ParseInput<'a, '_, Rule>,
+    ) -> ParseResult<&'a str> {
+        Ok(input.as_str())
+    }
+    fn path_component(input: ParseInput<Rule>) -> ParseResult<String> {
+        Ok(parse_children!(input;
+            [unquoted_path_component(s)] => s.to_string(),
+            [quoted_path_component(s)] => {
+                const RESERVED: &percent_encoding::AsciiSet =
+                    &percent_encoding::CONTROLS
+                    .add(b'=').add(b':').add(b'/').add(b'?')
+                    .add(b'#').add(b'[').add(b']').add(b'@')
+                    .add(b'!').add(b'$').add(b'&').add(b'\'')
+                    .add(b'(').add(b')').add(b'*').add(b'+')
+                    .add(b',').add(b';');
+                s.chars()
+                    .map(|c| {
+                        // Percent-encode ascii chars
+                        if c.is_ascii() {
+                            percent_encoding::utf8_percent_encode(
+                                &c.to_string(),
+                                RESERVED,
+                            ).to_string()
+                        } else {
+                            c.to_string()
+                        }
+                    })
+                    .collect()
+            },
+        ))
+    }
+    fn path(input: ParseInput<Rule>) -> ParseResult<Vec<String>> {
+        Ok(parse_children!(input;
+            [path_component(components)..] => {
+                components.collect()
             }
-        }
-    );
-
-    rule!(double_literal<core::Double>; children!(
-        [numeric_double_literal(n)] => n,
-        [minus_infinity_literal(_)] => std::f64::NEG_INFINITY.into(),
-        [plus_infinity_literal(_)] => std::f64::INFINITY.into(),
-        [NaN(_)] => std::f64::NAN.into(),
-    ));
-
-    rule!(natural_literal<core::Natural>;
-        captured_str!(s) => {
-            s.trim()
-                .parse()
-                .map_err(|e| format!("{}", e))?
-        }
-    );
+        ))
+    }
 
-    rule!(integer_literal<core::Integer>;
-        captured_str!(s) => {
-            s.trim()
-                .parse()
-                .map_err(|e| format!("{}", e))?
-        }
-    );
-
-    rule!(identifier<ParsedExpr>; span; children!(
-        [variable(v)] => {
-            spanned(span, Var(v))
-        },
-        [builtin(e)] => e,
-    ));
-
-    rule!(variable<V<Label>>; children!(
-        [label(l), natural_literal(idx)] => {
-            V(l, idx)
-        },
-        [label(l)] => {
-            V(l, 0)
-        },
-    ));
-
-    rule!(unquoted_path_component<&'a str>; captured_str!(s) => s);
-    rule!(quoted_path_component<&'a str>; captured_str!(s) => s);
-    rule!(path_component<String>; children!(
-        [unquoted_path_component(s)] => s.to_string(),
-        [quoted_path_component(s)] => {
-            const RESERVED: &percent_encoding::AsciiSet =
-                &percent_encoding::CONTROLS
-                .add(b'=').add(b':').add(b'/').add(b'?')
-                .add(b'#').add(b'[').add(b']').add(b'@')
-                .add(b'!').add(b'$').add(b'&').add(b'\'')
-                .add(b'(').add(b')').add(b'*').add(b'+')
-                .add(b',').add(b';');
-            s.chars()
-                .map(|c| {
-                    // Percent-encode ascii chars
-                    if c.is_ascii() {
-                        percent_encoding::utf8_percent_encode(
-                            &c.to_string(),
-                            RESERVED,
-                        ).to_string()
-                    } else {
-                        c.to_string()
-                    }
-                })
-                .collect()
-        },
-    ));
-    rule!(path<Vec<String>>; children!(
-        [path_component(components)..] => {
-            components.collect()
-        }
-    ));
-
-    rule!(local<(FilePrefix, Vec<String>)>; children!(
-        [parent_path(l)] => l,
-        [here_path(l)] => l,
-        [home_path(l)] => l,
-        [absolute_path(l)] => l,
-    ));
-
-    rule!(parent_path<(FilePrefix, Vec<String>)>; children!(
-        [path(p)] => (FilePrefix::Parent, p)
-    ));
-    rule!(here_path<(FilePrefix, Vec<String>)>; children!(
-        [path(p)] => (FilePrefix::Here, p)
-    ));
-    rule!(home_path<(FilePrefix, Vec<String>)>; children!(
-        [path(p)] => (FilePrefix::Home, p)
-    ));
-    rule!(absolute_path<(FilePrefix, Vec<String>)>; children!(
-        [path(p)] => (FilePrefix::Absolute, p)
-    ));
-
-    rule!(scheme<Scheme>; captured_str!(s) => match s {
-        "http" => Scheme::HTTP,
-        "https" => Scheme::HTTPS,
-        _ => unreachable!(),
-    });
-
-    rule!(http_raw<URL<ParsedExpr>>; children!(
-        [scheme(sch), authority(auth), path(p)] => URL {
-            scheme: sch,
-            authority: auth,
-            path: p,
-            query: None,
-            headers: None,
-        },
-        [scheme(sch), authority(auth), path(p), query(q)] => URL {
-            scheme: sch,
-            authority: auth,
-            path: p,
-            query: Some(q),
-            headers: None,
-        },
-    ));
-
-    rule!(authority<String>; captured_str!(s) => s.to_owned());
-
-    rule!(query<String>; captured_str!(s) => s.to_owned());
-
-    rule!(http<URL<ParsedExpr>>; children!(
+    fn local(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<(FilePrefix, Vec<String>)> {
+        Ok(parse_children!(input;
+            [parent_path(l)] => l,
+            [here_path(l)] => l,
+            [home_path(l)] => l,
+            [absolute_path(l)] => l,
+        ))
+    }
+
+    fn parent_path(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<(FilePrefix, Vec<String>)> {
+        Ok(parse_children!(input;
+            [path(p)] => (FilePrefix::Parent, p)
+        ))
+    }
+    fn here_path(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<(FilePrefix, Vec<String>)> {
+        Ok(parse_children!(input;
+            [path(p)] => (FilePrefix::Here, p)
+        ))
+    }
+    fn home_path(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<(FilePrefix, Vec<String>)> {
+        Ok(parse_children!(input;
+            [path(p)] => (FilePrefix::Home, p)
+        ))
+    }
+    fn absolute_path(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<(FilePrefix, Vec<String>)> {
+        Ok(parse_children!(input;
+            [path(p)] => (FilePrefix::Absolute, p)
+        ))
+    }
+
+    fn scheme(input: ParseInput<Rule>) -> ParseResult<Scheme> {
+        Ok(match input.as_str() {
+            "http" => Scheme::HTTP,
+            "https" => Scheme::HTTPS,
+            _ => unreachable!(),
+        })
+    }
+
+    fn http_raw(input: ParseInput<Rule>) -> ParseResult<URL<ParsedExpr>> {
+        Ok(parse_children!(input;
+            [scheme(sch), authority(auth), path(p)] => URL {
+                scheme: sch,
+                authority: auth,
+                path: p,
+                query: None,
+                headers: None,
+            },
+            [scheme(sch), authority(auth), path(p), query(q)] => URL {
+                scheme: sch,
+                authority: auth,
+                path: p,
+                query: Some(q),
+                headers: None,
+            },
+        ))
+    }
+
+    fn authority(input: ParseInput<Rule>) -> ParseResult<String> {
+        Ok(input.as_str().to_owned())
+    }
+
+    fn query(input: ParseInput<Rule>) -> ParseResult<String> {
+        Ok(input.as_str().to_owned())
+    }
+
+    fn http(input: ParseInput<Rule>) -> ParseResult<URL<ParsedExpr>> {
+        Ok(parse_children!(input;
         [http_raw(url)] => url,
         [http_raw(url), import_expression(e)] =>
             URL { headers: Some(e), ..url },
-    ));
-
-    rule!(env<String>; children!(
-        [bash_environment_variable(s)] => s,
-        [posix_environment_variable(s)] => s,
-    ));
-    rule!(bash_environment_variable<String>; captured_str!(s) => s.to_owned());
-    rule!(posix_environment_variable<String>; children!(
-        [posix_environment_variable_character(chars)..] => {
-            chars.collect()
-        },
-    ));
-    rule!(posix_environment_variable_character<Cow<'a, str>>;
-        captured_str!(s) => {
-            match s {
-                "\\\"" => 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()),
-                _ => Cow::Borrowed(s)
-            }
-        }
-    );
-
-    rule!(missing<()>);
-
-    rule!(import_type<ImportLocation<ParsedExpr>>; children!(
-        [missing(_)] => {
-            ImportLocation::Missing
-        },
-        [env(e)] => {
-            ImportLocation::Env(e)
-        },
-        [http(url)] => {
-            ImportLocation::Remote(url)
-        },
-        [local((prefix, p))] => {
-            ImportLocation::Local(prefix, p)
-        },
-    ));
-
-    rule!(hash<Hash>; captured_str!(s) => {
-        let s = s.trim();
+        ))
+    }
+
+    fn env(input: ParseInput<Rule>) -> ParseResult<String> {
+        Ok(parse_children!(input;
+            [bash_environment_variable(s)] => s,
+            [posix_environment_variable(s)] => s,
+        ))
+    }
+    fn bash_environment_variable(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<String> {
+        Ok(input.as_str().to_owned())
+    }
+    fn posix_environment_variable(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<String> {
+        Ok(parse_children!(input;
+            [posix_environment_variable_character(chars)..] => {
+                chars.collect()
+            },
+        ))
+    }
+    fn posix_environment_variable_character<'a>(
+        input: ParseInput<'a, '_, Rule>,
+    ) -> ParseResult<Cow<'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),
+        })
+    }
+
+    fn missing(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+
+    fn import_type(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<ImportLocation<ParsedExpr>> {
+        Ok(parse_children!(input;
+            [missing(_)] => {
+                ImportLocation::Missing
+            },
+            [env(e)] => {
+                ImportLocation::Env(e)
+            },
+            [http(url)] => {
+                ImportLocation::Remote(url)
+            },
+            [local((prefix, p))] => {
+                ImportLocation::Local(prefix, p)
+            },
+        ))
+    }
+
+    fn hash(input: ParseInput<Rule>) -> ParseResult<Hash> {
+        let s = input.as_str().trim();
         let protocol = &s[..6];
         let hash = &s[7..];
         if protocol != "sha256" {
-            Err(format!("Unknown hashing protocol '{}'", protocol))?
+            Err(input.error(format!("Unknown hashing protocol '{}'", protocol)))?
         }
-        Hash::SHA256(hex::decode(hash).unwrap())
-    });
+        Ok(Hash::SHA256(hex::decode(hash).unwrap()))
+    }
 
-    rule!(import_hashed<crate::Import<ParsedExpr>>; children!(
+    fn import_hashed(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<crate::Import<ParsedExpr>> {
+        Ok(parse_children!(input;
         [import_type(location)] =>
             crate::Import {mode: ImportMode::Code, location, hash: None },
         [import_type(location), hash(h)] =>
-            crate::Import {mode: ImportMode::Code, location, hash: Some(h) },
-    ));
-
-    rule!(Text<()>);
-    rule!(Location<()>);
-
-    rule!(import<ParsedExpr>; span; children!(
-        [import_hashed(imp)] => {
-            spanned(span, Import(crate::Import {
-                mode: ImportMode::Code,
-                ..imp
-            }))
-        },
-        [import_hashed(imp), Text(_)] => {
-            spanned(span, Import(crate::Import {
-                mode: ImportMode::RawText,
-                ..imp
-            }))
-        },
-        [import_hashed(imp), Location(_)] => {
-            spanned(span, Import(crate::Import {
-                mode: ImportMode::Location,
-                ..imp
-            }))
-        },
-    ));
-
-    rule!(lambda<()>);
-    rule!(forall<()>);
-    rule!(arrow<()>);
-    rule!(merge<()>);
-    rule!(assert<()>);
-    rule!(if_<()>);
-    rule!(in_<()>);
-    rule!(toMap<()>);
-
-    rule!(empty_list_literal<ParsedExpr>; span; children!(
-        [application_expression(e)] => {
-            spanned(span, EmptyListLit(e))
-        },
-    ));
-
-    rule!(expression<ParsedExpr>; span; children!(
-        [lambda(()), label(l), expression(typ),
-                arrow(()), expression(body)] => {
-            spanned(span, Lam(l, typ, body))
-        },
-        [if_(()), expression(cond), expression(left), expression(right)] => {
-            spanned(span, BoolIf(cond, left, right))
-        },
-        [let_binding(bindings).., in_(()), expression(final_expr)] => {
-            bindings.rev().fold(
-                final_expr,
-                |acc, x| unspanned(Let(x.0, x.1, x.2, acc))
-            )
-        },
-        [forall(()), label(l), expression(typ),
-                arrow(()), expression(body)] => {
-            spanned(span, Pi(l, typ, body))
-        },
-        [operator_expression(typ), arrow(()), expression(body)] => {
-            spanned(span, Pi("_".into(), typ, body))
-        },
-        [merge(()), import_expression(x), import_expression(y),
-                application_expression(z)] => {
-            spanned(span, Merge(x, y, Some(z)))
-        },
-        [empty_list_literal(e)] => e,
-        [assert(()), expression(x)] => {
-            spanned(span, Assert(x))
-        },
-        [toMap(()), import_expression(x), application_expression(y)] => {
-            spanned(span, ToMap(x, Some(y)))
-        },
-        [operator_expression(e)] => e,
-        [operator_expression(e), expression(annot)] => {
-            spanned(span, Annot(e, annot))
-        },
-    ));
-
-    rule!(let_binding<(Label, Option<ParsedExpr>, ParsedExpr)>;
-            children!(
-        [label(name), expression(annot), expression(expr)] =>
-            (name, Some(annot), expr),
-        [label(name), expression(expr)] =>
-            (name, None, expr),
-    ));
-
-    rule!(List<()>);
-    rule!(Optional<()>);
-
-    rule!(operator_expression<ParsedExpr>; prec_climb!(
-        application_expression,
-        {
-            use Rule::*;
-            // In order of precedence
-            let operators = vec![
-                import_alt,
-                bool_or,
-                natural_plus,
-                text_append,
-                list_append,
-                bool_and,
-                combine,
-                prefer,
-                combine_types,
-                natural_times,
-                bool_eq,
-                bool_ne,
-                equivalent,
-            ];
-            PrecClimber::new(
-                operators
-                    .into_iter()
-                    .map(|op| pcl::Operator::new(op, pcl::Assoc::Left))
-                    .collect(),
-            )
-        },
-        (l, op, r) => {
-            use crate::BinOp::*;
-            use Rule::*;
-            let op = match op.as_rule() {
-                import_alt => ImportAlt,
-                bool_or => BoolOr,
-                natural_plus => NaturalPlus,
-                text_append => TextAppend,
-                list_append => ListAppend,
-                bool_and => BoolAnd,
-                combine => RecursiveRecordMerge,
-                prefer => RightBiasedRecordMerge,
-                combine_types => RecursiveRecordTypeMerge,
-                natural_times => NaturalTimes,
-                bool_eq => BoolEQ,
-                bool_ne => BoolNE,
-                equivalent => Equivalence,
-                r => Err(
-                    format!("Rule {:?} isn't an operator", r),
-                )?,
-            };
-
-            unspanned(BinOp(op, l, r))
-        }
-    ));
-
-    rule!(Some_<()>);
-
-    rule!(application_expression<ParsedExpr>; children!(
-        [first_application_expression(e)] => e,
-        [first_application_expression(first), import_expression(rest)..] => {
-            rest.fold(first, |acc, e| unspanned(App(acc, e)))
-        },
-    ));
-
-    rule!(first_application_expression<ParsedExpr>; span;
-            children!(
-        [Some_(()), import_expression(e)] => {
-            spanned(span, SomeLit(e))
-        },
-        [merge(()), import_expression(x), import_expression(y)] => {
-            spanned(span, Merge(x, y, None))
-        },
-        [toMap(()), import_expression(x)] => {
-            spanned(span, ToMap(x, None))
-        },
-        [import_expression(e)] => e,
-    ));
-
-    rule!(import_expression<ParsedExpr>;
-            children!(
-        [selector_expression(e)] => e,
-        [import(e)] => e,
-    ));
-
-    rule!(selector_expression<ParsedExpr>; children!(
-        [primitive_expression(e)] => e,
-        [primitive_expression(first), selector(rest)..] => {
-            rest.fold(first, |acc, e| unspanned(match e {
-                Either::Left(l) => Field(acc, l),
-                Either::Right(ls) => Projection(acc, ls),
-            }))
-        },
-    ));
-
-    rule!(selector<Either<Label, DupTreeSet<Label>>>; children!(
-        [label(l)] => Either::Left(l),
-        [labels(ls)] => Either::Right(ls),
-        [expression(_e)] => unimplemented!("selection by expression"), // TODO
-    ));
-
-    rule!(labels<DupTreeSet<Label>>; children!(
-        [label(ls)..] => ls.collect(),
-    ));
-
-    rule!(primitive_expression<ParsedExpr>; span; children!(
-        [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)),
-        [empty_record_type(e)] => e,
-        [empty_record_literal(e)] => e,
-        [non_empty_record_type_or_literal(e)] => e,
-        [union_type(e)] => e,
-        [non_empty_list_literal(e)] => e,
-        [identifier(e)] => e,
-        [expression(e)] => e,
-    ));
-
-    rule!(empty_record_literal<ParsedExpr>; span;
-        captured_str!(_) => spanned(span, RecordLit(Default::default()))
-    );
-
-    rule!(empty_record_type<ParsedExpr>; span;
-        captured_str!(_) => spanned(span, RecordType(Default::default()))
-    );
-
-    rule!(non_empty_record_type_or_literal<ParsedExpr>; span;
-          children!(
-        [label(first_label), non_empty_record_type(rest)] => {
-            let (first_expr, mut map) = rest;
-            map.insert(first_label, first_expr);
-            spanned(span, RecordType(map))
-        },
-        [label(first_label), non_empty_record_literal(rest)] => {
-            let (first_expr, mut map) = rest;
-            map.insert(first_label, first_expr);
-            spanned(span, RecordLit(map))
-        },
-    ));
-
-    rule!(non_empty_record_type
-          <(ParsedExpr, DupTreeMap<Label, ParsedExpr>)>; children!(
-        [expression(expr), record_type_entry(entries)..] => {
-            (expr, entries.collect())
-        }
-    ));
+        crate::Import {mode: ImportMode::Code, location, hash: Some(h) },
+        ))
+    }
 
-    rule!(record_type_entry<(Label, ParsedExpr)>; children!(
-        [label(name), expression(expr)] => (name, expr)
-    ));
+    fn Text(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+    fn Location(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
 
-    rule!(non_empty_record_literal
-          <(ParsedExpr, DupTreeMap<Label, ParsedExpr>)>; children!(
-        [expression(expr), record_literal_entry(entries)..] => {
-            (expr, entries.collect())
-        }
-    ));
-
-    rule!(record_literal_entry<(Label, ParsedExpr)>; children!(
-        [label(name), expression(expr)] => (name, expr)
-    ));
-
-    rule!(union_type<ParsedExpr>; span; children!(
-        [empty_union_type(_)] => {
-            spanned(span, UnionType(Default::default()))
-        },
-        [union_type_entry(entries)..] => {
-            spanned(span, UnionType(entries.collect()))
-        },
-    ));
-
-    rule!(empty_union_type<()>);
-
-    rule!(union_type_entry<(Label, Option<ParsedExpr>)>; children!(
-        [label(name), expression(expr)] => (name, Some(expr)),
-        [label(name)] => (name, None),
-    ));
-
-    rule!(non_empty_list_literal<ParsedExpr>; span;
-          children!(
-        [expression(items)..] => spanned(
-            span,
-            NEListLit(items.collect())
-        )
-    ));
+    fn import(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+        let span = input.as_span();
+        Ok(parse_children!(input;
+            [import_hashed(imp)] => {
+                spanned(span, Import(crate::Import {
+                    mode: ImportMode::Code,
+                    ..imp
+                }))
+            },
+            [import_hashed(imp), Text(_)] => {
+                spanned(span, Import(crate::Import {
+                    mode: ImportMode::RawText,
+                    ..imp
+                }))
+            },
+            [import_hashed(imp), Location(_)] => {
+                spanned(span, Import(crate::Import {
+                    mode: ImportMode::Location,
+                    ..imp
+                }))
+            },
+        ))
+    }
+
+    fn lambda(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+    fn forall(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+    fn arrow(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+    fn merge(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+    fn assert(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+    fn if_(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+    fn in_(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+    fn toMap(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+
+    fn empty_list_literal(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+        let span = input.as_span();
+        Ok(parse_children!(input;
+            [application_expression(e)] => {
+                spanned(span, EmptyListLit(e))
+            },
+        ))
+    }
+
+    fn expression(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+        let span = input.as_span();
+        Ok(parse_children!(input;
+            [lambda(()), label(l), expression(typ),
+                    arrow(()), expression(body)] => {
+                spanned(span, Lam(l, typ, body))
+            },
+            [if_(()), expression(cond), expression(left),
+                    expression(right)] => {
+                spanned(span, BoolIf(cond, left, right))
+            },
+            [let_binding(bindings).., in_(()), expression(final_expr)] => {
+                bindings.rev().fold(
+                    final_expr,
+                    |acc, x| unspanned(Let(x.0, x.1, x.2, acc))
+                )
+            },
+            [forall(()), label(l), expression(typ),
+                    arrow(()), expression(body)] => {
+                spanned(span, Pi(l, typ, body))
+            },
+            [operator_expression(typ), arrow(()), expression(body)] => {
+                spanned(span, Pi("_".into(), typ, body))
+            },
+            [merge(()), import_expression(x), import_expression(y),
+                    application_expression(z)] => {
+                spanned(span, Merge(x, y, Some(z)))
+            },
+            [empty_list_literal(e)] => e,
+            [assert(()), expression(x)] => {
+                spanned(span, Assert(x))
+            },
+            [toMap(()), import_expression(x), application_expression(y)] => {
+                spanned(span, ToMap(x, Some(y)))
+            },
+            [operator_expression(e)] => e,
+            [operator_expression(e), expression(annot)] => {
+                spanned(span, Annot(e, annot))
+            },
+        ))
+    }
+
+    fn let_binding(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<(Label, Option<ParsedExpr>, ParsedExpr)> {
+        Ok(parse_children!(input;
+            [label(name), expression(annot), expression(expr)] =>
+                (name, Some(annot), expr),
+            [label(name), expression(expr)] =>
+                (name, None, expr),
+        ))
+    }
+
+    fn List(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+    fn Optional(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+
+    #[prec_climb(application_expression, make_precclimber())]
+    fn operator_expression(
+        input: ParseInput<Rule>,
+        l: ParsedExpr,
+        op: Pair<Rule>,
+        r: ParsedExpr,
+    ) -> ParseResult<ParsedExpr> {
+        use crate::BinOp::*;
+        use Rule::*;
+        let op = match op.as_rule() {
+            import_alt => ImportAlt,
+            bool_or => BoolOr,
+            natural_plus => NaturalPlus,
+            text_append => TextAppend,
+            list_append => ListAppend,
+            bool_and => BoolAnd,
+            combine => RecursiveRecordMerge,
+            prefer => RightBiasedRecordMerge,
+            combine_types => RecursiveRecordTypeMerge,
+            natural_times => NaturalTimes,
+            bool_eq => BoolEQ,
+            bool_ne => BoolNE,
+            equivalent => Equivalence,
+            r => Err(input.error(format!("Rule {:?} isn't an operator", r)))?,
+        };
+
+        Ok(unspanned(BinOp(op, l, r)))
+    }
+
+    fn Some_(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+
+    fn application_expression(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<ParsedExpr> {
+        Ok(parse_children!(input;
+            [first_application_expression(e)] => e,
+            [first_application_expression(first),
+                    import_expression(rest)..] => {
+                rest.fold(first, |acc, e| unspanned(App(acc, e)))
+            },
+        ))
+    }
+
+    fn first_application_expression(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<ParsedExpr> {
+        let span = input.as_span();
+        Ok(parse_children!(input;
+            [Some_(()), import_expression(e)] => {
+                spanned(span, SomeLit(e))
+            },
+            [merge(()), import_expression(x), import_expression(y)] => {
+                spanned(span, Merge(x, y, None))
+            },
+            [toMap(()), import_expression(x)] => {
+                spanned(span, ToMap(x, None))
+            },
+            [import_expression(e)] => e,
+        ))
+    }
+
+    fn import_expression(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+        Ok(parse_children!(input;
+            [selector_expression(e)] => e,
+            [import(e)] => e,
+        ))
+    }
+
+    fn selector_expression(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+        Ok(parse_children!(input;
+            [primitive_expression(e)] => e,
+            [primitive_expression(first), selector(rest)..] => {
+                rest.fold(first, |acc, e| unspanned(match e {
+                    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),
+            [expression(_e)] => unimplemented!("selection by expression"), // TODO
+        ))
+    }
+
+    fn labels(input: ParseInput<Rule>) -> ParseResult<DupTreeSet<Label>> {
+        Ok(parse_children!(input;
+            [label(ls)..] => ls.collect(),
+        ))
+    }
+
+    fn primitive_expression(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<ParsedExpr> {
+        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)),
+            [empty_record_type(e)] => e,
+            [empty_record_literal(e)] => e,
+            [non_empty_record_type_or_literal(e)] => e,
+            [union_type(e)] => e,
+            [non_empty_list_literal(e)] => e,
+            [identifier(e)] => e,
+            [expression(e)] => e,
+        ))
+    }
+
+    fn empty_record_literal(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<ParsedExpr> {
+        let span = input.as_span();
+        Ok(spanned(span, RecordLit(Default::default())))
+    }
 
-    rule!(final_expression<ParsedExpr>; children!(
-        [expression(e), EOI(_)] => e
-    ));
+    fn empty_record_type(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+        let span = input.as_span();
+        Ok(spanned(span, RecordType(Default::default())))
+    }
+
+    fn non_empty_record_type_or_literal(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<ParsedExpr> {
+        let span = input.as_span();
+        Ok(parse_children!(input;
+            [label(first_label), non_empty_record_type(rest)] => {
+                let (first_expr, mut map) = rest;
+                map.insert(first_label, first_expr);
+                spanned(span, RecordType(map))
+            },
+            [label(first_label), non_empty_record_literal(rest)] => {
+                let (first_expr, mut map) = rest;
+                map.insert(first_label, first_expr);
+                spanned(span, RecordLit(map))
+            },
+        ))
+    }
+
+    fn non_empty_record_type(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<(ParsedExpr, DupTreeMap<Label, ParsedExpr>)> {
+        Ok(parse_children!(input;
+            [expression(expr), record_type_entry(entries)..] => {
+                (expr, entries.collect())
+            }
+        ))
+    }
+
+    fn record_type_entry(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<(Label, ParsedExpr)> {
+        Ok(parse_children!(input;
+            [label(name), expression(expr)] => (name, expr)
+        ))
+    }
+
+    fn non_empty_record_literal(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<(ParsedExpr, DupTreeMap<Label, ParsedExpr>)> {
+        Ok(parse_children!(input;
+            [expression(expr), record_literal_entry(entries)..] => {
+                (expr, entries.collect())
+            }
+        ))
+    }
+
+    fn record_literal_entry(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<(Label, ParsedExpr)> {
+        Ok(parse_children!(input;
+            [label(name), expression(expr)] => (name, expr)
+        ))
+    }
+
+    fn union_type(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+        let span = input.as_span();
+        Ok(parse_children!(input;
+            [empty_union_type(_)] => {
+                spanned(span, UnionType(Default::default()))
+            },
+            [union_type_entry(entries)..] => {
+                spanned(span, UnionType(entries.collect()))
+            },
+        ))
+    }
+
+    fn empty_union_type(_: ParseInput<Rule>) -> ParseResult<()> {
+        Ok(())
+    }
+
+    fn union_type_entry(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<(Label, Option<ParsedExpr>)> {
+        Ok(parse_children!(input;
+            [label(name), expression(expr)] => (name, Some(expr)),
+            [label(name)] => (name, None),
+        ))
+    }
+
+    fn non_empty_list_literal(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<ParsedExpr> {
+        let span = input.as_span();
+        Ok(parse_children!(input;
+            [expression(items)..] => spanned(
+                span,
+                NEListLit(items.collect())
+            )
+        ))
+    }
+
+    fn final_expression(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+        Ok(parse_children!(input;
+            [expression(e), EOI(_)] => e
+        ))
+    }
 }
 
 pub fn parse_expr(s: &str) -> ParseResult<ParsedExpr> {
     let mut pairs = DhallParser::parse(Rule::final_expression, s)?;
-    let rc_input = s.to_string().into();
-    let expr = EntryPoint::final_expression(rc_input, pairs.next().unwrap())?;
+    let expr = EntryPoint::final_expression(s, pairs.next().unwrap())?;
     assert_eq!(pairs.next(), None);
     Ok(expr)
 }
-- 
cgit v1.2.3


From 3e9aa3e46bd5906469751c908a0daedfe26dac22 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sun, 1 Sep 2019 22:46:03 +0200
Subject: Make make_parser into a proc_macro_attribute

That way rustfmt will format the contents of the parser.
---
 dhall_proc_macros/src/lib.rs    |  4 ++--
 dhall_proc_macros/src/parser.rs | 12 ++++++++----
 dhall_syntax/src/parser.rs      |  3 ++-
 3 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/dhall_proc_macros/src/lib.rs b/dhall_proc_macros/src/lib.rs
index 46d93e9..92cf981 100644
--- a/dhall_proc_macros/src/lib.rs
+++ b/dhall_proc_macros/src/lib.rs
@@ -15,8 +15,8 @@ pub fn derive_static_type(input: TokenStream) -> TokenStream {
     derive::derive_static_type(input)
 }
 
-#[proc_macro]
-pub fn make_parser(input: TokenStream) -> TokenStream {
+#[proc_macro_attribute]
+pub fn make_parser(_attr: TokenStream, input: TokenStream) -> TokenStream {
     TokenStream::from(match parser::make_parser(input) {
         Ok(tokens) => tokens,
         Err(err) => err.to_compile_error(),
diff --git a/dhall_proc_macros/src/parser.rs b/dhall_proc_macros/src/parser.rs
index 2618bec..1c75279 100644
--- a/dhall_proc_macros/src/parser.rs
+++ b/dhall_proc_macros/src/parser.rs
@@ -4,8 +4,8 @@ use syn::parse::{Parse, ParseStream, Result};
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
 use syn::{
-    bracketed, parenthesized, parse_quote, token, Error, Expr, Ident, ItemFn,
-    Pat, ReturnType, Token, Type,
+    braced, bracketed, parenthesized, parse_quote, token, Error, Expr, Ident,
+    ItemFn, Pat, ReturnType, Token, Type,
 };
 
 mod rule_kw {
@@ -58,9 +58,13 @@ struct ParseChildrenInput {
 
 impl Parse for Rules {
     fn parse(input: ParseStream) -> Result<Self> {
+        let _: Token![impl ] = input.parse()?;
+        let _: Token![_] = input.parse()?;
+        let contents;
+        braced!(contents in input);
         let mut rules = Vec::new();
-        while !input.is_empty() {
-            rules.push(input.parse()?)
+        while !contents.is_empty() {
+            rules.push(contents.parse()?)
         }
         Ok(Rules(rules))
     }
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index fa2d7c5..2864a97 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -215,7 +215,8 @@ fn make_precclimber() -> PrecClimber<Rule> {
     )
 }
 
-make_parser! {
+#[make_parser]
+impl _ {
     fn EOI(_: ParseInput<Rule>) -> ParseResult<()> {
         Ok(())
     }
-- 
cgit v1.2.3


From 98b53bfe084fcdb58207de19fccbd9ac10a7baf7 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 2 Sep 2019 17:02:06 +0200
Subject: Avoid use of bind_by_move_pattern_guards feature

---
 dhall_proc_macros/src/parser.rs | 11 +++++++++--
 dhall_syntax/src/lib.rs         |  1 -
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/dhall_proc_macros/src/parser.rs b/dhall_proc_macros/src/parser.rs
index 1c75279..f2efb80 100644
--- a/dhall_proc_macros/src/parser.rs
+++ b/dhall_proc_macros/src/parser.rs
@@ -283,7 +283,7 @@ fn make_parser_branch(branch: &ChildrenBranch) -> Result<TokenStream> {
     // 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 that they all match the chosen Rule in the `if`-condition.
+    // subslice and checks, in the if-guard, that its elements all match the chosen Rule.
     let variable_pattern_ident =
         Ident::new("variable_pattern", Span::call_site());
     let match_pat = branch.pattern.iter().map(|item| match item {
@@ -293,7 +293,14 @@ fn make_parser_branch(branch: &ChildrenBranch) -> Result<TokenStream> {
     let match_filter = branch.pattern.iter().map(|item| match item {
         Single { .. } => quote!(),
         Multiple { rule_name, .. } => quote!(
-            #variable_pattern_ident.iter().all(|r| r == &Rule::#rule_name) &&
+            {
+                // We can't use .all() directly in the pattern guard without the
+                // bind_by_move_pattern_guards feature.
+                fn all_match(slice: &[Rule]) -> bool {
+                    slice.iter().all(|r| r == &Rule::#rule_name)
+                }
+                all_match(#variable_pattern_ident)
+            } &&
         ),
     });
 
diff --git a/dhall_syntax/src/lib.rs b/dhall_syntax/src/lib.rs
index 290f53c..fb12af4 100644
--- a/dhall_syntax/src/lib.rs
+++ b/dhall_syntax/src/lib.rs
@@ -2,7 +2,6 @@
 #![feature(slice_patterns)]
 #![feature(try_blocks)]
 #![feature(never_type)]
-#![feature(bind_by_move_pattern_guards)]
 #![feature(proc_macro_hygiene)]
 #![allow(
     clippy::many_single_char_names,
-- 
cgit v1.2.3


From 4bc3380f57e6ce1c7766df0d6b720371b216490d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 2 Sep 2019 17:44:23 +0200
Subject: Get rid of EntryPoint magic

---
 dhall_proc_macros/src/lib.rs    |   1 +
 dhall_proc_macros/src/parser.rs | 156 ++++++++--------------------------------
 dhall_syntax/src/parser.rs      |  91 ++++++++++++-----------
 3 files changed, 80 insertions(+), 168 deletions(-)

diff --git a/dhall_proc_macros/src/lib.rs b/dhall_proc_macros/src/lib.rs
index 92cf981..3e41254 100644
--- a/dhall_proc_macros/src/lib.rs
+++ b/dhall_proc_macros/src/lib.rs
@@ -1,3 +1,4 @@
+#![feature(drain_filter)]
 //! This crate contains the code-generation primitives for the [dhall-rust][dhall-rust] crate.
 //! This is highly unstable and breaks regularly; use at your own risk.
 //!
diff --git a/dhall_proc_macros/src/parser.rs b/dhall_proc_macros/src/parser.rs
index f2efb80..5d03cf5 100644
--- a/dhall_proc_macros/src/parser.rs
+++ b/dhall_proc_macros/src/parser.rs
@@ -5,7 +5,7 @@ use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
 use syn::{
     braced, bracketed, parenthesized, parse_quote, token, Error, Expr, Ident,
-    ItemFn, Pat, ReturnType, Token, Type,
+    ItemFn, Pat, ReturnType, Token,
 };
 
 mod rule_kw {
@@ -20,21 +20,7 @@ struct Rules(Vec<Rule>);
 
 #[derive(Debug, Clone)]
 struct Rule {
-    name: Ident,
-    output_type: Type,
-    contents: RuleContents,
-}
-
-#[derive(Debug, Clone)]
-enum RuleContents {
-    PrecClimb {
-        child_rule: Ident,
-        climber: Expr,
-        function: ItemFn,
-    },
-    Function {
-        function: ItemFn,
-    },
+    function: ItemFn,
 }
 
 #[derive(Debug, Clone)]
@@ -72,16 +58,11 @@ impl Parse for Rules {
 
 impl Parse for Rule {
     fn parse(input: ParseStream) -> Result<Self> {
-        let function: ItemFn = input.parse()?;
-        let (recognized_attrs, remaining_attrs) = function
+        let mut function: ItemFn = input.parse()?;
+        let recognized_attrs: Vec<_> = function
             .attrs
-            .iter()
-            .cloned()
-            .partition::<Vec<_>, _>(|attr| attr.path.is_ident("prec_climb"));
-        let function = ItemFn {
-            attrs: remaining_attrs,
-            ..(function.clone())
-        };
+            .drain_filter(|attr| attr.path.is_ident("prec_climb"))
+            .collect();
 
         let name = function.sig.ident.clone();
         let output_type = match &function.sig.output {
@@ -90,11 +71,7 @@ impl Parse for Rule {
         };
 
         if recognized_attrs.is_empty() {
-            Ok(Rule {
-                name,
-                output_type,
-                contents: RuleContents::Function { function },
-            })
+            Ok(Rule { function })
         } else if recognized_attrs.len() != 1 {
             Err(input.error("expected a prec_climb attribute"))
         } else {
@@ -107,15 +84,24 @@ impl Parse for Rule {
                     Ok((child_rule, climber))
                 })?;
 
-            Ok(Rule {
-                name,
-                output_type,
-                contents: RuleContents::PrecClimb {
-                    child_rule,
-                    climber,
-                    function,
-                },
-            })
+            let function = parse_quote!(
+                fn #name<'a>(
+                    input: ParseInput<'a, Rule>,
+                ) -> #output_type {
+                    #[allow(non_snake_case, dead_code)]
+                    #function
+
+                    #climber.climb(
+                        input.pair.clone().into_inner(),
+                        |p| Parsers::#child_rule(input.with_pair(p)),
+                        |l, op, r| {
+                            #name(input.clone(), l?, op, r?)
+                        },
+                    )
+                }
+            );
+
+            Ok(Rule { function })
         }
     }
 }
@@ -169,86 +155,13 @@ impl Parse for ParseChildrenInput {
     }
 }
 
-fn make_construct_precclimbers(rules: &Rules) -> Result<TokenStream> {
-    let mut entries: Vec<TokenStream> = Vec::new();
-    for rule in &rules.0 {
-        if let RuleContents::PrecClimb { climber, .. } = &rule.contents {
-            let name = &rule.name;
-            entries.push(quote!(
-                map.insert(Rule::#name, #climber);
-            ))
-        }
-    }
-
-    Ok(quote!(
-        fn construct_precclimbers() -> HashMap<Rule, PrecClimber<Rule>> {
-            let mut map = HashMap::new();
-            #(#entries)*
-            map
-        }
-    ))
-}
-
-fn make_entrypoints(rules: &Rules) -> Result<TokenStream> {
-    let mut entries: Vec<TokenStream> = Vec::new();
-    for rule in &rules.0 {
-        let name = &rule.name;
-        let output_type = &rule.output_type;
-        entries.push(quote!(
-            #[allow(non_snake_case, dead_code)]
-            fn #name<'a>(
-                input_str: &str,
-                pair: Pair<'a, Rule>,
-            ) -> #output_type {
-                let climbers = construct_precclimbers();
-                let input = ParseInput {
-                    climbers: &climbers,
-                    original_input_str: input_str.to_string().into(),
-                    pair
-                };
-                Parsers::#name(input)
-            }
-        ))
-    }
-
-    Ok(quote!(
-        struct EntryPoint;
-        impl EntryPoint {
-            #(#entries)*
-        }
-    ))
-}
-
 fn make_parsers(rules: &Rules) -> Result<TokenStream> {
     let entries = rules.0.iter().map(|rule| {
-        let name = &rule.name;
-        let output_type = &rule.output_type;
-        match &rule.contents {
-            RuleContents::PrecClimb {
-                child_rule,
-                function,
-                ..
-            } => quote!(
-                #[allow(non_snake_case, dead_code)]
-                fn #name<'a, 'climbers>(
-                    input: ParseInput<'a, 'climbers, Rule>,
-                ) -> #output_type {
-                    #function
-                    let climber = input.climbers.get(&Rule::#name).unwrap();
-                    climber.climb(
-                        input.pair.clone().into_inner(),
-                        |p| Parsers::#child_rule(input.with_pair(p)),
-                        |l, op, r| {
-                            #name(input.clone(), l?, op, r?)
-                        },
-                    )
-                }
-            ),
-            RuleContents::Function { function } => quote!(
-                #[allow(non_snake_case, dead_code)]
-                #function
-            ),
-        }
+        let function = &rule.function;
+        quote!(
+            #[allow(non_snake_case, dead_code)]
+            #function
+        )
     });
 
     Ok(quote!(
@@ -263,16 +176,9 @@ pub fn make_parser(
     input: proc_macro::TokenStream,
 ) -> Result<proc_macro2::TokenStream> {
     let rules: Rules = syn::parse(input.clone())?;
-
-    let construct_precclimbers = make_construct_precclimbers(&rules)?;
-    let entrypoints = make_entrypoints(&rules)?;
     let parsers = make_parsers(&rules)?;
 
-    Ok(quote!(
-        #construct_precclimbers
-        #entrypoints
-        #parsers
-    ))
+    Ok(quote!( #parsers ))
 }
 
 fn make_parser_branch(branch: &ChildrenBranch) -> Result<TokenStream> {
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 2864a97..5ed524d 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -4,7 +4,6 @@ use pest::prec_climber as pcl;
 use pest::prec_climber::PrecClimber;
 use pest::Parser;
 use std::borrow::Cow;
-use std::collections::HashMap;
 use std::rc::Rc;
 
 use dhall_generated_parser::{DhallParser, Rule};
@@ -29,16 +28,15 @@ pub type ParseError = pest::error::Error<Rule>;
 pub type ParseResult<T> = Result<T, ParseError>;
 
 #[derive(Debug, Clone)]
-struct ParseInput<'input, 'climbers, Rule>
+struct ParseInput<'input, Rule>
 where
     Rule: std::fmt::Debug + Copy + std::hash::Hash + Ord,
 {
     pair: Pair<'input, Rule>,
-    climbers: &'climbers HashMap<Rule, PrecClimber<Rule>>,
     original_input_str: Rc<str>,
 }
 
-impl<'input, 'climbers> ParseInput<'input, 'climbers, Rule> {
+impl<'input> ParseInput<'input, Rule> {
     fn error(&self, message: String) -> ParseError {
         let message = format!(
             "{} while matching on:\n{}",
@@ -48,10 +46,19 @@ impl<'input, 'climbers> ParseInput<'input, 'climbers, Rule> {
         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,
-            climbers: self.climbers,
             original_input_str: self.original_input_str.clone(),
         }
     }
@@ -189,30 +196,32 @@ fn trim_indent(lines: &mut Vec<ParsedText>) {
     }
 }
 
-fn make_precclimber() -> PrecClimber<Rule> {
-    use Rule::*;
-    // In order of precedence
-    let operators = vec![
-        import_alt,
-        bool_or,
-        natural_plus,
-        text_append,
-        list_append,
-        bool_and,
-        combine,
-        prefer,
-        combine_types,
-        natural_times,
-        bool_eq,
-        bool_ne,
-        equivalent,
-    ];
-    PrecClimber::new(
-        operators
-            .into_iter()
-            .map(|op| pcl::Operator::new(op, pcl::Assoc::Left))
-            .collect(),
-    )
+lazy_static::lazy_static! {
+    static ref PRECCLIMBER: PrecClimber<Rule> = {
+        use Rule::*;
+        // In order of precedence
+        let operators = vec![
+            import_alt,
+            bool_or,
+            natural_plus,
+            text_append,
+            list_append,
+            bool_and,
+            combine,
+            prefer,
+            combine_types,
+            natural_times,
+            bool_eq,
+            bool_ne,
+            equivalent,
+        ];
+        PrecClimber::new(
+            operators
+                .into_iter()
+                .map(|op| pcl::Operator::new(op, pcl::Assoc::Left))
+                .collect(),
+        )
+    };
 }
 
 #[make_parser]
@@ -330,7 +339,7 @@ impl _ {
         })
     }
     fn double_quote_char<'a>(
-        input: ParseInput<'a, '_, Rule>,
+        input: ParseInput<'a, Rule>,
     ) -> ParseResult<&'a str> {
         Ok(input.as_str())
     }
@@ -359,17 +368,15 @@ impl _ {
         ))
     }
     fn single_quote_char<'a>(
-        input: ParseInput<'a, '_, Rule>,
+        input: ParseInput<'a, Rule>,
     ) -> ParseResult<&'a str> {
         Ok(input.as_str())
     }
-    fn escaped_quote_pair<'a>(
-        _: ParseInput<'a, '_, Rule>,
-    ) -> ParseResult<&'a str> {
+    fn escaped_quote_pair<'a>(_: ParseInput<'a, Rule>) -> ParseResult<&'a str> {
         Ok("''")
     }
     fn escaped_interpolation<'a>(
-        _: ParseInput<'a, '_, Rule>,
+        _: ParseInput<'a, Rule>,
     ) -> ParseResult<&'a str> {
         Ok("${")
     }
@@ -514,12 +521,12 @@ impl _ {
     }
 
     fn unquoted_path_component<'a>(
-        input: ParseInput<'a, '_, Rule>,
+        input: ParseInput<'a, Rule>,
     ) -> ParseResult<&'a str> {
         Ok(input.as_str())
     }
     fn quoted_path_component<'a>(
-        input: ParseInput<'a, '_, Rule>,
+        input: ParseInput<'a, Rule>,
     ) -> ParseResult<&'a str> {
         Ok(input.as_str())
     }
@@ -662,7 +669,7 @@ impl _ {
         ))
     }
     fn posix_environment_variable_character<'a>(
-        input: ParseInput<'a, '_, Rule>,
+        input: ParseInput<'a, Rule>,
     ) -> ParseResult<Cow<'a, str>> {
         Ok(match input.as_str() {
             "\\\"" => Cow::Owned("\"".to_owned()),
@@ -847,7 +854,7 @@ impl _ {
         Ok(())
     }
 
-    #[prec_climb(application_expression, make_precclimber())]
+    #[prec_climb(application_expression, PRECCLIMBER)]
     fn operator_expression(
         input: ParseInput<Rule>,
         l: ParsedExpr,
@@ -1076,8 +1083,6 @@ impl _ {
 }
 
 pub fn parse_expr(s: &str) -> ParseResult<ParsedExpr> {
-    let mut pairs = DhallParser::parse(Rule::final_expression, s)?;
-    let expr = EntryPoint::final_expression(s, pairs.next().unwrap())?;
-    assert_eq!(pairs.next(), None);
-    Ok(expr)
+    let input = ParseInput::parse(s, Rule::final_expression)?;
+    Parsers::final_expression(input)
 }
-- 
cgit v1.2.3


From 49f142e3cd173549b8d63883380b5e780c9fefb1 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 2 Sep 2019 18:12:14 +0200
Subject: Properly parse the argument of make_parser as an impl

---
 dhall_proc_macros/src/parser.rs | 161 ++++++++++++++++------------------------
 dhall_syntax/src/parser.rs      |   4 +-
 2 files changed, 65 insertions(+), 100 deletions(-)

diff --git a/dhall_proc_macros/src/parser.rs b/dhall_proc_macros/src/parser.rs
index 5d03cf5..d775ca8 100644
--- a/dhall_proc_macros/src/parser.rs
+++ b/dhall_proc_macros/src/parser.rs
@@ -4,25 +4,10 @@ use syn::parse::{Parse, ParseStream, Result};
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
 use syn::{
-    braced, bracketed, parenthesized, parse_quote, token, Error, Expr, Ident,
-    ItemFn, Pat, ReturnType, Token,
+    bracketed, parenthesized, parse_quote, token, Error, Expr, Ident, ImplItem,
+    ImplItemMethod, ItemImpl, Pat, ReturnType, Token,
 };
 
-mod rule_kw {
-    syn::custom_keyword!(rule);
-    syn::custom_keyword!(captured_str);
-    syn::custom_keyword!(children);
-    syn::custom_keyword!(prec_climb);
-}
-
-#[derive(Debug, Clone)]
-struct Rules(Vec<Rule>);
-
-#[derive(Debug, Clone)]
-struct Rule {
-    function: ItemFn,
-}
-
 #[derive(Debug, Clone)]
 struct ChildrenBranch {
     pattern_span: Span,
@@ -42,70 +27,6 @@ struct ParseChildrenInput {
     branches: Punctuated<ChildrenBranch, Token![,]>,
 }
 
-impl Parse for Rules {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let _: Token![impl ] = input.parse()?;
-        let _: Token![_] = input.parse()?;
-        let contents;
-        braced!(contents in input);
-        let mut rules = Vec::new();
-        while !contents.is_empty() {
-            rules.push(contents.parse()?)
-        }
-        Ok(Rules(rules))
-    }
-}
-
-impl Parse for Rule {
-    fn parse(input: ParseStream) -> Result<Self> {
-        let mut function: ItemFn = input.parse()?;
-        let recognized_attrs: Vec<_> = function
-            .attrs
-            .drain_filter(|attr| attr.path.is_ident("prec_climb"))
-            .collect();
-
-        let name = function.sig.ident.clone();
-        let output_type = match &function.sig.output {
-            ReturnType::Default => parse_quote!(()),
-            ReturnType::Type(_, t) => (**t).clone(),
-        };
-
-        if recognized_attrs.is_empty() {
-            Ok(Rule { function })
-        } else if recognized_attrs.len() != 1 {
-            Err(input.error("expected a prec_climb attribute"))
-        } else {
-            let attr = recognized_attrs.into_iter().next().unwrap();
-            let (child_rule, climber) =
-                attr.parse_args_with(|input: ParseStream| {
-                    let child_rule: Ident = input.parse()?;
-                    let _: Token![,] = input.parse()?;
-                    let climber: Expr = input.parse()?;
-                    Ok((child_rule, climber))
-                })?;
-
-            let function = parse_quote!(
-                fn #name<'a>(
-                    input: ParseInput<'a, Rule>,
-                ) -> #output_type {
-                    #[allow(non_snake_case, dead_code)]
-                    #function
-
-                    #climber.climb(
-                        input.pair.clone().into_inner(),
-                        |p| Parsers::#child_rule(input.with_pair(p)),
-                        |l, op, r| {
-                            #name(input.clone(), l?, op, r?)
-                        },
-                    )
-                }
-            );
-
-            Ok(Rule { function })
-        }
-    }
-}
-
 impl Parse for ChildrenBranch {
     fn parse(input: ParseStream) -> Result<Self> {
         let contents;
@@ -155,30 +76,72 @@ impl Parse for ParseChildrenInput {
     }
 }
 
-fn make_parsers(rules: &Rules) -> Result<TokenStream> {
-    let entries = rules.0.iter().map(|rule| {
-        let function = &rule.function;
-        quote!(
-            #[allow(non_snake_case, dead_code)]
-            #function
-        )
-    });
+fn apply_special_attrs(function: &mut ImplItemMethod) -> Result<()> {
+    let recognized_attrs: Vec<_> = function
+        .attrs
+        .drain_filter(|attr| attr.path.is_ident("prec_climb"))
+        .collect();
 
-    Ok(quote!(
-        struct Parsers;
-        impl Parsers {
-            #(#entries)*
-        }
-    ))
+    let name = function.sig.ident.clone();
+    let output_type = match &function.sig.output {
+        ReturnType::Default => parse_quote!(()),
+        ReturnType::Type(_, t) => (**t).clone(),
+    };
+
+    if recognized_attrs.is_empty() {
+    } else if recognized_attrs.len() > 1 {
+        return Err(Error::new(
+            recognized_attrs[1].span(),
+            "expected a single prec_climb attribute",
+        ));
+    } else {
+        let attr = recognized_attrs.into_iter().next().unwrap();
+        let (child_rule, climber) =
+            attr.parse_args_with(|input: ParseStream| {
+                let child_rule: Ident = input.parse()?;
+                let _: Token![,] = input.parse()?;
+                let climber: Expr = input.parse()?;
+                Ok((child_rule, climber))
+            })?;
+
+        *function = parse_quote!(
+            fn #name<'a>(
+                input: ParseInput<'a, Rule>,
+            ) -> #output_type {
+                #[allow(non_snake_case, dead_code)]
+                #function
+
+                #climber.climb(
+                    input.pair.clone().into_inner(),
+                    |p| Parsers::#child_rule(input.with_pair(p)),
+                    |l, op, r| {
+                        #name(input.clone(), l?, op, r?)
+                    },
+                )
+            }
+        );
+    }
+
+    *function = parse_quote!(
+        #[allow(non_snake_case, dead_code)]
+        #function
+    );
+
+    Ok(())
 }
 
 pub fn make_parser(
     input: proc_macro::TokenStream,
 ) -> Result<proc_macro2::TokenStream> {
-    let rules: Rules = syn::parse(input.clone())?;
-    let parsers = make_parsers(&rules)?;
-
-    Ok(quote!( #parsers ))
+    let mut imp: ItemImpl = syn::parse(input)?;
+    imp.items
+        .iter_mut()
+        .map(|item| match item {
+            ImplItem::Method(m) => apply_special_attrs(m),
+            _ => Ok(()),
+        })
+        .collect::<Result<()>>()?;
+    Ok(quote!( #imp ))
 }
 
 fn make_parser_branch(branch: &ChildrenBranch) -> Result<TokenStream> {
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 5ed524d..fac6ecc 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -224,8 +224,10 @@ lazy_static::lazy_static! {
     };
 }
 
+struct Parsers;
+
 #[make_parser]
-impl _ {
+impl Parsers {
     fn EOI(_: ParseInput<Rule>) -> ParseResult<()> {
         Ok(())
     }
-- 
cgit v1.2.3


From 41f598a75de41665dd9ec0aad56b5ef526698151 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 2 Sep 2019 18:46:53 +0200
Subject: Use proper hygiene for `Parsers` and `Rule`

---
 dhall_proc_macros/src/lib.rs    |  4 ++--
 dhall_proc_macros/src/parser.rs | 49 ++++++++++++++++++++++++++++-------------
 dhall_syntax/src/lib.rs         |  1 +
 dhall_syntax/src/parser.rs      |  9 ++++++--
 4 files changed, 44 insertions(+), 19 deletions(-)

diff --git a/dhall_proc_macros/src/lib.rs b/dhall_proc_macros/src/lib.rs
index 3e41254..63dd29a 100644
--- a/dhall_proc_macros/src/lib.rs
+++ b/dhall_proc_macros/src/lib.rs
@@ -17,8 +17,8 @@ pub fn derive_static_type(input: TokenStream) -> TokenStream {
 }
 
 #[proc_macro_attribute]
-pub fn make_parser(_attr: TokenStream, input: TokenStream) -> TokenStream {
-    TokenStream::from(match parser::make_parser(input) {
+pub fn make_parser(attrs: TokenStream, input: TokenStream) -> TokenStream {
+    TokenStream::from(match parser::make_parser(attrs, input) {
         Ok(tokens) => tokens,
         Err(err) => err.to_compile_error(),
     })
diff --git a/dhall_proc_macros/src/parser.rs b/dhall_proc_macros/src/parser.rs
index d775ca8..a440b16 100644
--- a/dhall_proc_macros/src/parser.rs
+++ b/dhall_proc_macros/src/parser.rs
@@ -76,7 +76,10 @@ impl Parse for ParseChildrenInput {
     }
 }
 
-fn apply_special_attrs(function: &mut ImplItemMethod) -> Result<()> {
+fn apply_special_attrs(
+    rule_enum: &Ident,
+    function: &mut ImplItemMethod,
+) -> Result<()> {
     let recognized_attrs: Vec<_> = function
         .attrs
         .drain_filter(|attr| attr.path.is_ident("prec_climb"))
@@ -106,14 +109,14 @@ fn apply_special_attrs(function: &mut ImplItemMethod) -> Result<()> {
 
         *function = parse_quote!(
             fn #name<'a>(
-                input: ParseInput<'a, Rule>,
+                input: ParseInput<'a, #rule_enum>,
             ) -> #output_type {
                 #[allow(non_snake_case, dead_code)]
                 #function
 
                 #climber.climb(
                     input.pair.clone().into_inner(),
-                    |p| Parsers::#child_rule(input.with_pair(p)),
+                    |p| Self::#child_rule(input.with_pair(p)),
                     |l, op, r| {
                         #name(input.clone(), l?, op, r?)
                     },
@@ -131,17 +134,29 @@ fn apply_special_attrs(function: &mut ImplItemMethod) -> Result<()> {
 }
 
 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)?;
     imp.items
         .iter_mut()
         .map(|item| match item {
-            ImplItem::Method(m) => apply_special_attrs(m),
+            ImplItem::Method(m) => apply_special_attrs(&rule_enum, m),
             _ => Ok(()),
         })
         .collect::<Result<()>>()?;
-    Ok(quote!( #imp ))
+
+    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 RuleEnum = #rule_enum;
+        }
+
+        #imp
+    ))
 }
 
 fn make_parser_branch(branch: &ChildrenBranch) -> Result<TokenStream> {
@@ -156,18 +171,22 @@ fn make_parser_branch(branch: &ChildrenBranch) -> Result<TokenStream> {
     let variable_pattern_ident =
         Ident::new("variable_pattern", Span::call_site());
     let match_pat = branch.pattern.iter().map(|item| match item {
-        Single { rule_name, .. } => quote!(Rule::#rule_name),
+        Single { rule_name, .. } => {
+            quote!(<<Self as PestConsumer>::RuleEnum>::#rule_name)
+        }
         Multiple { .. } => quote!(#variable_pattern_ident..),
     });
     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 without the
-                // bind_by_move_pattern_guards feature.
-                fn all_match(slice: &[Rule]) -> bool {
-                    slice.iter().all(|r| r == &Rule::#rule_name)
-                }
+                // 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 == &<<Self as PestConsumer>::RuleEnum>::#rule_name
+                    )
+                };
                 all_match(#variable_pattern_ident)
             } &&
         ),
@@ -205,7 +224,7 @@ fn make_parser_branch(branch: &ChildrenBranch) -> Result<TokenStream> {
     let mut parses = Vec::new();
     for (rule_name, binder) in singles_before_multiple.into_iter() {
         parses.push(quote!(
-            let #binder = Parsers::#rule_name(
+            let #binder = Self::#rule_name(
                 inputs.next().unwrap()
             )?;
         ))
@@ -214,7 +233,7 @@ fn make_parser_branch(branch: &ChildrenBranch) -> Result<TokenStream> {
     // 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 = Parsers::#rule_name(
+            let #binder = Self::#rule_name(
                 inputs.next_back().unwrap()
             )?;
         ))
@@ -222,7 +241,7 @@ fn make_parser_branch(branch: &ChildrenBranch) -> Result<TokenStream> {
     if let Some((rule_name, binder)) = multiple {
         parses.push(quote!(
             let #binder = inputs
-                .map(|i| Parsers::#rule_name(i))
+                .map(|i| Self::#rule_name(i))
                 .collect::<Result<Vec<_>, _>>()?
                 .into_iter();
         ))
@@ -248,7 +267,7 @@ pub fn parse_children(
         .map(make_parser_branch)
         .collect::<Result<Vec<_>>>()?;
     Ok(quote!({
-        let children_rules: Vec<Rule> = #input_expr.pair
+        let children_rules: Vec<_> = #input_expr.pair
             .clone()
             .into_inner()
             .map(|p| p.as_rule())
diff --git a/dhall_syntax/src/lib.rs b/dhall_syntax/src/lib.rs
index fb12af4..1636c8b 100644
--- a/dhall_syntax/src/lib.rs
+++ b/dhall_syntax/src/lib.rs
@@ -3,6 +3,7 @@
 #![feature(try_blocks)]
 #![feature(never_type)]
 #![feature(proc_macro_hygiene)]
+#![feature(type_alias_enum_variants)]
 #![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 fac6ecc..b1e429b 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -30,7 +30,7 @@ pub type ParseResult<T> = Result<T, ParseError>;
 #[derive(Debug, Clone)]
 struct ParseInput<'input, Rule>
 where
-    Rule: std::fmt::Debug + Copy + std::hash::Hash + Ord,
+    Rule: pest::RuleType,
 {
     pair: Pair<'input, Rule>,
     original_input_str: Rc<str>,
@@ -70,6 +70,11 @@ impl<'input> ParseInput<'input, Rule> {
     }
 }
 
+// Used to retrieve the `Rule` enum associated with the `Self` type in `parse_children`.
+trait PestConsumer {
+    type RuleEnum: pest::RuleType;
+}
+
 fn debug_pair(pair: Pair<Rule>) -> String {
     use std::fmt::Write;
     let mut s = String::new();
@@ -226,7 +231,7 @@ lazy_static::lazy_static! {
 
 struct Parsers;
 
-#[make_parser]
+#[make_parser(Rule)]
 impl Parsers {
     fn EOI(_: ParseInput<Rule>) -> ParseResult<()> {
         Ok(())
-- 
cgit v1.2.3


From 97d74f514bd8c5c4b96fb4f4071f4a93ac28572d Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 2 Sep 2019 18:59:30 +0200
Subject: Separate both parser proc_macros into their own files

---
 dhall_proc_macros/src/lib.rs            |   7 +-
 dhall_proc_macros/src/make_parser.rs    |  90 ++++++++++
 dhall_proc_macros/src/parse_children.rs | 205 ++++++++++++++++++++++
 dhall_proc_macros/src/parser.rs         | 291 --------------------------------
 4 files changed, 299 insertions(+), 294 deletions(-)
 create mode 100644 dhall_proc_macros/src/make_parser.rs
 create mode 100644 dhall_proc_macros/src/parse_children.rs
 delete mode 100644 dhall_proc_macros/src/parser.rs

diff --git a/dhall_proc_macros/src/lib.rs b/dhall_proc_macros/src/lib.rs
index 63dd29a..37e8f9f 100644
--- a/dhall_proc_macros/src/lib.rs
+++ b/dhall_proc_macros/src/lib.rs
@@ -7,7 +7,8 @@
 extern crate proc_macro;
 
 mod derive;
-mod parser;
+mod make_parser;
+mod parse_children;
 
 use proc_macro::TokenStream;
 
@@ -18,7 +19,7 @@ pub fn derive_static_type(input: TokenStream) -> TokenStream {
 
 #[proc_macro_attribute]
 pub fn make_parser(attrs: TokenStream, input: TokenStream) -> TokenStream {
-    TokenStream::from(match parser::make_parser(attrs, input) {
+    TokenStream::from(match make_parser::make_parser(attrs, input) {
         Ok(tokens) => tokens,
         Err(err) => err.to_compile_error(),
     })
@@ -26,7 +27,7 @@ pub fn make_parser(attrs: TokenStream, input: TokenStream) -> TokenStream {
 
 #[proc_macro]
 pub fn parse_children(input: TokenStream) -> TokenStream {
-    TokenStream::from(match parser::parse_children(input) {
+    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
new file mode 100644
index 0000000..63ce779
--- /dev/null
+++ b/dhall_proc_macros/src/make_parser.rs
@@ -0,0 +1,90 @@
+use quote::quote;
+use syn::parse::{ParseStream, Result};
+use syn::spanned::Spanned;
+use syn::{
+    parse_quote, Error, Expr, Ident, ImplItem, ImplItemMethod, ItemImpl,
+    ReturnType, Token,
+};
+
+fn apply_special_attrs(
+    rule_enum: &Ident,
+    function: &mut ImplItemMethod,
+) -> Result<()> {
+    let recognized_attrs: Vec<_> = function
+        .attrs
+        .drain_filter(|attr| attr.path.is_ident("prec_climb"))
+        .collect();
+
+    let name = function.sig.ident.clone();
+    let output_type = match &function.sig.output {
+        ReturnType::Default => parse_quote!(()),
+        ReturnType::Type(_, t) => (**t).clone(),
+    };
+
+    if recognized_attrs.is_empty() {
+    } else if recognized_attrs.len() > 1 {
+        return Err(Error::new(
+            recognized_attrs[1].span(),
+            "expected a single prec_climb attribute",
+        ));
+    } else {
+        let attr = recognized_attrs.into_iter().next().unwrap();
+        let (child_rule, climber) =
+            attr.parse_args_with(|input: ParseStream| {
+                let child_rule: Ident = input.parse()?;
+                let _: Token![,] = input.parse()?;
+                let climber: Expr = input.parse()?;
+                Ok((child_rule, climber))
+            })?;
+
+        *function = parse_quote!(
+            fn #name<'a>(
+                input: ParseInput<'a, #rule_enum>,
+            ) -> #output_type {
+                #[allow(non_snake_case, dead_code)]
+                #function
+
+                #climber.climb(
+                    input.pair.clone().into_inner(),
+                    |p| Self::#child_rule(input.with_pair(p)),
+                    |l, op, r| {
+                        #name(input.clone(), l?, op, r?)
+                    },
+                )
+            }
+        );
+    }
+
+    *function = parse_quote!(
+        #[allow(non_snake_case, dead_code)]
+        #function
+    );
+
+    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)?;
+    imp.items
+        .iter_mut()
+        .map(|item| match item {
+            ImplItem::Method(m) => apply_special_attrs(&rule_enum, m),
+            _ => Ok(()),
+        })
+        .collect::<Result<()>>()?;
+
+    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 RuleEnum = #rule_enum;
+        }
+
+        #imp
+    ))
+}
diff --git a/dhall_proc_macros/src/parse_children.rs b/dhall_proc_macros/src/parse_children.rs
new file mode 100644
index 0000000..ce6f66c
--- /dev/null
+++ b/dhall_proc_macros/src/parse_children.rs
@@ -0,0 +1,205 @@
+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) -> 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 variable_pattern_ident =
+        Ident::new("variable_pattern", Span::call_site());
+    let match_pat = branch.pattern.iter().map(|item| match item {
+        Single { rule_name, .. } => {
+            quote!(<<Self as PestConsumer>::RuleEnum>::#rule_name)
+        }
+        Multiple { .. } => quote!(#variable_pattern_ident..),
+    });
+    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 == &<<Self as PestConsumer>::RuleEnum>::#rule_name
+                    )
+                };
+                all_match(#variable_pattern_ident)
+            } &&
+        ),
+    });
+
+    // 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(
+                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(
+                inputs.next_back().unwrap()
+            )?;
+        ))
+    }
+    if let Some((rule_name, binder)) = multiple {
+        parses.push(quote!(
+            let #binder = 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 input_expr = &input.input_expr;
+    let branches = input
+        .branches
+        .iter()
+        .map(make_parser_branch)
+        .collect::<Result<Vec<_>>>()?;
+    Ok(quote!({
+        let children_rules: Vec<_> = #input_expr.pair
+            .clone()
+            .into_inner()
+            .map(|p| p.as_rule())
+            .collect();
+
+        #[allow(unused_mut)]
+        let mut inputs = #input_expr
+            .pair
+            .clone()
+            .into_inner()
+            .map(|p| #input_expr.with_pair(p));
+
+        #[allow(unreachable_code)]
+        match children_rules.as_slice() {
+            #(#branches,)*
+            [..] => return Err(#input_expr.error(
+                format!("Unexpected children: {:?}", children_rules)
+            )),
+        }
+    }))
+}
diff --git a/dhall_proc_macros/src/parser.rs b/dhall_proc_macros/src/parser.rs
deleted file mode 100644
index a440b16..0000000
--- a/dhall_proc_macros/src/parser.rs
+++ /dev/null
@@ -1,291 +0,0 @@
-use proc_macro2::{Span, TokenStream};
-use quote::quote;
-use syn::parse::{Parse, ParseStream, Result};
-use syn::punctuated::Punctuated;
-use syn::spanned::Spanned;
-use syn::{
-    bracketed, parenthesized, parse_quote, token, Error, Expr, Ident, ImplItem,
-    ImplItemMethod, ItemImpl, Pat, ReturnType, 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 apply_special_attrs(
-    rule_enum: &Ident,
-    function: &mut ImplItemMethod,
-) -> Result<()> {
-    let recognized_attrs: Vec<_> = function
-        .attrs
-        .drain_filter(|attr| attr.path.is_ident("prec_climb"))
-        .collect();
-
-    let name = function.sig.ident.clone();
-    let output_type = match &function.sig.output {
-        ReturnType::Default => parse_quote!(()),
-        ReturnType::Type(_, t) => (**t).clone(),
-    };
-
-    if recognized_attrs.is_empty() {
-    } else if recognized_attrs.len() > 1 {
-        return Err(Error::new(
-            recognized_attrs[1].span(),
-            "expected a single prec_climb attribute",
-        ));
-    } else {
-        let attr = recognized_attrs.into_iter().next().unwrap();
-        let (child_rule, climber) =
-            attr.parse_args_with(|input: ParseStream| {
-                let child_rule: Ident = input.parse()?;
-                let _: Token![,] = input.parse()?;
-                let climber: Expr = input.parse()?;
-                Ok((child_rule, climber))
-            })?;
-
-        *function = parse_quote!(
-            fn #name<'a>(
-                input: ParseInput<'a, #rule_enum>,
-            ) -> #output_type {
-                #[allow(non_snake_case, dead_code)]
-                #function
-
-                #climber.climb(
-                    input.pair.clone().into_inner(),
-                    |p| Self::#child_rule(input.with_pair(p)),
-                    |l, op, r| {
-                        #name(input.clone(), l?, op, r?)
-                    },
-                )
-            }
-        );
-    }
-
-    *function = parse_quote!(
-        #[allow(non_snake_case, dead_code)]
-        #function
-    );
-
-    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)?;
-    imp.items
-        .iter_mut()
-        .map(|item| match item {
-            ImplItem::Method(m) => apply_special_attrs(&rule_enum, m),
-            _ => Ok(()),
-        })
-        .collect::<Result<()>>()?;
-
-    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 RuleEnum = #rule_enum;
-        }
-
-        #imp
-    ))
-}
-
-fn make_parser_branch(branch: &ChildrenBranch) -> 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 variable_pattern_ident =
-        Ident::new("variable_pattern", Span::call_site());
-    let match_pat = branch.pattern.iter().map(|item| match item {
-        Single { rule_name, .. } => {
-            quote!(<<Self as PestConsumer>::RuleEnum>::#rule_name)
-        }
-        Multiple { .. } => quote!(#variable_pattern_ident..),
-    });
-    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 == &<<Self as PestConsumer>::RuleEnum>::#rule_name
-                    )
-                };
-                all_match(#variable_pattern_ident)
-            } &&
-        ),
-    });
-
-    // 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(
-                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(
-                inputs.next_back().unwrap()
-            )?;
-        ))
-    }
-    if let Some((rule_name, binder)) = multiple {
-        parses.push(quote!(
-            let #binder = 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 input_expr = &input.input_expr;
-    let branches = input
-        .branches
-        .iter()
-        .map(make_parser_branch)
-        .collect::<Result<Vec<_>>>()?;
-    Ok(quote!({
-        let children_rules: Vec<_> = #input_expr.pair
-            .clone()
-            .into_inner()
-            .map(|p| p.as_rule())
-            .collect();
-
-        #[allow(unused_mut)]
-        let mut inputs = #input_expr
-            .pair
-            .clone()
-            .into_inner()
-            .map(|p| #input_expr.with_pair(p));
-
-        #[allow(unreachable_code)]
-        match children_rules.as_slice() {
-            #(#branches,)*
-            [..] => return Err(#input_expr.error(
-                format!("Unexpected children: {:?}", children_rules)
-            )),
-        }
-    }))
-}
-- 
cgit v1.2.3


From 0c746c4e5dc3c490071e9dccdf089e33ce3ea7bf Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 2 Sep 2019 22:03:47 +0200
Subject: We don't use the try_blocks feature anymore

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

diff --git a/dhall_syntax/src/lib.rs b/dhall_syntax/src/lib.rs
index 1636c8b..7b43c6b 100644
--- a/dhall_syntax/src/lib.rs
+++ b/dhall_syntax/src/lib.rs
@@ -1,6 +1,5 @@
 #![feature(trace_macros)]
 #![feature(slice_patterns)]
-#![feature(try_blocks)]
 #![feature(never_type)]
 #![feature(proc_macro_hygiene)]
 #![feature(type_alias_enum_variants)]
-- 
cgit v1.2.3


From 5dde11c8ffb13fbaf5dbc9c2b544270c22a7d2f5 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 2 Sep 2019 22:50:16 +0200
Subject: Parse polymorphically in the Embed parameter

---
 dhall_proc_macros/src/make_parser.rs |  83 +++++++++++++--------
 dhall_syntax/src/core/expr.rs        |   9 +--
 dhall_syntax/src/parser.rs           | 140 +++++++++++++++++++----------------
 3 files changed, 130 insertions(+), 102 deletions(-)

diff --git a/dhall_proc_macros/src/make_parser.rs b/dhall_proc_macros/src/make_parser.rs
index 63ce779..268a639 100644
--- a/dhall_proc_macros/src/make_parser.rs
+++ b/dhall_proc_macros/src/make_parser.rs
@@ -2,26 +2,25 @@ use quote::quote;
 use syn::parse::{ParseStream, Result};
 use syn::spanned::Spanned;
 use syn::{
-    parse_quote, Error, Expr, Ident, ImplItem, ImplItemMethod, ItemImpl,
-    ReturnType, Token,
+    parse_quote, Error, Expr, FnArg, Ident, ImplItem, ImplItemMethod, ItemImpl,
+    Pat, Token,
 };
 
-fn apply_special_attrs(
-    rule_enum: &Ident,
-    function: &mut ImplItemMethod,
-) -> Result<()> {
+fn apply_special_attrs(function: &mut ImplItemMethod) -> Result<()> {
+    *function = parse_quote!(
+        #[allow(non_snake_case, dead_code)]
+        #function
+    );
+
     let recognized_attrs: Vec<_> = function
         .attrs
         .drain_filter(|attr| attr.path.is_ident("prec_climb"))
         .collect();
 
     let name = function.sig.ident.clone();
-    let output_type = match &function.sig.output {
-        ReturnType::Default => parse_quote!(()),
-        ReturnType::Type(_, t) => (**t).clone(),
-    };
 
     if recognized_attrs.is_empty() {
+        // do nothing
     } else if recognized_attrs.len() > 1 {
         return Err(Error::new(
             recognized_attrs[1].span(),
@@ -37,28 +36,50 @@ fn apply_special_attrs(
                 Ok((child_rule, climber))
             })?;
 
-        *function = parse_quote!(
-            fn #name<'a>(
-                input: ParseInput<'a, #rule_enum>,
-            ) -> #output_type {
-                #[allow(non_snake_case, dead_code)]
-                #function
-
-                #climber.climb(
-                    input.pair.clone().into_inner(),
-                    |p| Self::#child_rule(input.with_pair(p)),
-                    |l, op, r| {
-                        #name(input.clone(), l?, op, r?)
-                    },
-                )
+        // Get the name of the first (`input`) function argument
+        let first_arg = function.sig.inputs.first().ok_or_else(|| {
+            Error::new(
+                function.sig.inputs.span(),
+                "a prec_climb function needs 4 arguments",
+            )
+        })?;
+        let first_arg = match &first_arg {
+            FnArg::Receiver(_) => return Err(Error::new(
+                first_arg.span(),
+                "a prec_climb function should not have a `self` argument",
+            )),
+            FnArg::Typed(first_arg) =>   match &*first_arg.pat{
+                Pat::Ident(ident) => &ident.ident,
+                _ => return Err(Error::new(
+                    first_arg.span(),
+                    "this argument should be a plain identifier instead of a pattern",
+                )),
             }
-        );
-    }
+        };
 
-    *function = parse_quote!(
-        #[allow(non_snake_case, dead_code)]
-        #function
-    );
+        function.block = parse_quote!({
+            #function
+
+            #climber.climb(
+                #first_arg.pair.clone().into_inner(),
+                |p| Self::#child_rule(#first_arg.with_pair(p)),
+                |l, op, r| {
+                    #name(#first_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",
+            )
+        })?;
+    }
 
     Ok(())
 }
@@ -73,7 +94,7 @@ pub fn make_parser(
     imp.items
         .iter_mut()
         .map(|item| match item {
-            ImplItem::Method(m) => apply_special_attrs(&rule_enum, m),
+            ImplItem::Method(m) => apply_special_attrs(m),
             _ => Ok(()),
         })
         .collect::<Result<()>>()?;
diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index 51b6c47..eeee4d8 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -381,15 +381,10 @@ pub fn rc<E>(x: RawExpr<E>) -> Expr<E> {
     Expr::from_expr_no_span(x)
 }
 
-pub(crate) fn spanned(
-    span: Span,
-    x: crate::parser::ParsedRawExpr,
-) -> crate::parser::ParsedExpr {
+pub(crate) fn spanned<E>(span: Span, x: RawExpr<E>) -> Expr<E> {
     Expr::new(x, span)
 }
-pub(crate) fn unspanned(
-    x: crate::parser::ParsedRawExpr,
-) -> crate::parser::ParsedExpr {
+pub(crate) fn unspanned<E>(x: RawExpr<E>) -> Expr<E> {
     Expr::from_expr_no_span(x)
 }
 
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index b1e429b..c2ba19a 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -18,10 +18,8 @@ use crate::*;
 // their own crate because they are quite general and useful. For now they
 // are here and hopefully you can figure out how they work.
 
-pub(crate) type ParsedRawExpr = RawExpr<!>;
-pub(crate) type ParsedExpr = Expr<!>;
-type ParsedText = InterpolatedText<ParsedExpr>;
-type ParsedTextContents = InterpolatedTextContents<ParsedExpr>;
+type ParsedText<E> = InterpolatedText<Expr<E>>;
+type ParsedTextContents<E> = InterpolatedTextContents<Expr<E>>;
 
 pub type ParseError = pest::error::Error<Rule>;
 
@@ -162,7 +160,7 @@ impl crate::Builtin {
 
 // Trim the shared indent off of a vec of lines, as defined by the Dhall semantics of multiline
 // literals.
-fn trim_indent(lines: &mut Vec<ParsedText>) {
+fn trim_indent<E: Clone>(lines: &mut Vec<ParsedText<E>>) {
     let is_indent = |c: char| c == ' ' || c == '\t';
 
     // There is at least one line so this is safe
@@ -250,9 +248,9 @@ impl Parsers {
         ))
     }
 
-    fn double_quote_literal(
+    fn double_quote_literal<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<ParsedText> {
+    ) -> ParseResult<ParsedText<E>> {
         Ok(parse_children!(input;
             [double_quote_chunk(chunks)..] => {
                 chunks.collect()
@@ -260,9 +258,9 @@ impl Parsers {
         ))
     }
 
-    fn double_quote_chunk(
+    fn double_quote_chunk<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<ParsedTextContents> {
+    ) -> ParseResult<ParsedTextContents<E>> {
         Ok(parse_children!(input;
             [interpolation(e)] => {
                 InterpolatedTextContents::Expr(e)
@@ -351,17 +349,17 @@ impl Parsers {
         Ok(input.as_str())
     }
 
-    fn single_quote_literal(
+    fn single_quote_literal<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<ParsedText> {
+    ) -> ParseResult<ParsedText<E>> {
         Ok(parse_children!(input;
             [single_quote_continue(lines)] => {
-                let newline: ParsedText = "\n".to_string().into();
+                let newline: ParsedText<E> = "\n".to_string().into();
 
-                let mut lines: Vec<ParsedText> = lines
+                let mut lines: Vec<ParsedText<E>> = lines
                     .into_iter()
                     .rev()
-                    .map(|l| l.into_iter().rev().collect::<ParsedText>())
+                    .map(|l| l.into_iter().rev().collect::<ParsedText<E>>())
                     .collect();
 
                 trim_indent(&mut lines);
@@ -370,7 +368,7 @@ impl Parsers {
                     .into_iter()
                     .intersperse(newline)
                     .flat_map(InterpolatedText::into_iter)
-                    .collect::<ParsedText>()
+                    .collect::<ParsedText<E>>()
             }
         ))
     }
@@ -387,16 +385,18 @@ impl Parsers {
     ) -> ParseResult<&'a str> {
         Ok("${")
     }
-    fn interpolation(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+    fn interpolation<E: Clone>(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<Expr<E>> {
         Ok(parse_children!(input;
             [expression(e)] => e
         ))
     }
 
     // Returns a vec of lines in reversed order, where each line is also in reversed order.
-    fn single_quote_continue(
+    fn single_quote_continue<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<Vec<Vec<ParsedTextContents>>> {
+    ) -> ParseResult<Vec<Vec<ParsedTextContents<E>>>> {
         Ok(parse_children!(input;
             [interpolation(c), single_quote_continue(lines)] => {
                 let c = InterpolatedTextContents::Expr(c);
@@ -435,7 +435,7 @@ impl Parsers {
         ))
     }
 
-    fn builtin(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+    fn builtin<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
         let s = input.as_str();
         let span = input.as_span();
         Ok(spanned(
@@ -506,7 +506,7 @@ impl Parsers {
             .map_err(|e| input.error(format!("{}", e)))
     }
 
-    fn identifier(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+    fn identifier<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
         let span = input.as_span();
         Ok(parse_children!(input;
             [variable(v)] => {
@@ -620,7 +620,9 @@ impl Parsers {
         })
     }
 
-    fn http_raw(input: ParseInput<Rule>) -> ParseResult<URL<ParsedExpr>> {
+    fn http_raw<E: Clone>(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<URL<Expr<E>>> {
         Ok(parse_children!(input;
             [scheme(sch), authority(auth), path(p)] => URL {
                 scheme: sch,
@@ -647,7 +649,7 @@ impl Parsers {
         Ok(input.as_str().to_owned())
     }
 
-    fn http(input: ParseInput<Rule>) -> ParseResult<URL<ParsedExpr>> {
+    fn http<E: Clone>(input: ParseInput<Rule>) -> ParseResult<URL<Expr<E>>> {
         Ok(parse_children!(input;
         [http_raw(url)] => url,
         [http_raw(url), import_expression(e)] =>
@@ -696,9 +698,9 @@ impl Parsers {
         Ok(())
     }
 
-    fn import_type(
+    fn import_type<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<ImportLocation<ParsedExpr>> {
+    ) -> ParseResult<ImportLocation<Expr<E>>> {
         Ok(parse_children!(input;
             [missing(_)] => {
                 ImportLocation::Missing
@@ -725,9 +727,9 @@ impl Parsers {
         Ok(Hash::SHA256(hex::decode(hash).unwrap()))
     }
 
-    fn import_hashed(
+    fn import_hashed<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<crate::Import<ParsedExpr>> {
+    ) -> ParseResult<crate::Import<Expr<E>>> {
         Ok(parse_children!(input;
         [import_type(location)] =>
             crate::Import {mode: ImportMode::Code, location, hash: None },
@@ -743,7 +745,7 @@ impl Parsers {
         Ok(())
     }
 
-    fn import(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+    fn import<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
         let span = input.as_span();
         Ok(parse_children!(input;
             [import_hashed(imp)] => {
@@ -792,7 +794,9 @@ impl Parsers {
         Ok(())
     }
 
-    fn empty_list_literal(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+    fn empty_list_literal<E: Clone>(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<Expr<E>> {
         let span = input.as_span();
         Ok(parse_children!(input;
             [application_expression(e)] => {
@@ -801,7 +805,7 @@ impl Parsers {
         ))
     }
 
-    fn expression(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+    fn expression<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
         let span = input.as_span();
         Ok(parse_children!(input;
             [lambda(()), label(l), expression(typ),
@@ -843,9 +847,9 @@ impl Parsers {
         ))
     }
 
-    fn let_binding(
+    fn let_binding<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<(Label, Option<ParsedExpr>, ParsedExpr)> {
+    ) -> ParseResult<(Label, Option<Expr<E>>, Expr<E>)> {
         Ok(parse_children!(input;
             [label(name), expression(annot), expression(expr)] =>
                 (name, Some(annot), expr),
@@ -862,12 +866,12 @@ impl Parsers {
     }
 
     #[prec_climb(application_expression, PRECCLIMBER)]
-    fn operator_expression(
+    fn operator_expression<E: Clone>(
         input: ParseInput<Rule>,
-        l: ParsedExpr,
+        l: Expr<E>,
         op: Pair<Rule>,
-        r: ParsedExpr,
-    ) -> ParseResult<ParsedExpr> {
+        r: Expr<E>,
+    ) -> ParseResult<Expr<E>> {
         use crate::BinOp::*;
         use Rule::*;
         let op = match op.as_rule() {
@@ -894,9 +898,9 @@ impl Parsers {
         Ok(())
     }
 
-    fn application_expression(
+    fn application_expression<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<ParsedExpr> {
+    ) -> ParseResult<Expr<E>> {
         Ok(parse_children!(input;
             [first_application_expression(e)] => e,
             [first_application_expression(first),
@@ -906,9 +910,9 @@ impl Parsers {
         ))
     }
 
-    fn first_application_expression(
+    fn first_application_expression<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<ParsedExpr> {
+    ) -> ParseResult<Expr<E>> {
         let span = input.as_span();
         Ok(parse_children!(input;
             [Some_(()), import_expression(e)] => {
@@ -924,14 +928,18 @@ impl Parsers {
         ))
     }
 
-    fn import_expression(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+    fn import_expression<E: Clone>(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<Expr<E>> {
         Ok(parse_children!(input;
             [selector_expression(e)] => e,
             [import(e)] => e,
         ))
     }
 
-    fn selector_expression(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+    fn selector_expression<E: Clone>(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<Expr<E>> {
         Ok(parse_children!(input;
             [primitive_expression(e)] => e,
             [primitive_expression(first), selector(rest)..] => {
@@ -949,7 +957,7 @@ impl Parsers {
         Ok(parse_children!(input;
             [label(l)] => Either::Left(l),
             [labels(ls)] => Either::Right(ls),
-            [expression(_e)] => unimplemented!("selection by expression"), // TODO
+            // [expression(_e)] => unimplemented!("selection by expression"), // TODO
         ))
     }
 
@@ -959,9 +967,9 @@ impl Parsers {
         ))
     }
 
-    fn primitive_expression(
+    fn primitive_expression<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<ParsedExpr> {
+    ) -> ParseResult<Expr<E>> {
         let span = input.as_span();
         Ok(parse_children!(input;
             [double_literal(n)] => spanned(span, DoubleLit(n)),
@@ -979,21 +987,23 @@ impl Parsers {
         ))
     }
 
-    fn empty_record_literal(
+    fn empty_record_literal<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<ParsedExpr> {
+    ) -> ParseResult<Expr<E>> {
         let span = input.as_span();
         Ok(spanned(span, RecordLit(Default::default())))
     }
 
-    fn empty_record_type(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+    fn empty_record_type<E: Clone>(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<Expr<E>> {
         let span = input.as_span();
         Ok(spanned(span, RecordType(Default::default())))
     }
 
-    fn non_empty_record_type_or_literal(
+    fn non_empty_record_type_or_literal<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<ParsedExpr> {
+    ) -> ParseResult<Expr<E>> {
         let span = input.as_span();
         Ok(parse_children!(input;
             [label(first_label), non_empty_record_type(rest)] => {
@@ -1009,9 +1019,9 @@ impl Parsers {
         ))
     }
 
-    fn non_empty_record_type(
+    fn non_empty_record_type<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<(ParsedExpr, DupTreeMap<Label, ParsedExpr>)> {
+    ) -> ParseResult<(Expr<E>, DupTreeMap<Label, Expr<E>>)> {
         Ok(parse_children!(input;
             [expression(expr), record_type_entry(entries)..] => {
                 (expr, entries.collect())
@@ -1019,17 +1029,17 @@ impl Parsers {
         ))
     }
 
-    fn record_type_entry(
+    fn record_type_entry<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<(Label, ParsedExpr)> {
+    ) -> ParseResult<(Label, Expr<E>)> {
         Ok(parse_children!(input;
             [label(name), expression(expr)] => (name, expr)
         ))
     }
 
-    fn non_empty_record_literal(
+    fn non_empty_record_literal<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<(ParsedExpr, DupTreeMap<Label, ParsedExpr>)> {
+    ) -> ParseResult<(Expr<E>, DupTreeMap<Label, Expr<E>>)> {
         Ok(parse_children!(input;
             [expression(expr), record_literal_entry(entries)..] => {
                 (expr, entries.collect())
@@ -1037,15 +1047,15 @@ impl Parsers {
         ))
     }
 
-    fn record_literal_entry(
+    fn record_literal_entry<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<(Label, ParsedExpr)> {
+    ) -> ParseResult<(Label, Expr<E>)> {
         Ok(parse_children!(input;
             [label(name), expression(expr)] => (name, expr)
         ))
     }
 
-    fn union_type(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+    fn union_type<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
         let span = input.as_span();
         Ok(parse_children!(input;
             [empty_union_type(_)] => {
@@ -1061,18 +1071,18 @@ impl Parsers {
         Ok(())
     }
 
-    fn union_type_entry(
+    fn union_type_entry<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<(Label, Option<ParsedExpr>)> {
+    ) -> ParseResult<(Label, Option<Expr<E>>)> {
         Ok(parse_children!(input;
             [label(name), expression(expr)] => (name, Some(expr)),
             [label(name)] => (name, None),
         ))
     }
 
-    fn non_empty_list_literal(
+    fn non_empty_list_literal<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<ParsedExpr> {
+    ) -> ParseResult<Expr<E>> {
         let span = input.as_span();
         Ok(parse_children!(input;
             [expression(items)..] => spanned(
@@ -1082,14 +1092,16 @@ impl Parsers {
         ))
     }
 
-    fn final_expression(input: ParseInput<Rule>) -> ParseResult<ParsedExpr> {
+    fn final_expression<E: Clone>(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<Expr<E>> {
         Ok(parse_children!(input;
             [expression(e), EOI(_)] => e
         ))
     }
 }
 
-pub fn parse_expr(s: &str) -> ParseResult<ParsedExpr> {
+pub fn parse_expr<E: Clone>(s: &str) -> ParseResult<Expr<E>> {
     let input = ParseInput::parse(s, Rule::final_expression)?;
     Parsers::final_expression(input)
 }
-- 
cgit v1.2.3


From f892f0bdb1dc9a8f2d1cda245e17c28fcf1090b3 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 2 Sep 2019 23:03:05 +0200
Subject: Improve hygiene of identifiers

---
 dhall_proc_macros/src/parse_children.rs | 33 ++++++++++++++++++++-------------
 1 file changed, 20 insertions(+), 13 deletions(-)

diff --git a/dhall_proc_macros/src/parse_children.rs b/dhall_proc_macros/src/parse_children.rs
index ce6f66c..c78adbc 100644
--- a/dhall_proc_macros/src/parse_children.rs
+++ b/dhall_proc_macros/src/parse_children.rs
@@ -73,7 +73,10 @@ impl Parse for ParseChildrenInput {
     }
 }
 
-fn make_parser_branch(branch: &ChildrenBranch) -> Result<TokenStream> {
+fn make_parser_branch(
+    branch: &ChildrenBranch,
+    i_inputs: &Ident,
+) -> Result<TokenStream> {
     use ChildrenBranchPatternItem::{Multiple, Single};
 
     let body = &branch.body;
@@ -82,13 +85,13 @@ fn make_parser_branch(branch: &ChildrenBranch) -> Result<TokenStream> {
     // 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 variable_pattern_ident =
-        Ident::new("variable_pattern", Span::call_site());
+    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!(<<Self as PestConsumer>::RuleEnum>::#rule_name)
         }
-        Multiple { .. } => quote!(#variable_pattern_ident..),
+        Multiple { .. } => quote!(#i_variable_pattern..),
     });
     let match_filter = branch.pattern.iter().map(|item| match item {
         Single { .. } => quote!(),
@@ -101,7 +104,7 @@ fn make_parser_branch(branch: &ChildrenBranch) -> Result<TokenStream> {
                         r == &<<Self as PestConsumer>::RuleEnum>::#rule_name
                     )
                 };
-                all_match(#variable_pattern_ident)
+                all_match(#i_variable_pattern)
             } &&
         ),
     });
@@ -139,7 +142,7 @@ fn make_parser_branch(branch: &ChildrenBranch) -> Result<TokenStream> {
     for (rule_name, binder) in singles_before_multiple.into_iter() {
         parses.push(quote!(
             let #binder = Self::#rule_name(
-                inputs.next().unwrap()
+                #i_inputs.next().unwrap()
             )?;
         ))
     }
@@ -148,13 +151,13 @@ fn make_parser_branch(branch: &ChildrenBranch) -> Result<TokenStream> {
     for (rule_name, binder) in singles_after_multiple.into_iter().rev() {
         parses.push(quote!(
             let #binder = Self::#rule_name(
-                inputs.next_back().unwrap()
+                #i_inputs.next_back().unwrap()
             )?;
         ))
     }
     if let Some((rule_name, binder)) = multiple {
         parses.push(quote!(
-            let #binder = inputs
+            let #binder = #i_inputs
                 .map(|i| Self::#rule_name(i))
                 .collect::<Result<Vec<_>, _>>()?
                 .into_iter();
@@ -174,31 +177,35 @@ pub fn parse_children(
 ) -> Result<proc_macro2::TokenStream> {
     let input: ParseChildrenInput = syn::parse(input)?;
 
+    let i_children_rules = Ident::new("___children_rules", Span::call_site());
+    let i_inputs = Ident::new("___inputs", Span::call_site());
+
     let input_expr = &input.input_expr;
     let branches = input
         .branches
         .iter()
-        .map(make_parser_branch)
+        .map(|br| make_parser_branch(br, &i_inputs))
         .collect::<Result<Vec<_>>>()?;
+
     Ok(quote!({
-        let children_rules: Vec<_> = #input_expr.pair
+        let #i_children_rules: Vec<_> = #input_expr.pair
             .clone()
             .into_inner()
             .map(|p| p.as_rule())
             .collect();
 
         #[allow(unused_mut)]
-        let mut inputs = #input_expr
+        let mut #i_inputs = #input_expr
             .pair
             .clone()
             .into_inner()
             .map(|p| #input_expr.with_pair(p));
 
         #[allow(unreachable_code)]
-        match children_rules.as_slice() {
+        match #i_children_rules.as_slice() {
             #(#branches,)*
             [..] => return Err(#input_expr.error(
-                format!("Unexpected children: {:?}", children_rules)
+                format!("Unexpected children: {:?}", #i_children_rules)
             )),
         }
     }))
-- 
cgit v1.2.3