From 250525a05e1af17bb46ceb72879f471e54fb5091 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 2 Sep 2019 23:07:12 +0200
Subject: No need to change the type of Embed when resolving anymore

---
 dhall_syntax/src/core/expr.rs    | 25 ++++++++++++++++---------
 dhall_syntax/src/core/visitor.rs | 11 ++++++-----
 2 files changed, 22 insertions(+), 14 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index eeee4d8..f46cafb 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -313,21 +313,25 @@ impl<SE, E> ExprF<SE, E> {
 }
 
 impl<E> RawExpr<E> {
-    pub fn traverse_resolve<E2, Err>(
+    pub fn traverse_resolve<Err>(
         &self,
-        visit_import: impl FnMut(&Import<Expr<E2>>) -> Result<E2, Err>,
-    ) -> Result<RawExpr<E2>, Err> {
+        visit_import: impl FnMut(&Import<Expr<E>>) -> Result<E, Err>,
+    ) -> Result<RawExpr<E>, Err>
+    where
+        E: Clone,
+    {
         self.traverse_resolve_with_visitor(&mut visitor::ResolveVisitor(
             visit_import,
         ))
     }
 
-    pub(crate) fn traverse_resolve_with_visitor<E2, Err, F1>(
+    pub(crate) fn traverse_resolve_with_visitor<Err, F1>(
         &self,
         visitor: &mut visitor::ResolveVisitor<F1>,
-    ) -> Result<RawExpr<E2>, Err>
+    ) -> Result<RawExpr<E>, Err>
     where
-        F1: FnMut(&Import<Expr<E2>>) -> Result<E2, Err>,
+        E: Clone,
+        F1: FnMut(&Import<Expr<E>>) -> Result<E, Err>,
     {
         match self {
             ExprF::BinOp(BinOp::ImportAlt, l, r) => l
@@ -368,10 +372,13 @@ impl<E> Expr<E> {
 }
 
 impl<E> Expr<E> {
-    pub fn traverse_resolve<E2, Err>(
+    pub fn traverse_resolve<Err>(
         &self,
-        visit_import: impl FnMut(&Import<Expr<E2>>) -> Result<E2, Err>,
-    ) -> Result<Expr<E2>, Err> {
+        visit_import: impl FnMut(&Import<Expr<E>>) -> Result<E, Err>,
+    ) -> Result<Expr<E>, Err>
+    where
+        E: Clone,
+    {
         Ok(self.rewrap(self.as_ref().traverse_resolve(visit_import)?))
     }
 }
diff --git a/dhall_syntax/src/core/visitor.rs b/dhall_syntax/src/core/visitor.rs
index 435771e..addb282 100644
--- a/dhall_syntax/src/core/visitor.rs
+++ b/dhall_syntax/src/core/visitor.rs
@@ -250,24 +250,25 @@ where
 
 pub struct ResolveVisitor<F1>(pub F1);
 
-impl<'a, 'b, E, E2, Err, F1> ExprFFallibleVisitor<'a, Expr<E>, Expr<E2>, E, E2>
+impl<'a, 'b, E, Err, F1> ExprFFallibleVisitor<'a, Expr<E>, Expr<E>, E, E>
     for &'b mut ResolveVisitor<F1>
 where
-    F1: FnMut(&Import<Expr<E2>>) -> Result<E2, Err>,
+    E: Clone,
+    F1: FnMut(&Import<Expr<E>>) -> Result<E, Err>,
 {
     type Error = Err;
 
     fn visit_subexpr(
         &mut self,
         subexpr: &'a Expr<E>,
-    ) -> Result<Expr<E2>, Self::Error> {
+    ) -> Result<Expr<E>, Self::Error> {
         Ok(subexpr.rewrap(
             subexpr
                 .as_ref()
                 .traverse_resolve_with_visitor(&mut **self)?,
         ))
     }
-    fn visit_embed(self, _embed: &'a E) -> Result<E2, Self::Error> {
-        unimplemented!()
+    fn visit_embed(self, embed: &'a E) -> Result<E, Self::Error> {
+        Ok(embed.clone())
     }
 }
-- 
cgit v1.3.1


From 79595b1ae1a12fa2414d4b6c3c4bb2f7a0a9c094 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 3 Sep 2019 16:24:07 +0200
Subject: Resolve imports by mutating Expr instead of cloning it

---
 dhall/src/phase/resolve.rs       |  41 ++--
 dhall_syntax/src/core/expr.rs    | 102 +++++-----
 dhall_syntax/src/core/import.rs  |  34 +++-
 dhall_syntax/src/core/map.rs     |  65 ++++++
 dhall_syntax/src/core/text.rs    |  10 +
 dhall_syntax/src/core/visitor.rs | 413 +++++++++++++++++++++++----------------
 6 files changed, 421 insertions(+), 244 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall/src/phase/resolve.rs b/dhall/src/phase/resolve.rs
index a58f5e4..32e90c8 100644
--- a/dhall/src/phase/resolve.rs
+++ b/dhall/src/phase/resolve.rs
@@ -58,18 +58,16 @@ fn load_import(
 }
 
 fn do_resolve_expr(
-    Parsed(expr, root): Parsed,
+    parsed: Parsed,
     import_cache: &mut ImportCache,
     import_stack: &ImportStack,
 ) -> Result<Resolved, ImportError> {
-    let resolve = |import: &Import| -> Result<Normalized, ImportError> {
-        if import_stack.contains(import) {
-            return Err(ImportError::ImportCycle(
-                import_stack.clone(),
-                import.clone(),
-            ));
+    let Parsed(mut expr, root) = parsed;
+    let mut resolve = |import: Import| -> Result<Normalized, ImportError> {
+        if import_stack.contains(&import) {
+            return Err(ImportError::ImportCycle(import_stack.clone(), import));
         }
-        match import_cache.get(import) {
+        match import_cache.get(&import) {
             Some(expr) => Ok(expr.clone()),
             None => {
                 // Copy the import stack and push the current import
@@ -77,16 +75,20 @@ fn do_resolve_expr(
                 import_stack.push(import.clone());
 
                 // Resolve the import recursively
-                let expr =
-                    resolve_import(import, &root, import_cache, &import_stack)?;
+                let expr = resolve_import(
+                    &import,
+                    &root,
+                    import_cache,
+                    &import_stack,
+                )?;
 
                 // Add the import to the cache
-                import_cache.insert(import.clone(), expr.clone());
+                import_cache.insert(import, expr.clone());
                 Ok(expr)
             }
         }
     };
-    let expr = expr.traverse_resolve(resolve)?;
+    expr.traverse_resolve_mut(&mut resolve)?;
     Ok(Resolved(expr))
 }
 
@@ -95,12 +97,13 @@ pub(crate) fn resolve(e: Parsed) -> Result<Resolved, ImportError> {
 }
 
 pub(crate) fn skip_resolve_expr(
-    Parsed(expr, _root): Parsed,
+    parsed: Parsed,
 ) -> Result<Resolved, ImportError> {
-    let resolve = |import: &Import| -> Result<Normalized, ImportError> {
-        Err(ImportError::UnexpectedImport(import.clone()))
+    let mut expr = parsed.0;
+    let mut resolve = |import: Import| -> Result<Normalized, ImportError> {
+        Err(ImportError::UnexpectedImport(import))
     };
-    let expr = expr.traverse_resolve(resolve)?;
+    expr.traverse_resolve_mut(&mut resolve)?;
     Ok(Resolved(expr))
 }
 
@@ -131,9 +134,9 @@ mod spec_tests {
     // import_success!(success_alternativeEnvNatural, "alternativeEnvNatural");
     // import_success!(success_alternativeEnvSimple, "alternativeEnvSimple");
     // import_success!(success_alternativeHashMismatch, "alternativeHashMismatch");
-    // import_success!(success_alternativeNatural, "alternativeNatural");
-    // import_success!(success_alternativeParseError, "alternativeParseError");
-    // import_success!(success_alternativeTypeError, "alternativeTypeError");
+    import_success!(success_alternativeNatural, "alternativeNatural");
+    import_success!(success_alternativeParseError, "alternativeParseError");
+    import_success!(success_alternativeTypeError, "alternativeTypeError");
     // import_success!(success_asLocation, "asLocation");
     // import_success!(success_asText, "asText");
     // import_success!(success_customHeaders, "customHeaders");
diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index f46cafb..2cb23c9 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -1,7 +1,7 @@
 use std::rc::Rc;
 
 use crate::map::{DupTreeMap, DupTreeSet};
-use crate::visitor;
+use crate::visitor::{self, ExprFMutVisitor, ExprFVisitor};
 use crate::*;
 
 pub type Integer = isize;
@@ -256,13 +256,6 @@ pub enum ExprF<SubExpr, Embed> {
 }
 
 impl<SE, E> ExprF<SE, E> {
-    pub(crate) fn visit<'a, V, Return>(&'a self, v: V) -> Return
-    where
-        V: visitor::GenericVisitor<&'a ExprF<SE, E>, Return>,
-    {
-        v.visit(self)
-    }
-
     pub fn traverse_ref_with_special_handling_of_binders<'a, SE2, Err>(
         &'a self,
         visit_subexpr: impl FnMut(&'a SE) -> Result<SE2, Err>,
@@ -271,10 +264,11 @@ impl<SE, E> ExprF<SE, E> {
     where
         E: Clone,
     {
-        self.visit(visitor::TraverseRefWithBindersVisitor {
+        visitor::TraverseRefWithBindersVisitor {
             visit_subexpr,
             visit_under_binder,
-        })
+        }
+        .visit(self)
     }
 
     fn traverse_ref<'a, SE2, Err>(
@@ -284,7 +278,14 @@ impl<SE, E> ExprF<SE, E> {
     where
         E: Clone,
     {
-        self.visit(visitor::TraverseRefVisitor { visit_subexpr })
+        visitor::TraverseRefVisitor { visit_subexpr }.visit(self)
+    }
+
+    fn traverse_mut<'a, Err>(
+        &'a mut self,
+        visit_subexpr: impl FnMut(&'a mut SE) -> Result<(), Err>,
+    ) -> Result<(), Err> {
+        visitor::TraverseMutVisitor { visit_subexpr }.visit(self)
     }
 
     pub fn map_ref_with_special_handling_of_binders<'a, SE2>(
@@ -310,42 +311,9 @@ impl<SE, E> ExprF<SE, E> {
     {
         trivial_result(self.traverse_ref(|x| Ok(map_subexpr(x))))
     }
-}
-
-impl<E> RawExpr<E> {
-    pub fn traverse_resolve<Err>(
-        &self,
-        visit_import: impl FnMut(&Import<Expr<E>>) -> Result<E, Err>,
-    ) -> Result<RawExpr<E>, Err>
-    where
-        E: Clone,
-    {
-        self.traverse_resolve_with_visitor(&mut visitor::ResolveVisitor(
-            visit_import,
-        ))
-    }
 
-    pub(crate) fn traverse_resolve_with_visitor<Err, F1>(
-        &self,
-        visitor: &mut visitor::ResolveVisitor<F1>,
-    ) -> Result<RawExpr<E>, Err>
-    where
-        E: Clone,
-        F1: FnMut(&Import<Expr<E>>) -> Result<E, Err>,
-    {
-        match self {
-            ExprF::BinOp(BinOp::ImportAlt, l, r) => l
-                .as_ref()
-                .traverse_resolve_with_visitor(visitor)
-                .or_else(|_| r.as_ref().traverse_resolve_with_visitor(visitor)),
-            _ => {
-                let e = self.visit(&mut *visitor)?;
-                Ok(match &e {
-                    ExprF::Import(import) => ExprF::Embed((visitor.0)(import)?),
-                    _ => e,
-                })
-            }
-        }
+    pub fn map_mut<'a>(&'a mut self, mut map_subexpr: impl FnMut(&'a mut SE)) {
+        trivial_result(self.traverse_mut(|x| Ok(map_subexpr(x))))
     }
 }
 
@@ -353,6 +321,9 @@ impl<E> Expr<E> {
     pub fn as_ref(&self) -> &RawExpr<E> {
         &self.0.as_ref().0
     }
+    pub fn as_mut(&mut self) -> &mut RawExpr<E> {
+        &mut self.0.as_mut().0
+    }
 
     pub fn new(x: RawExpr<E>, n: Span) -> Self {
         Expr(Box::new((x, Some(n))))
@@ -369,17 +340,42 @@ impl<E> Expr<E> {
     pub fn rewrap<E2>(&self, x: RawExpr<E2>) -> Expr<E2> {
         Expr(Box::new((x, (self.0).1.clone())))
     }
-}
 
-impl<E> Expr<E> {
-    pub fn traverse_resolve<Err>(
-        &self,
-        visit_import: impl FnMut(&Import<Expr<E>>) -> Result<E, Err>,
-    ) -> Result<Expr<E>, Err>
+    pub fn traverse_resolve_mut<Err, F1>(
+        &mut self,
+        f: &mut F1,
+    ) -> Result<(), Err>
     where
         E: Clone,
+        F1: FnMut(Import<Expr<E>>) -> Result<E, Err>,
     {
-        Ok(self.rewrap(self.as_ref().traverse_resolve(visit_import)?))
+        match self.as_mut() {
+            ExprF::BinOp(BinOp::ImportAlt, l, r) => {
+                let garbage_expr = ExprF::BoolLit(false);
+                let new_self = if l.traverse_resolve_mut(f).is_ok() {
+                    l
+                } else {
+                    r.traverse_resolve_mut(f)?;
+                    r
+                };
+                *self.as_mut() =
+                    std::mem::replace(new_self.as_mut(), garbage_expr);
+            }
+            _ => {
+                self.as_mut().traverse_mut(|e| e.traverse_resolve_mut(f))?;
+                if let ExprF::Import(import) = self.as_mut() {
+                    let garbage_import = Import {
+                        mode: ImportMode::Code,
+                        location: ImportLocation::Missing,
+                        hash: None,
+                    };
+                    // Move out of &mut import
+                    let import = std::mem::replace(import, garbage_import);
+                    *self.as_mut() = ExprF::Embed(f(import)?);
+                }
+            }
+        }
+        Ok(())
     }
 }
 
diff --git a/dhall_syntax/src/core/import.rs b/dhall_syntax/src/core/import.rs
index d1f3fca..43597df 100644
--- a/dhall_syntax/src/core/import.rs
+++ b/dhall_syntax/src/core/import.rs
@@ -57,7 +57,7 @@ pub struct Import<SubExpr> {
 }
 
 impl<SE> URL<SE> {
-    pub fn visit_subexpr<'a, Err, SE2>(
+    pub fn traverse_ref<'a, Err, SE2>(
         &'a self,
         f: impl FnOnce(&'a SE) -> Result<SE2, Err>,
     ) -> Result<URL<SE2>, Err> {
@@ -70,32 +70,56 @@ impl<SE> URL<SE> {
             headers,
         })
     }
+    pub fn traverse_mut<'a, Err>(
+        &'a mut self,
+        f: impl FnOnce(&'a mut SE) -> Result<(), Err>,
+    ) -> Result<(), Err> {
+        if let Some(header) = &mut self.headers {
+            f(header)?;
+        }
+        Ok(())
+    }
 }
 
 impl<SE> ImportLocation<SE> {
-    pub fn visit_subexpr<'a, Err, SE2>(
+    pub fn traverse_ref<'a, Err, SE2>(
         &'a self,
         f: impl FnOnce(&'a SE) -> Result<SE2, Err>,
     ) -> Result<ImportLocation<SE2>, Err> {
         use ImportLocation::*;
         Ok(match self {
             Local(prefix, path) => Local(*prefix, path.clone()),
-            Remote(url) => Remote(url.visit_subexpr(f)?),
+            Remote(url) => Remote(url.traverse_ref(f)?),
             Env(env) => Env(env.clone()),
             Missing => Missing,
         })
     }
+    pub fn traverse_mut<'a, Err>(
+        &'a mut self,
+        f: impl FnOnce(&'a mut SE) -> Result<(), Err>,
+    ) -> Result<(), Err> {
+        if let ImportLocation::Remote(url) = self {
+            url.traverse_mut(f)?;
+        }
+        Ok(())
+    }
 }
 
 impl<SE> Import<SE> {
-    pub fn visit_subexpr<'a, Err, SE2>(
+    pub fn traverse_ref<'a, Err, SE2>(
         &'a self,
         f: impl FnOnce(&'a SE) -> Result<SE2, Err>,
     ) -> Result<Import<SE2>, Err> {
         Ok(Import {
             mode: self.mode,
-            location: self.location.visit_subexpr(f)?,
+            location: self.location.traverse_ref(f)?,
             hash: self.hash.clone(),
         })
     }
+    pub fn traverse_mut<'a, Err>(
+        &'a mut self,
+        f: impl FnOnce(&'a mut SE) -> Result<(), Err>,
+    ) -> Result<(), Err> {
+        self.location.traverse_mut(f)
+    }
 }
diff --git a/dhall_syntax/src/core/map.rs b/dhall_syntax/src/core/map.rs
index 6a0ebda..c4c6126 100644
--- a/dhall_syntax/src/core/map.rs
+++ b/dhall_syntax/src/core/map.rs
@@ -13,6 +13,8 @@ mod one_or_more {
     }
 
     pub type Iter<'a, T> = Either<slice::Iter<'a, T>, iter::Once<&'a T>>;
+    pub type IterMut<'a, T> =
+        Either<slice::IterMut<'a, T>, iter::Once<&'a mut T>>;
     pub type IntoIter<T> = Either<vec::IntoIter<T>, iter::Once<T>>;
 
     impl<T> OneOrMore<T> {
@@ -36,6 +38,13 @@ mod one_or_more {
                 OneOrMore::One(x) => Either::Right(iter::once(x)),
             }
         }
+
+        pub fn iter_mut(&mut self) -> IterMut<'_, T> {
+            match self {
+                OneOrMore::More(vec) => Either::Left(vec.iter_mut()),
+                OneOrMore::One(x) => Either::Right(iter::once(x)),
+            }
+        }
     }
 
     impl<T> IntoIterator for OneOrMore<T> {
@@ -76,6 +85,19 @@ mod dup_tree_map {
         iter: IterInternal<'a, K, V>,
         size: usize,
     }
+    pub type IterMutInternalIntermediate<'a, K, V> =
+        iter::Zip<iter::Repeat<&'a K>, one_or_more::IterMut<'a, V>>;
+    pub type IterMutInternal<'a, K, V> = iter::FlatMap<
+        btree_map::IterMut<'a, K, OneOrMore<V>>,
+        IterMutInternalIntermediate<'a, K, V>,
+        for<'b> fn(
+            (&'b K, &'b mut OneOrMore<V>),
+        ) -> IterMutInternalIntermediate<'b, K, V>,
+    >;
+    pub struct IterMut<'a, K, V> {
+        iter: IterMutInternal<'a, K, V>,
+        size: usize,
+    }
     pub type IntoIterInternalIntermediate<K, V> =
         iter::Zip<iter::Repeat<K>, one_or_more::IntoIter<V>>;
     pub type IntoIterInternal<K, V> = iter::FlatMap<
@@ -134,6 +156,21 @@ mod dup_tree_map {
                 size: self.size,
             }
         }
+
+        pub fn iter_mut(&mut self) -> IterMut<'_, K, V>
+        where
+            K: Ord,
+        {
+            fn foo<'a, K, V>(
+                (k, oom): (&'a K, &'a mut OneOrMore<V>),
+            ) -> IterMutInternalIntermediate<'a, K, V> {
+                iter::repeat(k).zip(oom.iter_mut())
+            }
+            IterMut {
+                iter: self.map.iter_mut().flat_map(foo),
+                size: self.size,
+            }
+        }
     }
 
     impl<K, V> Default for DupTreeMap<K, V>
@@ -180,6 +217,18 @@ mod dup_tree_map {
         }
     }
 
+    impl<'a, K, V> IntoIterator for &'a mut DupTreeMap<K, V>
+    where
+        K: Ord,
+    {
+        type Item = (&'a K, &'a mut V);
+        type IntoIter = IterMut<'a, K, V>;
+
+        fn into_iter(self) -> Self::IntoIter {
+            self.iter_mut()
+        }
+    }
+
     impl<K, V> iter::FromIterator<(K, V)> for DupTreeMap<K, V>
     where
         K: Ord,
@@ -212,6 +261,22 @@ mod dup_tree_map {
         }
     }
 
+    impl<'a, K, V> Iterator for IterMut<'a, K, V> {
+        type Item = (&'a K, &'a mut V);
+
+        fn next(&mut self) -> Option<Self::Item> {
+            let next = self.iter.next();
+            if next.is_some() {
+                self.size -= 1;
+            }
+            next
+        }
+
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            (self.size, Some(self.size))
+        }
+    }
+
     impl<K, V> Iterator for IntoIter<K, V>
     where
         K: Clone,
diff --git a/dhall_syntax/src/core/text.rs b/dhall_syntax/src/core/text.rs
index 10fd68a..e17f00f 100644
--- a/dhall_syntax/src/core/text.rs
+++ b/dhall_syntax/src/core/text.rs
@@ -76,6 +76,16 @@ impl<SubExpr> InterpolatedText<SubExpr> {
         })
     }
 
+    pub fn traverse_mut<'a, E, F>(&'a mut self, mut f: F) -> Result<(), E>
+    where
+        F: FnMut(&'a mut SubExpr) -> Result<(), E>,
+    {
+        for (e, _) in &mut self.tail {
+            f(e)?
+        }
+        Ok(())
+    }
+
     pub fn iter<'a>(
         &'a self,
     ) -> impl Iterator<Item = InterpolatedTextContents<&'a SubExpr>> + 'a {
diff --git a/dhall_syntax/src/core/visitor.rs b/dhall_syntax/src/core/visitor.rs
index addb282..39a027f 100644
--- a/dhall_syntax/src/core/visitor.rs
+++ b/dhall_syntax/src/core/visitor.rs
@@ -1,11 +1,6 @@
 use crate::*;
 use std::iter::FromIterator;
 
-/// A way too generic Visitor trait.
-pub trait GenericVisitor<Input, Output>: Sized {
-    fn visit(self, input: Input) -> Output;
-}
-
 /// A visitor trait that can be used to traverse `ExprF`s. We need this pattern so that Rust lets
 /// us have as much mutability as we can.
 /// For example, `traverse_ref_with_special_handling_of_binders` cannot be made using only
@@ -14,7 +9,7 @@ pub trait GenericVisitor<Input, Output>: Sized {
 /// preventing exactly this ! So we have to be more clever. The visitor pattern allows us to have
 /// only one mutable thing the whole time: the visitor itself. The visitor can then carry around
 /// multiple closures or just one, and Rust is ok with either. See for example TraverseRefVisitor.
-pub trait ExprFFallibleVisitor<'a, SE1, SE2, E1, E2>: Sized {
+pub trait ExprFVisitor<'a, SE1, SE2, E1, E2>: Sized {
     type Error;
 
     fn visit_subexpr(&mut self, subexpr: &'a SE1) -> Result<SE2, Self::Error>;
@@ -27,174 +22,263 @@ pub trait ExprFFallibleVisitor<'a, SE1, SE2, E1, E2>: Sized {
     ) -> Result<SE2, Self::Error> {
         self.visit_subexpr(subexpr)
     }
+
+    fn visit(
+        self,
+        input: &'a ExprF<SE1, E1>,
+    ) -> Result<ExprF<SE2, E2>, Self::Error> {
+        visit_ref(self, input)
+    }
 }
 
-/// Like ExprFFallibleVisitor, but without the error handling.
-pub trait ExprFInFallibleVisitor<'a, SE1, SE2, E1, E2>: Sized {
-    fn visit_subexpr(&mut self, subexpr: &'a SE1) -> SE2;
-    fn visit_embed(self, embed: &'a E1) -> E2;
+/// Like `ExprFVisitor`, but by mutable reference
+pub trait ExprFMutVisitor<'a, SE, E>: Sized {
+    type Error;
+
+    fn visit_subexpr(&mut self, subexpr: &'a mut SE)
+        -> Result<(), Self::Error>;
+    fn visit_embed(self, _embed: &'a mut E) -> Result<(), Self::Error> {
+        Ok(())
+    }
 
     fn visit_subexpr_under_binder(
         mut self,
-        _label: &'a Label,
-        subexpr: &'a SE1,
-    ) -> SE2 {
+        _label: &'a mut Label,
+        subexpr: &'a mut SE,
+    ) -> Result<(), Self::Error> {
         self.visit_subexpr(subexpr)
     }
+
+    fn visit(self, input: &'a mut ExprF<SE, E>) -> Result<(), Self::Error> {
+        visit_mut(self, input)
+    }
 }
 
-impl<'a, T, SE1, SE2, E1, E2>
-    GenericVisitor<&'a ExprF<SE1, E1>, Result<ExprF<SE2, E2>, T::Error>> for T
+fn visit_ref<'a, V, SE1, SE2, E1, E2>(
+    mut v: V,
+    input: &'a ExprF<SE1, E1>,
+) -> Result<ExprF<SE2, E2>, V::Error>
 where
-    T: ExprFFallibleVisitor<'a, SE1, SE2, E1, E2>,
+    V: ExprFVisitor<'a, SE1, SE2, E1, E2>,
 {
-    fn visit(
-        self,
-        input: &'a ExprF<SE1, E1>,
-    ) -> Result<ExprF<SE2, E2>, T::Error> {
-        fn vec<'a, T, U, Err, F: FnMut(&'a T) -> Result<U, Err>>(
-            x: &'a [T],
-            f: F,
-        ) -> Result<Vec<U>, Err> {
-            x.iter().map(f).collect()
-        }
-        fn opt<'a, T, U, Err, F: FnOnce(&'a T) -> Result<U, Err>>(
-            x: &'a Option<T>,
-            f: F,
-        ) -> Result<Option<U>, Err> {
-            Ok(match x {
-                Some(x) => Some(f(x)?),
-                None => None,
+    fn vec<'a, T, U, Err, F: FnMut(&'a T) -> Result<U, Err>>(
+        x: &'a [T],
+        f: F,
+    ) -> Result<Vec<U>, Err> {
+        x.iter().map(f).collect()
+    }
+    fn opt<'a, T, U, Err, F: FnOnce(&'a T) -> Result<U, Err>>(
+        x: &'a Option<T>,
+        f: F,
+    ) -> Result<Option<U>, Err> {
+        Ok(match x {
+            Some(x) => Some(f(x)?),
+            None => None,
+        })
+    }
+    fn dupmap<'a, V, SE1, SE2, E1, E2, T>(
+        x: impl IntoIterator<Item = (&'a Label, &'a SE1)>,
+        mut v: V,
+    ) -> Result<T, V::Error>
+    where
+        SE1: 'a,
+        T: FromIterator<(Label, SE2)>,
+        V: ExprFVisitor<'a, SE1, SE2, E1, E2>,
+    {
+        x.into_iter()
+            .map(|(k, x)| Ok((k.clone(), v.visit_subexpr(x)?)))
+            .collect()
+    }
+    fn optdupmap<'a, V, SE1, SE2, E1, E2, T>(
+        x: impl IntoIterator<Item = (&'a Label, &'a Option<SE1>)>,
+        mut v: V,
+    ) -> Result<T, V::Error>
+    where
+        SE1: 'a,
+        T: FromIterator<(Label, Option<SE2>)>,
+        V: ExprFVisitor<'a, SE1, SE2, E1, E2>,
+    {
+        x.into_iter()
+            .map(|(k, x)| {
+                Ok((
+                    k.clone(),
+                    match x {
+                        Some(x) => Some(v.visit_subexpr(x)?),
+                        None => None,
+                    },
+                ))
             })
+            .collect()
+    }
+
+    use crate::ExprF::*;
+    Ok(match input {
+        Var(v) => Var(v.clone()),
+        Lam(l, t, e) => {
+            let t = v.visit_subexpr(t)?;
+            let e = v.visit_subexpr_under_binder(l, e)?;
+            Lam(l.clone(), t, e)
         }
-        fn dupmap<'a, V, SE1, SE2, E1, E2, T>(
-            x: impl IntoIterator<Item = (&'a Label, &'a SE1)>,
-            mut v: V,
-        ) -> Result<T, V::Error>
-        where
-            SE1: 'a,
-            T: FromIterator<(Label, SE2)>,
-            V: ExprFFallibleVisitor<'a, SE1, SE2, E1, E2>,
-        {
-            x.into_iter()
-                .map(|(k, x)| Ok((k.clone(), v.visit_subexpr(x)?)))
-                .collect()
+        Pi(l, t, e) => {
+            let t = v.visit_subexpr(t)?;
+            let e = v.visit_subexpr_under_binder(l, e)?;
+            Pi(l.clone(), t, e)
         }
-        fn optdupmap<'a, V, SE1, SE2, E1, E2, T>(
-            x: impl IntoIterator<Item = (&'a Label, &'a Option<SE1>)>,
-            mut v: V,
-        ) -> Result<T, V::Error>
-        where
-            SE1: 'a,
-            T: FromIterator<(Label, Option<SE2>)>,
-            V: ExprFFallibleVisitor<'a, SE1, SE2, E1, E2>,
-        {
-            x.into_iter()
-                .map(|(k, x)| {
-                    Ok((
-                        k.clone(),
-                        match x {
-                            Some(x) => Some(v.visit_subexpr(x)?),
-                            None => None,
-                        },
-                    ))
-                })
-                .collect()
+        Let(l, t, a, e) => {
+            let t = opt(t, &mut |e| v.visit_subexpr(e))?;
+            let a = v.visit_subexpr(a)?;
+            let e = v.visit_subexpr_under_binder(l, e)?;
+            Let(l.clone(), t, a, e)
         }
-
-        let mut v = self;
-        use crate::ExprF::*;
-        Ok(match input {
-            Var(v) => Var(v.clone()),
-            Lam(l, t, e) => {
-                let t = v.visit_subexpr(t)?;
-                let e = v.visit_subexpr_under_binder(l, e)?;
-                Lam(l.clone(), t, e)
-            }
-            Pi(l, t, e) => {
-                let t = v.visit_subexpr(t)?;
-                let e = v.visit_subexpr_under_binder(l, e)?;
-                Pi(l.clone(), t, e)
-            }
-            Let(l, t, a, e) => {
-                let t = opt(t, &mut |e| v.visit_subexpr(e))?;
-                let a = v.visit_subexpr(a)?;
-                let e = v.visit_subexpr_under_binder(l, e)?;
-                Let(l.clone(), t, a, e)
-            }
-            App(f, a) => App(v.visit_subexpr(f)?, v.visit_subexpr(a)?),
-            Annot(x, t) => Annot(v.visit_subexpr(x)?, v.visit_subexpr(t)?),
-            Const(k) => Const(*k),
-            Builtin(v) => Builtin(*v),
-            BoolLit(b) => BoolLit(*b),
-            NaturalLit(n) => NaturalLit(*n),
-            IntegerLit(n) => IntegerLit(*n),
-            DoubleLit(n) => DoubleLit(*n),
-            TextLit(t) => TextLit(t.traverse_ref(|e| v.visit_subexpr(e))?),
-            BinOp(o, x, y) => {
-                BinOp(*o, v.visit_subexpr(x)?, v.visit_subexpr(y)?)
-            }
-            BoolIf(b, t, f) => BoolIf(
-                v.visit_subexpr(b)?,
-                v.visit_subexpr(t)?,
-                v.visit_subexpr(f)?,
-            ),
-            EmptyListLit(t) => EmptyListLit(v.visit_subexpr(t)?),
-            NEListLit(es) => NEListLit(vec(es, |e| v.visit_subexpr(e))?),
-            SomeLit(e) => SomeLit(v.visit_subexpr(e)?),
-            RecordType(kts) => RecordType(dupmap(kts, v)?),
-            RecordLit(kvs) => RecordLit(dupmap(kvs, v)?),
-            UnionType(kts) => UnionType(optdupmap(kts, v)?),
-            Merge(x, y, t) => Merge(
-                v.visit_subexpr(x)?,
-                v.visit_subexpr(y)?,
-                opt(t, |e| v.visit_subexpr(e))?,
-            ),
-            ToMap(x, t) => {
-                ToMap(v.visit_subexpr(x)?, opt(t, |e| v.visit_subexpr(e))?)
-            }
-            Field(e, l) => Field(v.visit_subexpr(e)?, l.clone()),
-            Projection(e, ls) => Projection(v.visit_subexpr(e)?, ls.clone()),
-            Assert(e) => Assert(v.visit_subexpr(e)?),
-            Import(i) => Import(i.visit_subexpr(|e| v.visit_subexpr(e))?),
-            Embed(a) => Embed(v.visit_embed(a)?),
-        })
-    }
+        App(f, a) => App(v.visit_subexpr(f)?, v.visit_subexpr(a)?),
+        Annot(x, t) => Annot(v.visit_subexpr(x)?, v.visit_subexpr(t)?),
+        Const(k) => Const(*k),
+        Builtin(v) => Builtin(*v),
+        BoolLit(b) => BoolLit(*b),
+        NaturalLit(n) => NaturalLit(*n),
+        IntegerLit(n) => IntegerLit(*n),
+        DoubleLit(n) => DoubleLit(*n),
+        TextLit(t) => TextLit(t.traverse_ref(|e| v.visit_subexpr(e))?),
+        BinOp(o, x, y) => BinOp(*o, v.visit_subexpr(x)?, v.visit_subexpr(y)?),
+        BoolIf(b, t, f) => BoolIf(
+            v.visit_subexpr(b)?,
+            v.visit_subexpr(t)?,
+            v.visit_subexpr(f)?,
+        ),
+        EmptyListLit(t) => EmptyListLit(v.visit_subexpr(t)?),
+        NEListLit(es) => NEListLit(vec(es, |e| v.visit_subexpr(e))?),
+        SomeLit(e) => SomeLit(v.visit_subexpr(e)?),
+        RecordType(kts) => RecordType(dupmap(kts, v)?),
+        RecordLit(kvs) => RecordLit(dupmap(kvs, v)?),
+        UnionType(kts) => UnionType(optdupmap(kts, v)?),
+        Merge(x, y, t) => Merge(
+            v.visit_subexpr(x)?,
+            v.visit_subexpr(y)?,
+            opt(t, |e| v.visit_subexpr(e))?,
+        ),
+        ToMap(x, t) => {
+            ToMap(v.visit_subexpr(x)?, opt(t, |e| v.visit_subexpr(e))?)
+        }
+        Field(e, l) => Field(v.visit_subexpr(e)?, l.clone()),
+        Projection(e, ls) => Projection(v.visit_subexpr(e)?, ls.clone()),
+        Assert(e) => Assert(v.visit_subexpr(e)?),
+        Import(i) => Import(i.traverse_ref(|e| v.visit_subexpr(e))?),
+        Embed(a) => Embed(v.visit_embed(a)?),
+    })
 }
 
-impl<'a, T, SE1, SE2, E1, E2> GenericVisitor<&'a ExprF<SE1, E1>, ExprF<SE2, E2>>
-    for T
+fn visit_mut<'a, V, SE, E>(
+    mut v: V,
+    input: &'a mut ExprF<SE, E>,
+) -> Result<(), V::Error>
 where
-    T: ExprFInFallibleVisitor<'a, SE1, SE2, E1, E2>,
+    V: ExprFMutVisitor<'a, SE, E>,
 {
-    fn visit(self, input: &'a ExprF<SE1, E1>) -> ExprF<SE2, E2> {
-        trivial_result(InfallibleWrapper(self).visit(input))
+    fn vec<'a, V, SE, E>(v: &mut V, x: &'a mut Vec<SE>) -> Result<(), V::Error>
+    where
+        V: ExprFMutVisitor<'a, SE, E>,
+    {
+        for x in x {
+            v.visit_subexpr(x)?;
+        }
+        Ok(())
     }
-}
-
-struct InfallibleWrapper<T>(T);
-
-impl<'a, T, SE1, SE2, E1, E2> ExprFFallibleVisitor<'a, SE1, SE2, E1, E2>
-    for InfallibleWrapper<T>
-where
-    T: ExprFInFallibleVisitor<'a, SE1, SE2, E1, E2>,
-{
-    type Error = !;
-
-    fn visit_subexpr(&mut self, subexpr: &'a SE1) -> Result<SE2, Self::Error> {
-        Ok(self.0.visit_subexpr(subexpr))
+    fn opt<'a, V, SE, E>(
+        v: &mut V,
+        x: &'a mut Option<SE>,
+    ) -> Result<(), V::Error>
+    where
+        V: ExprFMutVisitor<'a, SE, E>,
+    {
+        if let Some(x) = x {
+            v.visit_subexpr(x)?;
+        }
+        Ok(())
     }
-    fn visit_embed(self, embed: &'a E1) -> Result<E2, Self::Error> {
-        Ok(self.0.visit_embed(embed))
+    fn dupmap<'a, V, SE, E>(
+        mut v: V,
+        x: impl IntoIterator<Item = (&'a Label, &'a mut SE)>,
+    ) -> Result<(), V::Error>
+    where
+        SE: 'a,
+        V: ExprFMutVisitor<'a, SE, E>,
+    {
+        for (_, x) in x {
+            v.visit_subexpr(x)?;
+        }
+        Ok(())
+    }
+    fn optdupmap<'a, V, SE, E>(
+        mut v: V,
+        x: impl IntoIterator<Item = (&'a Label, &'a mut Option<SE>)>,
+    ) -> Result<(), V::Error>
+    where
+        SE: 'a,
+        V: ExprFMutVisitor<'a, SE, E>,
+    {
+        for (_, x) in x {
+            opt(&mut v, x)?;
+        }
+        Ok(())
     }
 
-    fn visit_subexpr_under_binder(
-        self,
-        label: &'a Label,
-        subexpr: &'a SE1,
-    ) -> Result<SE2, Self::Error> {
-        Ok(self.0.visit_subexpr_under_binder(label, subexpr))
+    use crate::ExprF::*;
+    match input {
+        Var(_) | Const(_) | Builtin(_) | BoolLit(_) | NaturalLit(_)
+        | IntegerLit(_) | DoubleLit(_) => {}
+        Lam(l, t, e) => {
+            v.visit_subexpr(t)?;
+            v.visit_subexpr_under_binder(l, e)?;
+        }
+        Pi(l, t, e) => {
+            v.visit_subexpr(t)?;
+            v.visit_subexpr_under_binder(l, e)?;
+        }
+        Let(l, t, a, e) => {
+            opt(&mut v, t)?;
+            v.visit_subexpr(a)?;
+            v.visit_subexpr_under_binder(l, e)?;
+        }
+        App(f, a) => {
+            v.visit_subexpr(f)?;
+            v.visit_subexpr(a)?;
+        }
+        Annot(x, t) => {
+            v.visit_subexpr(x)?;
+            v.visit_subexpr(t)?;
+        }
+        TextLit(t) => t.traverse_mut(|e| v.visit_subexpr(e))?,
+        BinOp(_, x, y) => {
+            v.visit_subexpr(x)?;
+            v.visit_subexpr(y)?;
+        }
+        BoolIf(b, t, f) => {
+            v.visit_subexpr(b)?;
+            v.visit_subexpr(t)?;
+            v.visit_subexpr(f)?;
+        }
+        EmptyListLit(t) => v.visit_subexpr(t)?,
+        NEListLit(es) => vec(&mut v, es)?,
+        SomeLit(e) => v.visit_subexpr(e)?,
+        RecordType(kts) => dupmap(v, kts)?,
+        RecordLit(kvs) => dupmap(v, kvs)?,
+        UnionType(kts) => optdupmap(v, kts)?,
+        Merge(x, y, t) => {
+            v.visit_subexpr(x)?;
+            v.visit_subexpr(y)?;
+            opt(&mut v, t)?;
+        }
+        ToMap(x, t) => {
+            v.visit_subexpr(x)?;
+            opt(&mut v, t)?;
+        }
+        Field(e, _) => v.visit_subexpr(e)?,
+        Projection(e, _) => v.visit_subexpr(e)?,
+        Assert(e) => v.visit_subexpr(e)?,
+        Import(i) => i.traverse_mut(|e| v.visit_subexpr(e))?,
+        Embed(a) => v.visit_embed(a)?,
     }
+    Ok(())
 }
 
 pub struct TraverseRefWithBindersVisitor<F1, F2> {
@@ -202,7 +286,7 @@ pub struct TraverseRefWithBindersVisitor<F1, F2> {
     pub visit_under_binder: F2,
 }
 
-impl<'a, SE, E, SE2, Err, F1, F2> ExprFFallibleVisitor<'a, SE, SE2, E, E>
+impl<'a, SE, E, SE2, Err, F1, F2> ExprFVisitor<'a, SE, SE2, E, E>
     for TraverseRefWithBindersVisitor<F1, F2>
 where
     SE: 'a,
@@ -231,7 +315,7 @@ pub struct TraverseRefVisitor<F1> {
     pub visit_subexpr: F1,
 }
 
-impl<'a, SE, E, SE2, Err, F1> ExprFFallibleVisitor<'a, SE, SE2, E, E>
+impl<'a, SE, E, SE2, Err, F1> ExprFVisitor<'a, SE, SE2, E, E>
     for TraverseRefVisitor<F1>
 where
     SE: 'a,
@@ -248,27 +332,22 @@ where
     }
 }
 
-pub struct ResolveVisitor<F1>(pub F1);
+pub struct TraverseMutVisitor<F1> {
+    pub visit_subexpr: F1,
+}
 
-impl<'a, 'b, E, Err, F1> ExprFFallibleVisitor<'a, Expr<E>, Expr<E>, E, E>
-    for &'b mut ResolveVisitor<F1>
+impl<'a, SE, E, Err, F1> ExprFMutVisitor<'a, SE, E> for TraverseMutVisitor<F1>
 where
-    E: Clone,
-    F1: FnMut(&Import<Expr<E>>) -> Result<E, Err>,
+    SE: 'a,
+    E: 'a,
+    F1: FnMut(&'a mut SE) -> Result<(), Err>,
 {
     type Error = Err;
 
     fn visit_subexpr(
         &mut self,
-        subexpr: &'a Expr<E>,
-    ) -> Result<Expr<E>, Self::Error> {
-        Ok(subexpr.rewrap(
-            subexpr
-                .as_ref()
-                .traverse_resolve_with_visitor(&mut **self)?,
-        ))
-    }
-    fn visit_embed(self, embed: &'a E) -> Result<E, Self::Error> {
-        Ok(embed.clone())
+        subexpr: &'a mut SE,
+    ) -> Result<(), Self::Error> {
+        (self.visit_subexpr)(subexpr)
     }
 }
-- 
cgit v1.3.1


From f1c3d1d7487fbb18b228a1082fc1c966f34b6dc3 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 3 Sep 2019 16:44:02 +0200
Subject: Add mapping functions to InterpolatedTextContents

---
 dhall/src/core/valuef.rs      | 22 ++++++---------------
 dhall/src/core/var.rs         | 12 ++---------
 dhall_syntax/src/core/text.rs | 46 +++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 54 insertions(+), 26 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall/src/core/valuef.rs b/dhall/src/core/valuef.rs
index 7a2b51c..4e457e6 100644
--- a/dhall/src/core/valuef.rs
+++ b/dhall/src/core/valuef.rs
@@ -110,17 +110,11 @@ impl ValueF {
                 ValueF::UnionConstructor(l.clone(), kts.clone()).to_expr(opts),
                 v.to_expr(opts),
             )),
-            ValueF::TextLit(elts) => {
-                use InterpolatedTextContents::{Expr, Text};
-                rc(ExprF::TextLit(
-                    elts.iter()
-                        .map(|contents| match contents {
-                            Expr(e) => Expr(e.to_expr(opts)),
-                            Text(s) => Text(s.clone()),
-                        })
-                        .collect(),
-                ))
-            }
+            ValueF::TextLit(elts) => rc(ExprF::TextLit(
+                elts.iter()
+                    .map(|contents| contents.map_ref(|e| e.to_expr(opts)))
+                    .collect(),
+            )),
             ValueF::Equivalence(x, y) => rc(ExprF::BinOp(
                 dhall_syntax::BinOp::Equivalence,
                 x.to_expr(opts),
@@ -187,11 +181,7 @@ impl ValueF {
             }
             ValueF::TextLit(elts) => {
                 for x in elts.iter_mut() {
-                    use InterpolatedTextContents::{Expr, Text};
-                    match x {
-                        Expr(v) => v.normalize_mut(),
-                        Text(_) => {}
-                    }
+                    x.map_mut(Value::normalize_mut);
                 }
             }
             ValueF::Equivalence(x, y) => {
diff --git a/dhall/src/core/var.rs b/dhall/src/core/var.rs
index ce4d137..3795f10 100644
--- a/dhall/src/core/var.rs
+++ b/dhall/src/core/var.rs
@@ -224,11 +224,7 @@ where
 
 impl<T: Shift> Shift for dhall_syntax::InterpolatedTextContents<T> {
     fn shift(&self, delta: isize, var: &AlphaVar) -> Option<Self> {
-        use dhall_syntax::InterpolatedTextContents::{Expr, Text};
-        Some(match self {
-            Expr(x) => Expr(x.shift(delta, var)?),
-            Text(s) => Text(s.clone()),
-        })
+        Some(self.traverse_ref(|x| Ok(x.shift(delta, var)?))?)
     }
 }
 
@@ -283,11 +279,7 @@ impl<S, T: Subst<S>> Subst<S> for Vec<T> {
 
 impl<S, T: Subst<S>> Subst<S> for dhall_syntax::InterpolatedTextContents<T> {
     fn subst_shift(&self, var: &AlphaVar, val: &S) -> Self {
-        use dhall_syntax::InterpolatedTextContents::{Expr, Text};
-        match self {
-            Expr(x) => Expr(x.subst_shift(var, val)),
-            Text(s) => Text(s.clone()),
-        }
+        self.map_ref(|x| x.subst_shift(var, val))
     }
 }
 
diff --git a/dhall_syntax/src/core/text.rs b/dhall_syntax/src/core/text.rs
index e17f00f..fb390ee 100644
--- a/dhall_syntax/src/core/text.rs
+++ b/dhall_syntax/src/core/text.rs
@@ -40,6 +40,52 @@ impl<SubExpr> InterpolatedTextContents<SubExpr> {
             Text(s) => s.is_empty(),
         }
     }
+
+    pub fn traverse_ref<'a, SubExpr2, E, F>(
+        &'a self,
+        mut f: F,
+    ) -> Result<InterpolatedTextContents<SubExpr2>, E>
+    where
+        F: FnMut(&'a SubExpr) -> Result<SubExpr2, E>,
+    {
+        use InterpolatedTextContents::{Expr, Text};
+        Ok(match self {
+            Expr(e) => Expr(f(e)?),
+            Text(s) => Text(s.clone()),
+        })
+    }
+    pub fn traverse_mut<'a, E, F>(&'a mut self, mut f: F) -> Result<(), E>
+    where
+        F: FnMut(&'a mut SubExpr) -> Result<(), E>,
+    {
+        use InterpolatedTextContents::Expr;
+        if let Expr(e) = self {
+            f(e)?;
+        }
+        Ok(())
+    }
+    pub fn map_ref<'a, SubExpr2, F>(
+        &'a self,
+        mut f: F,
+    ) -> InterpolatedTextContents<SubExpr2>
+    where
+        F: FnMut(&'a SubExpr) -> SubExpr2,
+    {
+        use InterpolatedTextContents::{Expr, Text};
+        match self {
+            Expr(e) => Expr(f(e)),
+            Text(s) => Text(s.clone()),
+        }
+    }
+    pub fn map_mut<'a, F>(&'a mut self, mut f: F)
+    where
+        F: FnMut(&'a mut SubExpr),
+    {
+        use InterpolatedTextContents::Expr;
+        if let Expr(e) = self {
+            f(e);
+        }
+    }
 }
 
 impl<SubExpr> InterpolatedText<SubExpr> {
-- 
cgit v1.3.1


From d3fcc3a5ef93d4e7f539954f1c77af58685c65b9 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 5 Sep 2019 17:40:29 +0200
Subject: Implement rule aliasing and simplify parser code

---
 dhall_generated_parser/src/dhall.pest.visibility |  18 +-
 dhall_proc_macros/src/make_parser.rs             | 187 ++++++++--
 dhall_proc_macros/src/parse_children.rs          |  11 +-
 dhall_syntax/src/parser.rs                       | 423 ++++++++++-------------
 tests_buffer                                     |   2 +
 5 files changed, 344 insertions(+), 297 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_generated_parser/src/dhall.pest.visibility b/dhall_generated_parser/src/dhall.pest.visibility
index dcebf45..17c1edc 100644
--- a/dhall_generated_parser/src/dhall.pest.visibility
+++ b/dhall_generated_parser/src/dhall.pest.visibility
@@ -18,7 +18,7 @@
 simple_label
 # quoted_label_char
 quoted_label
-label
+# label
 # nonreserved_label
 # any_label
 double_quote_chunk
@@ -31,13 +31,13 @@ escaped_quote_pair
 escaped_interpolation
 single_quote_char
 single_quote_literal
-interpolation
+# interpolation
 # text_literal
 if_
 # then
 # else_
 # let_
-in_
+# in_
 # as_
 # using
 merge
@@ -49,9 +49,9 @@ toMap
 assert
 # keyword
 builtin
-Optional
+# Optional
 Text
-List
+# List
 Location
 # Bool
 # True
@@ -95,7 +95,7 @@ arrow
 numeric_double_literal
 minus_infinity_literal
 plus_infinity_literal
-double_literal
+# double_literal
 natural_literal
 integer_literal
 identifier
@@ -104,7 +104,7 @@ variable
 # quoted_path_character
 unquoted_path_component
 quoted_path_component
-path_component
+# path_component
 path
 local
 parent_path
@@ -136,7 +136,7 @@ env
 bash_environment_variable
 posix_environment_variable
 posix_environment_variable_character
-import_type
+# import_type
 hash
 import_hashed
 import
@@ -160,7 +160,7 @@ not_equal_expression
 equivalent_expression
 application_expression
 first_application_expression
-import_expression
+# import_expression
 selector_expression
 selector
 labels
diff --git a/dhall_proc_macros/src/make_parser.rs b/dhall_proc_macros/src/make_parser.rs
index 268a639..3375c39 100644
--- a/dhall_proc_macros/src/make_parser.rs
+++ b/dhall_proc_macros/src/make_parser.rs
@@ -1,33 +1,101 @@
+use std::collections::HashMap;
+use std::iter;
+
 use quote::quote;
 use syn::parse::{ParseStream, Result};
 use syn::spanned::Spanned;
 use syn::{
     parse_quote, Error, Expr, FnArg, Ident, ImplItem, ImplItemMethod, ItemImpl,
-    Pat, Token,
+    Pat, Signature, Token,
 };
 
-fn apply_special_attrs(function: &mut ImplItemMethod) -> Result<()> {
+fn collect_aliases(
+    imp: &mut ItemImpl,
+) -> Result<HashMap<Ident, (Signature, Vec<Ident>)>> {
+    let mut alias_map = HashMap::new();
+
+    for item in &mut imp.items {
+        if let ImplItem::Method(function) = item {
+            let fn_name = function.sig.ident.clone();
+            let mut alias_attrs = function
+                .attrs
+                .drain_filter(|attr| attr.path.is_ident("alias"))
+                .collect::<Vec<_>>()
+                .into_iter();
+
+            if let Some(attr) = alias_attrs.next() {
+                let tgt: Ident = attr.parse_args()?;
+                alias_map
+                    .entry(tgt)
+                    .or_insert_with(|| (function.sig.clone(), Vec::new()))
+                    .1
+                    .push(fn_name);
+            }
+            if let Some(attr) = alias_attrs.next() {
+                return Err(Error::new(
+                    attr.span(),
+                    "expected at most one alias attribute",
+                ));
+            }
+        }
+    }
+
+    Ok(alias_map)
+}
+
+fn parse_rulefn_sig(sig: &Signature) -> Result<(Ident, Ident)> {
+    let fn_name = sig.ident.clone();
+    // Get the name of the first (`input`) function argument
+    let input_arg = sig.inputs.first().ok_or_else(|| {
+        Error::new(
+            sig.inputs.span(),
+            "a rule function needs an `input` argument",
+        )
+    })?;
+    let input_arg = match &input_arg {
+        FnArg::Receiver(_) => return Err(Error::new(
+            input_arg.span(),
+            "a rule function should not have a `self` argument",
+        )),
+        FnArg::Typed(input_arg) => match &*input_arg.pat{
+            Pat::Ident(ident) => ident.ident.clone(),
+            _ => return Err(Error::new(
+                input_arg.span(),
+                "this argument should be a plain identifier instead of a pattern",
+            )),
+        }
+    };
+
+    Ok((fn_name, input_arg))
+}
+
+fn apply_special_attrs(
+    function: &mut ImplItemMethod,
+    alias_map: &mut HashMap<Ident, (Signature, Vec<Ident>)>,
+    rule_enum: &Ident,
+) -> Result<()> {
     *function = parse_quote!(
         #[allow(non_snake_case, dead_code)]
         #function
     );
 
-    let recognized_attrs: Vec<_> = function
+    let (fn_name, input_arg) = parse_rulefn_sig(&function.sig)?;
+
+    // `prec_climb` attr
+    let prec_climb_attrs: Vec<_> = function
         .attrs
         .drain_filter(|attr| attr.path.is_ident("prec_climb"))
         .collect();
 
-    let name = function.sig.ident.clone();
-
-    if recognized_attrs.is_empty() {
-        // do nothing
-    } else if recognized_attrs.len() > 1 {
+    if prec_climb_attrs.len() > 1 {
         return Err(Error::new(
-            recognized_attrs[1].span(),
-            "expected a single prec_climb attribute",
+            prec_climb_attrs[1].span(),
+            "expected at most one prec_climb attribute",
         ));
+    } else if prec_climb_attrs.is_empty() {
+        // do nothing
     } else {
-        let attr = recognized_attrs.into_iter().next().unwrap();
+        let attr = prec_climb_attrs.into_iter().next().unwrap();
         let (child_rule, climber) =
             attr.parse_args_with(|input: ParseStream| {
                 let child_rule: Ident = input.parse()?;
@@ -36,35 +104,14 @@ fn apply_special_attrs(function: &mut ImplItemMethod) -> Result<()> {
                 Ok((child_rule, climber))
             })?;
 
-        // 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.block = parse_quote!({
             #function
 
             #climber.climb(
-                #first_arg.pair.clone().into_inner(),
-                |p| Self::#child_rule(#first_arg.with_pair(p)),
+                #input_arg.pair.clone().into_inner(),
+                |p| Self::#child_rule(#input_arg.with_pair(p)),
                 |l, op, r| {
-                    #name(#first_arg.clone(), l?, op, r?)
+                    #fn_name(#input_arg.clone(), l?, op, r?)
                 },
             )
         });
@@ -81,6 +128,22 @@ fn apply_special_attrs(function: &mut ImplItemMethod) -> Result<()> {
         })?;
     }
 
+    // `alias` attr
+    if let Some((_, aliases)) = alias_map.remove(&fn_name) {
+        let block = &function.block;
+        function.block = parse_quote!({
+            match #input_arg.as_rule() {
+                #(#rule_enum::#aliases => Self::#aliases(#input_arg),)*
+                #rule_enum::#fn_name => #block,
+                r => unreachable!(
+                    "make_parser: called {} on {:?}",
+                    stringify!(#fn_name),
+                    r
+                )
+            }
+        });
+    }
+
     Ok(())
 }
 
@@ -89,21 +152,69 @@ pub fn make_parser(
     input: proc_macro::TokenStream,
 ) -> Result<proc_macro2::TokenStream> {
     let rule_enum: Ident = syn::parse(attrs)?;
-
     let mut imp: ItemImpl = syn::parse(input)?;
+
+    let mut alias_map = collect_aliases(&mut imp)?;
+    let rule_alias_branches: Vec<_> = alias_map
+        .iter()
+        .flat_map(|(tgt, (_, srcs))| iter::repeat(tgt).zip(srcs))
+        .map(|(tgt, src)| {
+            quote!(
+                #rule_enum::#src => stringify!(#tgt).to_string(),
+            )
+        })
+        .collect();
+
     imp.items
         .iter_mut()
         .map(|item| match item {
-            ImplItem::Method(m) => apply_special_attrs(m),
+            ImplItem::Method(m) => {
+                apply_special_attrs(m, &mut alias_map, &rule_enum)
+            }
             _ => Ok(()),
         })
         .collect::<Result<()>>()?;
 
+    // Entries that remain in the alias map don't have a matching method, so we create one.
+    let extra_fns: Vec<_> = alias_map
+        .iter()
+        .map(|(tgt, (sig, srcs))| {
+            let mut sig = sig.clone();
+            sig.ident = tgt.clone();
+
+            let (_, input_arg) = parse_rulefn_sig(&sig)?;
+            Ok(ImplItem::Method(parse_quote!(
+                #sig {
+                    match #input_arg.as_rule() {
+                        #(#rule_enum::#srcs => Self::#srcs(#input_arg),)*
+                        r if &format!("{:?}", r) == stringify!(#tgt) =>
+                            return Err(#input_arg.error(format!(
+                                "make_parser: missing method for rule {}",
+                                stringify!(#tgt),
+                            ))),
+                        r => unreachable!(
+                            "make_parser: called {} on {:?}",
+                            stringify!(#tgt),
+                            r
+                        )
+                    }
+                }
+            )))
+        })
+        .collect::<Result<_>>()?;
+    imp.items.extend(extra_fns);
+
     let ty = &imp.self_ty;
     let (impl_generics, _, where_clause) = imp.generics.split_for_impl();
     Ok(quote!(
         impl #impl_generics PestConsumer for #ty #where_clause {
-            type RuleEnum = #rule_enum;
+            type Rule = #rule_enum;
+            fn rule_alias(rule: Self::Rule) -> String {
+                match rule {
+                    #(#rule_alias_branches)*
+                    r => format!("{:?}", r),
+                }
+            }
         }
 
         #imp
diff --git a/dhall_proc_macros/src/parse_children.rs b/dhall_proc_macros/src/parse_children.rs
index b1d43fc..a35c03f 100644
--- a/dhall_proc_macros/src/parse_children.rs
+++ b/dhall_proc_macros/src/parse_children.rs
@@ -88,9 +88,7 @@ fn make_parser_branch(
     let i_variable_pattern =
         Ident::new("___variable_pattern", Span::call_site());
     let match_pat = branch.pattern.iter().map(|item| match item {
-        Single { rule_name, .. } => {
-            quote!(<<Self as PestConsumer>::RuleEnum>::#rule_name)
-        }
+        Single { rule_name, .. } => quote!(stringify!(#rule_name)),
         Multiple { .. } => quote!(#i_variable_pattern @ ..),
     });
     let match_filter = branch.pattern.iter().map(|item| match item {
@@ -101,7 +99,7 @@ fn make_parser_branch(
                 // https://github.com/rust-lang/rust/issues/59803.
                 let all_match = |slice: &[_]| {
                     slice.iter().all(|r|
-                        r == &<<Self as PestConsumer>::RuleEnum>::#rule_name
+                        *r == stringify!(#rule_name)
                     )
                 };
                 all_match(#i_variable_pattern)
@@ -192,6 +190,11 @@ pub fn parse_children(
             .clone()
             .into_inner()
             .map(|p| p.as_rule())
+            .map(<Self as PestConsumer>::rule_alias)
+            .collect();
+        let #i_children_rules: Vec<&str> = #i_children_rules
+            .iter()
+            .map(String::as_str)
             .collect();
 
         #[allow(unused_mut)]
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index c2ba19a..bd29a27 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -66,11 +66,15 @@ impl<'input> ParseInput<'input, Rule> {
     fn as_str(&self) -> &'input str {
         self.pair.as_str()
     }
+    fn as_rule(&self) -> Rule {
+        self.pair.as_rule()
+    }
 }
 
-// Used to retrieve the `Rule` enum associated with the `Self` type in `parse_children`.
+// Used by the macros.
 trait PestConsumer {
-    type RuleEnum: pest::RuleType;
+    type Rule: pest::RuleType;
+    fn rule_alias(rule: Self::Rule) -> String;
 }
 
 fn debug_pair(pair: Pair<Rule>) -> String {
@@ -231,21 +235,17 @@ struct Parsers;
 
 #[make_parser(Rule)]
 impl Parsers {
-    fn EOI(_: ParseInput<Rule>) -> ParseResult<()> {
+    fn EOI(_input: ParseInput<Rule>) -> ParseResult<()> {
         Ok(())
     }
 
+    #[alias(label)]
     fn simple_label(input: ParseInput<Rule>) -> ParseResult<Label> {
-        Ok(Label::from(input.as_str().trim().to_owned()))
+        Ok(Label::from(input.as_str()))
     }
+    #[alias(label)]
     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,
-        ))
+        Ok(Label::from(input.as_str()))
     }
 
     fn double_quote_literal<E: Clone>(
@@ -262,17 +262,15 @@ impl Parsers {
         input: ParseInput<Rule>,
     ) -> ParseResult<ParsedTextContents<E>> {
         Ok(parse_children!(input;
-            [interpolation(e)] => {
+            [expression(e)] => {
                 InterpolatedTextContents::Expr(e)
             },
-            [double_quote_escaped(s)] => {
-                InterpolatedTextContents::Text(s)
-            },
             [double_quote_char(s)] => {
-                InterpolatedTextContents::Text(s.to_owned())
+                InterpolatedTextContents::Text(s)
             },
         ))
     }
+    #[alias(double_quote_char)]
     fn double_quote_escaped(input: ParseInput<Rule>) -> ParseResult<String> {
         Ok(match input.as_str() {
             "\"" => "\"".to_owned(),
@@ -345,8 +343,8 @@ impl Parsers {
     }
     fn double_quote_char<'a>(
         input: ParseInput<'a, Rule>,
-    ) -> ParseResult<&'a str> {
-        Ok(input.as_str())
+    ) -> ParseResult<String> {
+        Ok(input.as_str().to_owned())
     }
 
     fn single_quote_literal<E: Clone>(
@@ -356,6 +354,7 @@ impl Parsers {
             [single_quote_continue(lines)] => {
                 let newline: ParsedText<E> = "\n".to_string().into();
 
+                // Reverse lines and chars in each line
                 let mut lines: Vec<ParsedText<E>> = lines
                     .into_iter()
                     .rev()
@@ -377,44 +376,27 @@ impl Parsers {
     ) -> ParseResult<&'a str> {
         Ok(input.as_str())
     }
-    fn escaped_quote_pair<'a>(_: ParseInput<'a, Rule>) -> ParseResult<&'a str> {
+    #[alias(single_quote_char)]
+    fn escaped_quote_pair<'a>(
+        _input: ParseInput<'a, Rule>,
+    ) -> ParseResult<&'a str> {
         Ok("''")
     }
+    #[alias(single_quote_char)]
     fn escaped_interpolation<'a>(
-        _: ParseInput<'a, Rule>,
+        _input: ParseInput<'a, Rule>,
     ) -> ParseResult<&'a str> {
         Ok("${")
     }
-    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<E: Clone>(
         input: ParseInput<Rule>,
     ) -> ParseResult<Vec<Vec<ParsedTextContents<E>>>> {
         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
-            },
-            [escaped_interpolation(c), single_quote_continue(lines)] => {
+            [expression(e), single_quote_continue(lines)] => {
+                let c = InterpolatedTextContents::Expr(e);
                 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
             },
@@ -435,38 +417,41 @@ impl Parsers {
         ))
     }
 
+    #[alias(expression)]
     fn builtin<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
         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(input
-                            .error(format!("Unrecognized builtin: '{}'", s)))?,
-                    }
-                }
+        let e = 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(input.error(format!("Unrecognized builtin: '{}'", s)))?,
             },
-        ))
+        };
+        Ok(spanned(input.as_span(), e))
     }
 
-    fn NaN(_: ParseInput<Rule>) -> ParseResult<()> {
-        Ok(())
+    #[alias(double_literal)]
+    fn NaN(_input: ParseInput<Rule>) -> ParseResult<core::Double> {
+        Ok(std::f64::NAN.into())
     }
-    fn minus_infinity_literal(_: ParseInput<Rule>) -> ParseResult<()> {
-        Ok(())
+    #[alias(double_literal)]
+    fn minus_infinity_literal(
+        _input: ParseInput<Rule>,
+    ) -> ParseResult<core::Double> {
+        Ok(std::f64::NEG_INFINITY.into())
     }
-    fn plus_infinity_literal(_: ParseInput<Rule>) -> ParseResult<()> {
-        Ok(())
+    #[alias(double_literal)]
+    fn plus_infinity_literal(
+        _input: ParseInput<Rule>,
+    ) -> ParseResult<core::Double> {
+        Ok(std::f64::INFINITY.into())
     }
 
+    #[alias(double_literal)]
     fn numeric_double_literal(
         input: ParseInput<Rule>,
     ) -> ParseResult<core::Double> {
@@ -481,15 +466,6 @@ impl Parsers {
         }
     }
 
-    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()
@@ -506,13 +482,13 @@ impl Parsers {
             .map_err(|e| input.error(format!("{}", e)))
     }
 
+    #[alias(expression)]
     fn identifier<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
-        let span = input.as_span();
         Ok(parse_children!(input;
             [variable(v)] => {
-                spanned(span, Var(v))
+                spanned(input.as_span(), Var(v))
             },
-            [builtin(e)] => e,
+            [expression(e)] => e,
         ))
     }
 
@@ -527,42 +503,40 @@ impl Parsers {
         ))
     }
 
+    #[alias(path_component)]
     fn unquoted_path_component<'a>(
         input: ParseInput<'a, Rule>,
-    ) -> ParseResult<&'a str> {
-        Ok(input.as_str())
+    ) -> ParseResult<String> {
+        Ok(input.as_str().to_string())
     }
+    #[alias(path_component)]
     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()
-            },
-        ))
+    ) -> ParseResult<String> {
+        #[rustfmt::skip]
+        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';');
+        Ok(input
+            .as_str()
+            .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;
@@ -572,17 +546,16 @@ impl Parsers {
         ))
     }
 
