Parse polymorphically in the Embed parameter

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