-    fn local(
+    #[alias(import_type)]
+    fn local<E: Clone>(
         input: ParseInput<Rule>,
-    ) -> ParseResult<(FilePrefix, Vec<String>)> {
+    ) -> ParseResult<ImportLocation<Expr<E>>> {
         Ok(parse_children!(input;
-            [parent_path(l)] => l,
-            [here_path(l)] => l,
-            [home_path(l)] => l,
-            [absolute_path(l)] => l,
+            [local_path((prefix, p))] => ImportLocation::Local(prefix, p),
         ))
     }
 
+    #[alias(local_path)]
     fn parent_path(
         input: ParseInput<Rule>,
     ) -> ParseResult<(FilePrefix, Vec<String>)> {
@@ -590,6 +563,7 @@ impl Parsers {
             [path(p)] => (FilePrefix::Parent, p)
         ))
     }
+    #[alias(local_path)]
     fn here_path(
         input: ParseInput<Rule>,
     ) -> ParseResult<(FilePrefix, Vec<String>)> {
@@ -597,6 +571,7 @@ impl Parsers {
             [path(p)] => (FilePrefix::Here, p)
         ))
     }
+    #[alias(local_path)]
     fn home_path(
         input: ParseInput<Rule>,
     ) -> ParseResult<(FilePrefix, Vec<String>)> {
@@ -604,6 +579,7 @@ impl Parsers {
             [path(p)] => (FilePrefix::Home, p)
         ))
     }
+    #[alias(local_path)]
     fn absolute_path(
         input: ParseInput<Rule>,
     ) -> ParseResult<(FilePrefix, Vec<String>)> {
@@ -649,25 +625,31 @@ impl Parsers {
         Ok(input.as_str().to_owned())
     }
 
-    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)] =>
-            URL { headers: Some(e), ..url },
-        ))
+    #[alias(import_type)]
+    fn http<E: Clone>(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<ImportLocation<Expr<E>>> {
+        Ok(ImportLocation::Remote(parse_children!(input;
+            [http_raw(url)] => url,
+            [http_raw(url), expression(e)] => URL { headers: Some(e), ..url },
+        )))
     }
 
-    fn env(input: ParseInput<Rule>) -> ParseResult<String> {
+    #[alias(import_type)]
+    fn env<E: Clone>(
+        input: ParseInput<Rule>,
+    ) -> ParseResult<ImportLocation<Expr<E>>> {
         Ok(parse_children!(input;
-            [bash_environment_variable(s)] => s,
-            [posix_environment_variable(s)] => s,
+            [environment_variable(v)] => ImportLocation::Env(v),
         ))
     }
+    #[alias(environment_variable)]
     fn bash_environment_variable(
         input: ParseInput<Rule>,
     ) -> ParseResult<String> {
         Ok(input.as_str().to_owned())
     }
+    #[alias(environment_variable)]
     fn posix_environment_variable(
         input: ParseInput<Rule>,
     ) -> ParseResult<String> {
@@ -694,27 +676,11 @@ impl Parsers {
         })
     }
 
-    fn missing(_: ParseInput<Rule>) -> ParseResult<()> {
-        Ok(())
-    }
-
-    fn import_type<E: Clone>(
-        input: ParseInput<Rule>,
+    #[alias(import_type)]
+    fn missing<E: Clone>(
+        _input: ParseInput<Rule>,
     ) -> ParseResult<ImportLocation<Expr<E>>> {
-        Ok(parse_children!(input;
-            [missing(_)] => {
-                ImportLocation::Missing
-            },
-            [env(e)] => {
-                ImportLocation::Env(e)
-            },
-            [http(url)] => {
-                ImportLocation::Remote(url)
-            },
-            [local((prefix, p))] => {
-                ImportLocation::Local(prefix, p)
-            },
-        ))
+        Ok(ImportLocation::Missing)
     }
 
     fn hash(input: ParseInput<Rule>) -> ParseResult<Hash> {
@@ -730,78 +696,65 @@ impl Parsers {
     fn import_hashed<E: Clone>(
         input: ParseInput<Rule>,
     ) -> ParseResult<crate::Import<Expr<E>>> {
+        use crate::Import;
+        let mode = ImportMode::Code;
         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) },
+            [import_type(location)] => Import { mode, location, hash: None },
+            [import_type(location), hash(h)] => Import { mode, location, hash: Some(h) },
         ))
     }
 
-    fn Text(_: ParseInput<Rule>) -> ParseResult<()> {
-        Ok(())
+    #[alias(import_mode)]
+    fn Text(_input: ParseInput<Rule>) -> ParseResult<ImportMode> {
+        Ok(ImportMode::RawText)
     }
-    fn Location(_: ParseInput<Rule>) -> ParseResult<()> {
-        Ok(())
+    #[alias(import_mode)]
+    fn Location(_input: ParseInput<Rule>) -> ParseResult<ImportMode> {
+        Ok(ImportMode::Location)
     }
 
+    #[alias(expression)]
     fn import<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
-        let span = input.as_span();
-        Ok(parse_children!(input;
+        use crate::Import;
+        let import = 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 { mode: ImportMode::Code, ..imp }
             },
-            [import_hashed(imp), Location(_)] => {
-                spanned(span, Import(crate::Import {
-                    mode: ImportMode::Location,
-                    ..imp
-                }))
+            [import_hashed(imp), import_mode(mode)] => {
+                Import { mode, ..imp }
             },
-        ))
+        );
+        Ok(spanned(input.as_span(), Import(import)))
     }
 
-    fn lambda(_: ParseInput<Rule>) -> ParseResult<()> {
+    fn lambda(_input: ParseInput<Rule>) -> ParseResult<()> {
         Ok(())
     }
-    fn forall(_: ParseInput<Rule>) -> ParseResult<()> {
+    fn forall(_input: ParseInput<Rule>) -> ParseResult<()> {
         Ok(())
     }
-    fn arrow(_: ParseInput<Rule>) -> ParseResult<()> {
+    fn arrow(_input: ParseInput<Rule>) -> ParseResult<()> {
         Ok(())
     }
-    fn merge(_: ParseInput<Rule>) -> ParseResult<()> {
+    fn merge(_input: ParseInput<Rule>) -> ParseResult<()> {
         Ok(())
     }
-    fn assert(_: ParseInput<Rule>) -> ParseResult<()> {
+    fn assert(_input: ParseInput<Rule>) -> ParseResult<()> {
         Ok(())
     }
-    fn if_(_: ParseInput<Rule>) -> ParseResult<()> {
+    fn if_(_input: ParseInput<Rule>) -> ParseResult<()> {
         Ok(())
     }
-    fn in_(_: ParseInput<Rule>) -> ParseResult<()> {
-        Ok(())
-    }
-    fn toMap(_: ParseInput<Rule>) -> ParseResult<()> {
+    fn toMap(_input: ParseInput<Rule>) -> ParseResult<()> {
         Ok(())
     }
 
+    #[alias(expression)]
     fn empty_list_literal<E: Clone>(
         input: ParseInput<Rule>,
     ) -> ParseResult<Expr<E>> {
-        let span = input.as_span();
         Ok(parse_children!(input;
-            [application_expression(e)] => {
-                spanned(span, EmptyListLit(e))
-            },
+            [expression(e)] => spanned(input.as_span(), EmptyListLit(e)),
         ))
     }
 
@@ -816,7 +769,7 @@ impl Parsers {
                     expression(right)] => {
                 spanned(span, BoolIf(cond, left, right))
             },
-            [let_binding(bindings).., in_(()), expression(final_expr)] => {
+            [let_binding(bindings).., expression(final_expr)] => {
                 bindings.rev().fold(
                     final_expr,
                     |acc, x| unspanned(Let(x.0, x.1, x.2, acc))
@@ -826,24 +779,22 @@ impl Parsers {
                     arrow(()), expression(body)] => {
                 spanned(span, Pi(l, typ, body))
             },
-            [operator_expression(typ), arrow(()), expression(body)] => {
+            [expression(typ), arrow(()), expression(body)] => {
                 spanned(span, Pi("_".into(), typ, body))
             },
-            [merge(()), import_expression(x), import_expression(y),
-                    application_expression(z)] => {
+            [merge(()), expression(x), expression(y), 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)] => {
+            [toMap(()), expression(x), expression(y)] => {
                 spanned(span, ToMap(x, Some(y)))
             },
-            [operator_expression(e)] => e,
-            [operator_expression(e), expression(annot)] => {
+            [expression(e), expression(annot)] => {
                 spanned(span, Annot(e, annot))
             },
+            [expression(e)] => e,
         ))
     }
 
@@ -858,14 +809,8 @@ impl Parsers {
         ))
     }
 
-    fn List(_: ParseInput<Rule>) -> ParseResult<()> {
-        Ok(())
-    }
-    fn Optional(_: ParseInput<Rule>) -> ParseResult<()> {
-        Ok(())
-    }
-
-    #[prec_climb(application_expression, PRECCLIMBER)]
+    #[alias(expression)]
+    #[prec_climb(expression, PRECCLIMBER)]
     fn operator_expression<E: Clone>(
         input: ParseInput<Rule>,
         l: Expr<E>,
@@ -894,55 +839,48 @@ impl Parsers {
         Ok(unspanned(BinOp(op, l, r)))
     }
 
-    fn Some_(_: ParseInput<Rule>) -> ParseResult<()> {
+    fn Some_(_input: ParseInput<Rule>) -> ParseResult<()> {
         Ok(())
     }
 
+    #[alias(expression)]
     fn application_expression<E: Clone>(
         input: ParseInput<Rule>,
     ) -> ParseResult<Expr<E>> {
         Ok(parse_children!(input;
-            [first_application_expression(e)] => e,
-            [first_application_expression(first),
-                    import_expression(rest)..] => {
+            [expression(e)] => e,
+            [expression(first), expression(rest)..] => {
                 rest.fold(first, |acc, e| unspanned(App(acc, e)))
             },
         ))
     }
 
+    #[alias(expression)]
     fn first_application_expression<E: Clone>(
         input: ParseInput<Rule>,
     ) -> ParseResult<Expr<E>> {
         let span = input.as_span();
         Ok(parse_children!(input;
-            [Some_(()), import_expression(e)] => {
+            [Some_(()), expression(e)] => {
                 spanned(span, SomeLit(e))
             },
-            [merge(()), import_expression(x), import_expression(y)] => {
+            [merge(()), expression(x), expression(y)] => {
                 spanned(span, Merge(x, y, None))
             },
-            [toMap(()), import_expression(x)] => {
+            [toMap(()), expression(x)] => {
                 spanned(span, ToMap(x, None))
             },
-            [import_expression(e)] => e,
-        ))
-    }
-
-    fn import_expression<E: Clone>(
-        input: ParseInput<Rule>,
-    ) -> ParseResult<Expr<E>> {
-        Ok(parse_children!(input;
-            [selector_expression(e)] => e,
-            [import(e)] => e,
+            [expression(e)] => e,
         ))
     }
 
+    #[alias(expression)]
     fn selector_expression<E: Clone>(
         input: ParseInput<Rule>,
     ) -> ParseResult<Expr<E>> {
         Ok(parse_children!(input;
-            [primitive_expression(e)] => e,
-            [primitive_expression(first), selector(rest)..] => {
+            [expression(e)] => e,
+            [expression(first), selector(rest)..] => {
                 rest.fold(first, |acc, e| unspanned(match e {
                     Either::Left(l) => Field(acc, l),
                     Either::Right(ls) => Projection(acc, ls),
@@ -967,6 +905,7 @@ impl Parsers {
         ))
     }
 
+    #[alias(expression)]
     fn primitive_expression<E: Clone>(
         input: ParseInput<Rule>,
     ) -> ParseResult<Expr<E>> {
@@ -977,46 +916,41 @@ impl Parsers {
             [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,
         ))
     }
 
+    #[alias(expression)]
     fn empty_record_literal<E: Clone>(
         input: ParseInput<Rule>,
     ) -> ParseResult<Expr<E>> {
-        let span = input.as_span();
-        Ok(spanned(span, RecordLit(Default::default())))
+        Ok(spanned(input.as_span(), RecordLit(Default::default())))
     }
 
+    #[alias(expression)]
     fn empty_record_type<E: Clone>(
         input: ParseInput<Rule>,
     ) -> ParseResult<Expr<E>> {
-        let span = input.as_span();
-        Ok(spanned(span, RecordType(Default::default())))
+        Ok(spanned(input.as_span(), RecordType(Default::default())))
     }
 
+    #[alias(expression)]
     fn non_empty_record_type_or_literal<E: Clone>(
         input: ParseInput<Rule>,
     ) -> ParseResult<Expr<E>> {
-        let span = input.as_span();
-        Ok(parse_children!(input;
+        let e = 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))
+                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))
+                RecordLit(map)
             },
-        ))
+        );
+        Ok(spanned(input.as_span(), e))
     }
 
     fn non_empty_record_type<E: Clone>(
@@ -1055,19 +989,16 @@ impl Parsers {
         ))
     }
 
+    #[alias(expression)]
     fn union_type<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
-        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()))
-            },
-        ))
+        let map = parse_children!(input;
+            [empty_union_type(_)] => Default::default(),
+            [union_type_entry(entries)..] => entries.collect(),
+        );
+        Ok(spanned(input.as_span(), UnionType(map)))
     }
 
-    fn empty_union_type(_: ParseInput<Rule>) -> ParseResult<()> {
+    fn empty_union_type(_input: ParseInput<Rule>) -> ParseResult<()> {
         Ok(())
     }
 
@@ -1080,13 +1011,13 @@ impl Parsers {
         ))
     }
 
+    #[alias(expression)]
     fn non_empty_list_literal<E: Clone>(
         input: ParseInput<Rule>,
     ) -> ParseResult<Expr<E>> {
-        let span = input.as_span();
         Ok(parse_children!(input;
             [expression(items)..] => spanned(
-                span,
+                input.as_span(),
                 NEListLit(items.collect())
             )
         ))
diff --git a/tests_buffer b/tests_buffer
index 6597d69..1c4cde5 100644
--- a/tests_buffer
+++ b/tests_buffer
@@ -4,6 +4,7 @@ parser:
 text interpolation and escapes
 projection by expression unit tests
 fix fakeurlencode test
+s/QuotedVariable/VariableQuoted/
 success/
     operators/
         PrecedenceAll1 a ? b || c + d ++ e # f && g ∧ h ⫽ i ⩓ j * k == l != m n.o
@@ -13,6 +14,7 @@ success/
     EmptyRecordLiteral {=}
     ToMap toMap x
     ToMapAnnot toMap x : T
+    VariableQuotedSpace ` x `
 failure/
     AssertNoAnnotation assert
 
-- 
cgit v1.3.1


From 9f1c5fe4c5ea275f85d8920351591378dd87ab71 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 5 Sep 2019 22:42:36 +0200
Subject: Implement rule shortcutting, and cleanup make_parser code

---
 dhall_proc_macros/src/make_parser.rs | 234 ++++++++++++++++++++++++++---------
 dhall_syntax/src/parser.rs           |  23 +++-
 2 files changed, 190 insertions(+), 67 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_proc_macros/src/make_parser.rs b/dhall_proc_macros/src/make_parser.rs
index 3375c39..a17ab61 100644
--- a/dhall_proc_macros/src/make_parser.rs
+++ b/dhall_proc_macros/src/make_parser.rs
@@ -2,53 +2,122 @@ use std::collections::HashMap;
 use std::iter;
 
 use quote::quote;
-use syn::parse::{ParseStream, Result};
+use syn::parse::{Parse, ParseStream, Result};
 use syn::spanned::Spanned;
 use syn::{
     parse_quote, Error, Expr, FnArg, Ident, ImplItem, ImplItemMethod, ItemImpl,
-    Pat, Signature, Token,
+    LitBool, Pat, Token,
 };
 
+mod kw {
+    syn::custom_keyword!(shortcut);
+}
+
+struct AliasArgs {
+    target: Ident,
+    is_shortcut: bool,
+}
+
+struct PrecClimbArgs {
+    child_rule: Ident,
+    climber: Expr,
+}
+
+struct AliasSrc {
+    ident: Ident,
+    is_shortcut: bool,
+}
+
+struct ParsedFn<'a> {
+    // Body of the function
+    function: &'a mut ImplItemMethod,
+    // Name of the function.
+    fn_name: Ident,
+    // Name of the first argument of the function, which should be of type `ParseInput`.
+    input_arg: Ident,
+    // List of aliases pointing to this function
+    alias_srcs: Vec<AliasSrc>,
+}
+
+impl Parse for AliasArgs {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let target = input.parse()?;
+        let is_shortcut = if input.peek(Token![,]) {
+            // #[alias(rule, shortcut = true)]
+            let _: Token![,] = input.parse()?;
+            let _: kw::shortcut = input.parse()?;
+            let _: Token![=] = input.parse()?;
+            let b: LitBool = input.parse()?;
+            b.value
+        } else {
+            // #[alias(rule)]
+            false
+        };
+        Ok(AliasArgs {
+            target,
+            is_shortcut,
+        })
+    }
+}
+
+impl Parse for PrecClimbArgs {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let child_rule = input.parse()?;
+        let _: Token![,] = input.parse()?;
+        let climber = input.parse()?;
+        Ok(PrecClimbArgs {
+            child_rule,
+            climber,
+        })
+    }
+}
+
 fn collect_aliases(
     imp: &mut ItemImpl,
-) -> Result<HashMap<Ident, (Signature, Vec<Ident>)>> {
+) -> Result<HashMap<Ident, Vec<AliasSrc>>> {
+    let functions = imp.items.iter_mut().flat_map(|item| match item {
+        ImplItem::Method(m) => Some(m),
+        _ => None,
+    });
+
     let mut alias_map = HashMap::new();
+    for function in functions {
+        let fn_name = function.sig.ident.clone();
+        let mut alias_attrs = function
+            .attrs
+            .drain_filter(|attr| attr.path.is_ident("alias"))
+            .collect::<Vec<_>>()
+            .into_iter();
 
-    for item in &mut imp.items {
-        if let ImplItem::Method(function) = item {
-            let fn_name = function.sig.ident.clone();
-            let mut alias_attrs = function
-                .attrs
-                .drain_filter(|attr| attr.path.is_ident("alias"))
-                .collect::<Vec<_>>()
-                .into_iter();
-
-            if let Some(attr) = alias_attrs.next() {
-                let tgt: Ident = attr.parse_args()?;
-                alias_map
-                    .entry(tgt)
-                    .or_insert_with(|| (function.sig.clone(), Vec::new()))
-                    .1
-                    .push(fn_name);
-            }
-            if let Some(attr) = alias_attrs.next() {
-                return Err(Error::new(
-                    attr.span(),
-                    "expected at most one alias attribute",
-                ));
-            }
+        if let Some(attr) = alias_attrs.next() {
+            let args: AliasArgs = attr.parse_args()?;
+            alias_map.entry(args.target).or_insert_with(Vec::new).push(
+                AliasSrc {
+                    ident: fn_name,
+                    is_shortcut: args.is_shortcut,
+                },
+            );
+        }
+        if let Some(attr) = alias_attrs.next() {
+            return Err(Error::new(
+                attr.span(),
+                "expected at most one alias attribute",
+            ));
         }
     }
 
     Ok(alias_map)
 }
 
-fn parse_rulefn_sig(sig: &Signature) -> Result<(Ident, Ident)> {
-    let fn_name = sig.ident.clone();
+fn parse_fn<'a>(
+    function: &'a mut ImplItemMethod,
+    alias_map: &mut HashMap<Ident, Vec<AliasSrc>>,
+) -> Result<ParsedFn<'a>> {
+    let fn_name = function.sig.ident.clone();
     // Get the name of the first (`input`) function argument
-    let input_arg = sig.inputs.first().ok_or_else(|| {
+    let input_arg = function.sig.inputs.first().ok_or_else(|| {
         Error::new(
-            sig.inputs.span(),
+            function.sig.inputs.span(),
             "a rule function needs an `input` argument",
         )
     })?;
@@ -66,21 +135,26 @@ fn parse_rulefn_sig(sig: &Signature) -> Result<(Ident, Ident)> {
         }
     };
 
-    Ok((fn_name, input_arg))
+    let alias_srcs = alias_map.remove(&fn_name).unwrap_or_else(Vec::new);
+
+    Ok(ParsedFn {
+        function,
+        fn_name,
+        input_arg,
+        alias_srcs,
+    })
 }
 
-fn apply_special_attrs(
-    function: &mut ImplItemMethod,
-    alias_map: &mut HashMap<Ident, (Signature, Vec<Ident>)>,
-    rule_enum: &Ident,
-) -> Result<()> {
+fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Ident) -> Result<()> {
+    let function = &mut *f.function;
+    let fn_name = &f.fn_name;
+    let input_arg = &f.input_arg;
+
     *function = parse_quote!(
-        #[allow(non_snake_case, dead_code)]
+        #[allow(non_snake_case)]
         #function
     );
 
-    let (fn_name, input_arg) = parse_rulefn_sig(&function.sig)?;
-
     // `prec_climb` attr
     let prec_climb_attrs: Vec<_> = function
         .attrs
@@ -96,13 +170,10 @@ fn apply_special_attrs(
         // do nothing
     } else {
         let attr = prec_climb_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 PrecClimbArgs {
+            child_rule,
+            climber,
+        } = attr.parse_args()?;
 
         function.block = parse_quote!({
             #function
@@ -129,9 +200,24 @@ fn apply_special_attrs(
     }
 
     // `alias` attr
-    if let Some((_, aliases)) = alias_map.remove(&fn_name) {
+    if !f.alias_srcs.is_empty() {
+        let aliases = f.alias_srcs.iter().map(|src| &src.ident);
         let block = &function.block;
         function.block = parse_quote!({
+            let mut #input_arg = #input_arg;
+            // While the current rule allows shortcutting, and there is a single child, and the
+            // child can still be parsed by the current function, then skip to that child.
+            while <Self as PestConsumer>::allows_shortcut(#input_arg.as_rule()) {
+                if let Some(child) = #input_arg.single_child() {
+                    if &<Self as PestConsumer>::rule_alias(child.as_rule())
+                            == stringify!(#fn_name) {
+                        #input_arg = child;
+                        continue;
+                    }
+                }
+                break
+            }
+
             match #input_arg.as_rule() {
                 #(#rule_enum::#aliases => Self::#aliases(#input_arg),)*
                 #rule_enum::#fn_name => #block,
@@ -157,36 +243,56 @@ pub fn make_parser(
     let mut alias_map = collect_aliases(&mut imp)?;
     let rule_alias_branches: Vec<_> = alias_map
         .iter()
-        .flat_map(|(tgt, (_, srcs))| iter::repeat(tgt).zip(srcs))
+        .flat_map(|(tgt, srcs)| iter::repeat(tgt).zip(srcs))
         .map(|(tgt, src)| {
+            let ident = &src.ident;
+            quote!(
+                #rule_enum::#ident => stringify!(#tgt).to_string(),
+            )
+        })
+        .collect();
+    let shortcut_branches: Vec<_> = alias_map
+        .iter()
+        .flat_map(|(_tgt, srcs)| srcs)
+        .map(|AliasSrc { ident, is_shortcut }| {
             quote!(
-                #rule_enum::#src => stringify!(#tgt).to_string(),
+                #rule_enum::#ident => #is_shortcut,
             )
         })
         .collect();
 
-    imp.items
+    let fn_map: HashMap<Ident, ParsedFn> = imp
+        .items
         .iter_mut()
-        .map(|item| match item {
-            ImplItem::Method(m) => {
-                apply_special_attrs(m, &mut alias_map, &rule_enum)
-            }
-            _ => Ok(()),
+        .flat_map(|item| match item {
+            ImplItem::Method(m) => Some(m),
+            _ => None,
         })
-        .collect::<Result<()>>()?;
+        .map(|method| {
+            let mut f = parse_fn(method, &mut alias_map)?;
+            apply_special_attrs(&mut f, &rule_enum)?;
+            Ok((f.fn_name.clone(), f))
+        })
+        .collect::<Result<_>>()?;
 
     // Entries that remain in the alias map don't have a matching method, so we create one.
     let extra_fns: Vec<_> = alias_map
         .iter()
-        .map(|(tgt, (sig, srcs))| {
-            let mut sig = sig.clone();
+        .map(|(tgt, srcs)| {
+            // Get the signature of one of the functions that has this alias. They should all have
+            // essentially the same signature anyways.
+            let f = fn_map.get(&srcs.first().unwrap().ident).unwrap();
+            let input_arg = f.input_arg.clone();
+            let mut sig = f.function.sig.clone();
             sig.ident = tgt.clone();
+            let srcs = srcs.iter().map(|src| &src.ident);
 
-            let (_, input_arg) = parse_rulefn_sig(&sig)?;
-            Ok(ImplItem::Method(parse_quote!(
+            Ok(parse_quote!(
                 #sig {
                     match #input_arg.as_rule() {
                         #(#rule_enum::#srcs => Self::#srcs(#input_arg),)*
+                        // We can't match on #rule_enum::#tgt since `tgt` might be an arbitrary
+                        // identifier.
                         r if &format!("{:?}", r) == stringify!(#tgt) =>
                             return Err(#input_arg.error(format!(
                                 "make_parser: missing method for rule {}",
@@ -199,7 +305,7 @@ pub fn make_parser(
                         )
                     }
                 }
-            )))
+            ))
         })
         .collect::<Result<_>>()?;
     imp.items.extend(extra_fns);
@@ -215,6 +321,12 @@ pub fn make_parser(
                     r => format!("{:?}", r),
                 }
             }
+            fn allows_shortcut(rule: Self::Rule) -> bool {
+                match rule {
+                    #(#shortcut_branches)*
+                    _ => false,
+                }
+            }
         }
 
         #imp
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index bd29a27..3f961e8 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -60,6 +60,16 @@ impl<'input> ParseInput<'input, Rule> {
             original_input_str: self.original_input_str.clone(),
         }
     }
+    /// If the contained pair has exactly one child, return a new Self containing it.
+    fn single_child(&self) -> Option<Self> {
+        let mut children = self.pair.clone().into_inner();
+        if let Some(child) = children.next() {
+            if children.next().is_none() {
+                return Some(self.with_pair(child));
+            }
+        }
+        None
+    }
     fn as_span(&self) -> Span {
         Span::make(self.original_input_str.clone(), self.pair.as_span())
     }
@@ -75,6 +85,7 @@ impl<'input> ParseInput<'input, Rule> {
 trait PestConsumer {
     type Rule: pest::RuleType;
     fn rule_alias(rule: Self::Rule) -> String;
+    fn allows_shortcut(rule: Self::Rule) -> bool;
 }
 
 fn debug_pair(pair: Pair<Rule>) -> String {
@@ -482,7 +493,7 @@ impl Parsers {
             .map_err(|e| input.error(format!("{}", e)))
     }
 
-    #[alias(expression)]
+    #[alias(expression, shortcut = true)]
     fn identifier<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> {
         Ok(parse_children!(input;
             [variable(v)] => {
@@ -809,7 +820,7 @@ impl Parsers {
         ))
     }
 
-    #[alias(expression)]
+    #[alias(expression, shortcut = true)]
     #[prec_climb(expression, PRECCLIMBER)]
     fn operator_expression<E: Clone>(
         input: ParseInput<Rule>,
@@ -843,7 +854,7 @@ impl Parsers {
         Ok(())
     }
 
-    #[alias(expression)]
+    #[alias(expression, shortcut = true)]
     fn application_expression<E: Clone>(
         input: ParseInput<Rule>,
     ) -> ParseResult<Expr<E>> {
@@ -855,7 +866,7 @@ impl Parsers {
         ))
     }
 
-    #[alias(expression)]
+    #[alias(expression, shortcut = true)]
     fn first_application_expression<E: Clone>(
         input: ParseInput<Rule>,
     ) -> ParseResult<Expr<E>> {
@@ -874,7 +885,7 @@ impl Parsers {
         ))
     }
 
-    #[alias(expression)]
+    #[alias(expression, shortcut = true)]
     fn selector_expression<E: Clone>(
         input: ParseInput<Rule>,
     ) -> ParseResult<Expr<E>> {
@@ -905,7 +916,7 @@ impl Parsers {
         ))
     }
 
-    #[alias(expression)]
+    #[alias(expression, shortcut = true)]
     fn primitive_expression<E: Clone>(
         input: ParseInput<Rule>,
     ) -> ParseResult<Expr<E>> {
-- 
cgit v1.3.1