From 5895c3aa6552f75d7e5202be561f9734fe8945e7 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 13 Aug 2019 19:31:23 +0200
Subject: No need to track the absence of `Span`s at the type level

---
 dhall_syntax/src/core/expr.rs    | 131 +++++++++++++++++++--------------------
 dhall_syntax/src/core/visitor.rs |  40 ++++--------
 dhall_syntax/src/parser.rs       |  39 ++----------
 dhall_syntax/src/printer.rs      |  12 ++--
 4 files changed, 84 insertions(+), 138 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index 6522cb1..0cbece3 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -19,6 +19,30 @@ pub fn trivial_result<T>(x: Result<T, X>) -> T {
     }
 }
 
+/// A location in the source text
+#[derive(Debug, Clone)]
+pub struct Span {
+    input: Rc<str>,
+    /// # Safety
+    ///
+    /// Must be a valid character boundary index into `input`.
+    start: usize,
+    /// # Safety
+    ///
+    /// Must be a valid character boundary index into `input`.
+    end: usize,
+}
+
+impl Span {
+    pub(crate) fn make(input: Rc<str>, sp: pest::Span) -> Self {
+        Span {
+            input,
+            start: sp.start(),
+            end: sp.end(),
+        }
+    }
+}
+
 /// Double with bitwise equality
 #[derive(Debug, Copy, Clone)]
 pub struct NaiveDouble(f64);
@@ -137,23 +161,19 @@ pub enum Builtin {
     TextShow,
 }
 
-pub type ParsedExpr = SubExpr<X, Import>;
-pub type ResolvedExpr = SubExpr<X, X>;
-pub type DhallExpr = ResolvedExpr;
-
 // Each node carries an annotation. In practice it's either X (no annotation) or a Span.
 #[derive(Debug)]
-pub struct SubExpr<Note, Embed>(Rc<(Expr<Note, Embed>, Option<Note>)>);
+pub struct SubExpr<Embed>(Rc<(Expr<Embed>, Option<Span>)>);
 
-impl<Note, Embed: PartialEq> std::cmp::PartialEq for SubExpr<Note, Embed> {
+impl<Embed: PartialEq> std::cmp::PartialEq for SubExpr<Embed> {
     fn eq(&self, other: &Self) -> bool {
         self.0.as_ref().0 == other.0.as_ref().0
     }
 }
 
-impl<Note, Embed: Eq> std::cmp::Eq for SubExpr<Note, Embed> {}
+impl<Embed: Eq> std::cmp::Eq for SubExpr<Embed> {}
 
-pub type Expr<Note, Embed> = ExprF<SubExpr<Note, Embed>, Embed>;
+pub type Expr<Embed> = ExprF<SubExpr<Embed>, Embed>;
 
 /// Syntax tree for expressions
 // Having the recursion out of the enum definition enables writing
@@ -293,31 +313,22 @@ impl<SE, E> ExprF<SE, E> {
     }
 }
 
-impl<N, E> Expr<N, E> {
+impl<E> Expr<E> {
     fn traverse_embed<E2, Err>(
         &self,
         visit_embed: impl FnMut(&E) -> Result<E2, Err>,
-    ) -> Result<Expr<N, E2>, Err>
-    where
-        N: Clone,
-    {
+    ) -> Result<Expr<E2>, Err> {
         self.visit(&mut visitor::TraverseEmbedVisitor(visit_embed))
     }
 
-    fn map_embed<E2>(&self, mut map_embed: impl FnMut(&E) -> E2) -> Expr<N, E2>
-    where
-        N: Clone,
-    {
+    fn map_embed<E2>(&self, mut map_embed: impl FnMut(&E) -> E2) -> Expr<E2> {
         trivial_result(self.traverse_embed(|x| Ok(map_embed(x))))
     }
 
     pub fn traverse_resolve<E2, Err>(
         &self,
         visit_embed: impl FnMut(&E) -> Result<E2, Err>,
-    ) -> Result<Expr<N, E2>, Err>
-    where
-        N: Clone,
-    {
+    ) -> Result<Expr<E2>, Err> {
         self.traverse_resolve_with_visitor(&mut visitor::ResolveVisitor(
             visit_embed,
         ))
@@ -326,9 +337,8 @@ impl<N, E> Expr<N, E> {
     pub(crate) fn traverse_resolve_with_visitor<E2, Err, F1>(
         &self,
         visitor: &mut visitor::ResolveVisitor<F1>,
-    ) -> Result<Expr<N, E2>, Err>
+    ) -> Result<Expr<E2>, Err>
     where
-        N: Clone,
         F1: FnMut(&E) -> Result<E2, Err>,
     {
         match self {
@@ -341,59 +351,44 @@ impl<N, E> Expr<N, E> {
     }
 }
 
-impl Expr<X, X> {
-    pub fn absurd<N, E>(&self) -> Expr<N, E> {
+impl Expr<X> {
+    pub fn absurd<E>(&self) -> Expr<E> {
         self.visit(&mut visitor::AbsurdVisitor)
     }
 }
 
-impl<E: Clone> Expr<X, E> {
-    pub fn note_absurd<N>(&self) -> Expr<N, E> {
-        self.visit(&mut visitor::NoteAbsurdVisitor)
-    }
-}
-
-impl<N, E> SubExpr<N, E> {
-    pub fn as_ref(&self) -> &Expr<N, E> {
+impl<E> SubExpr<E> {
+    pub fn as_ref(&self) -> &Expr<E> {
         &self.0.as_ref().0
     }
 
-    pub fn new(x: Expr<N, E>, n: N) -> Self {
+    pub fn new(x: Expr<E>, n: Span) -> Self {
         SubExpr(Rc::new((x, Some(n))))
     }
 
-    pub fn from_expr_no_note(x: Expr<N, E>) -> Self {
+    pub fn from_expr_no_span(x: Expr<E>) -> Self {
         SubExpr(Rc::new((x, None)))
     }
 
     pub fn from_builtin(b: Builtin) -> Self {
-        SubExpr::from_expr_no_note(ExprF::Builtin(b))
+        SubExpr::from_expr_no_span(ExprF::Builtin(b))
     }
 
-    pub fn rewrap<E2>(&self, x: Expr<N, E2>) -> SubExpr<N, E2>
-    where
-        N: Clone,
-    {
+    pub fn rewrap<E2>(&self, x: Expr<E2>) -> SubExpr<E2> {
         SubExpr(Rc::new((x, (self.0).1.clone())))
     }
 
     pub fn traverse_embed<E2, Err>(
         &self,
         visit_embed: impl FnMut(&E) -> Result<E2, Err>,
-    ) -> Result<SubExpr<N, E2>, Err>
-    where
-        N: Clone,
-    {
+    ) -> Result<SubExpr<E2>, Err> {
         Ok(self.rewrap(self.as_ref().traverse_embed(visit_embed)?))
     }
 
     pub fn map_embed<E2>(
         &self,
         map_embed: impl FnMut(&E) -> E2,
-    ) -> SubExpr<N, E2>
-    where
-        N: Clone,
-    {
+    ) -> SubExpr<E2> {
         self.rewrap(self.as_ref().map_embed(map_embed))
     }
 
@@ -401,10 +396,7 @@ impl<N, E> SubExpr<N, E> {
         &'a self,
         map_expr: impl FnMut(&'a Self) -> Self,
         map_under_binder: impl FnMut(&'a Label, &'a Self) -> Self,
-    ) -> Self
-    where
-        N: Clone,
-    {
+    ) -> Self {
         match self.as_ref() {
             ExprF::Embed(_) => SubExpr::clone(self),
             // This calls ExprF::map_ref
@@ -419,35 +411,38 @@ impl<N, E> SubExpr<N, E> {
     pub fn traverse_resolve<E2, Err>(
         &self,
         visit_embed: impl FnMut(&E) -> Result<E2, Err>,
-    ) -> Result<SubExpr<N, E2>, Err>
-    where
-        N: Clone,
-    {
+    ) -> Result<SubExpr<E2>, Err> {
         Ok(self.rewrap(self.as_ref().traverse_resolve(visit_embed)?))
     }
 }
 
-impl SubExpr<X, X> {
-    pub fn absurd<N: Clone, T>(&self) -> SubExpr<N, T> {
-        SubExpr::from_expr_no_note(self.as_ref().absurd())
-    }
-}
-
-impl<E: Clone> SubExpr<X, E> {
-    pub fn note_absurd<N>(&self) -> SubExpr<N, E> {
-        SubExpr::from_expr_no_note(self.as_ref().note_absurd())
+impl SubExpr<X> {
+    pub fn absurd<T>(&self) -> SubExpr<T> {
+        SubExpr::from_expr_no_span(self.as_ref().absurd())
     }
 }
 
-impl<N, E> Clone for SubExpr<N, E> {
+impl<E> Clone for SubExpr<E> {
     fn clone(&self) -> Self {
         SubExpr(Rc::clone(&self.0))
     }
 }
 
 // Should probably rename this
-pub fn rc<E>(x: Expr<X, E>) -> SubExpr<X, E> {
-    SubExpr::from_expr_no_note(x)
+pub fn rc<E>(x: Expr<E>) -> SubExpr<E> {
+    SubExpr::from_expr_no_span(x)
+}
+
+pub(crate) fn spanned(
+    span: Span,
+    x: crate::parser::ParsedExpr,
+) -> crate::parser::ParsedSubExpr {
+    SubExpr::new(x, span)
+}
+pub(crate) fn unspanned(
+    x: crate::parser::ParsedExpr,
+) -> crate::parser::ParsedSubExpr {
+    SubExpr::from_expr_no_span(x)
 }
 
 /// Add an isize to an usize
diff --git a/dhall_syntax/src/core/visitor.rs b/dhall_syntax/src/core/visitor.rs
index 18f76d9..50ec68a 100644
--- a/dhall_syntax/src/core/visitor.rs
+++ b/dhall_syntax/src/core/visitor.rs
@@ -336,19 +336,18 @@ where
 
 pub struct TraverseEmbedVisitor<F1>(pub F1);
 
-impl<'a, 'b, N, E, E2, Err, F1>
-    ExprFFallibleVisitor<'a, SubExpr<N, E>, SubExpr<N, E2>, E, E2>
+impl<'a, 'b, E, E2, Err, F1>
+    ExprFFallibleVisitor<'a, SubExpr<E>, SubExpr<E2>, E, E2>
     for &'b mut TraverseEmbedVisitor<F1>
 where
-    N: Clone + 'a,
     F1: FnMut(&E) -> Result<E2, Err>,
 {
     type Error = Err;
 
     fn visit_subexpr(
         &mut self,
-        subexpr: &'a SubExpr<N, E>,
-    ) -> Result<SubExpr<N, E2>, Self::Error> {
+        subexpr: &'a SubExpr<E>,
+    ) -> Result<SubExpr<E2>, Self::Error> {
         Ok(subexpr.rewrap(subexpr.as_ref().visit(&mut **self)?))
     }
     fn visit_embed(self, embed: &'a E) -> Result<E2, Self::Error> {
@@ -358,19 +357,18 @@ where
 
 pub struct ResolveVisitor<F1>(pub F1);
 
-impl<'a, 'b, N, E, E2, Err, F1>
-    ExprFFallibleVisitor<'a, SubExpr<N, E>, SubExpr<N, E2>, E, E2>
+impl<'a, 'b, E, E2, Err, F1>
+    ExprFFallibleVisitor<'a, SubExpr<E>, SubExpr<E2>, E, E2>
     for &'b mut ResolveVisitor<F1>
 where
-    N: Clone + 'a,
     F1: FnMut(&E) -> Result<E2, Err>,
 {
     type Error = Err;
 
     fn visit_subexpr(
         &mut self,
-        subexpr: &'a SubExpr<N, E>,
-    ) -> Result<SubExpr<N, E2>, Self::Error> {
+        subexpr: &'a SubExpr<E>,
+    ) -> Result<SubExpr<E2>, Self::Error> {
         Ok(subexpr.rewrap(
             subexpr
                 .as_ref()
@@ -381,30 +379,14 @@ where
         (self.0)(embed)
     }
 }
-pub struct NoteAbsurdVisitor;
-
-impl<'a, 'b, N, E>
-    ExprFInFallibleVisitor<'a, SubExpr<X, E>, SubExpr<N, E>, E, E>
-    for &'b mut NoteAbsurdVisitor
-where
-    E: Clone + 'a,
-{
-    fn visit_subexpr(&mut self, subexpr: &'a SubExpr<X, E>) -> SubExpr<N, E> {
-        SubExpr::from_expr_no_note(subexpr.as_ref().visit(&mut **self))
-    }
-    fn visit_embed(self, embed: &'a E) -> E {
-        E::clone(embed)
-    }
-}
 
 pub struct AbsurdVisitor;
 
-impl<'a, 'b, N, E>
-    ExprFInFallibleVisitor<'a, SubExpr<X, X>, SubExpr<N, E>, X, E>
+impl<'a, 'b, E> ExprFInFallibleVisitor<'a, SubExpr<X>, SubExpr<E>, X, E>
     for &'b mut AbsurdVisitor
 {
-    fn visit_subexpr(&mut self, subexpr: &'a SubExpr<X, X>) -> SubExpr<N, E> {
-        SubExpr::from_expr_no_note(subexpr.as_ref().visit(&mut **self))
+    fn visit_subexpr(&mut self, subexpr: &'a SubExpr<X>) -> SubExpr<E> {
+        SubExpr::from_expr_no_span(subexpr.as_ref().visit(&mut **self))
     }
     fn visit_embed(self, embed: &'a X) -> E {
         match *embed {}
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 9ae6dc8..1ab6e6d 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -15,46 +15,15 @@ use crate::*;
 // their own crate because they are quite general and useful. For now they
 // are here and hopefully you can figure out how they work.
 
-type ParsedExpr = Expr<Span, Import>;
-type ParsedSubExpr = SubExpr<Span, Import>;
-type ParsedText = InterpolatedText<SubExpr<Span, Import>>;
-type ParsedTextContents = InterpolatedTextContents<SubExpr<Span, Import>>;
+pub(crate) type ParsedExpr = Expr<Import>;
+pub(crate) type ParsedSubExpr = SubExpr<Import>;
+type ParsedText = InterpolatedText<SubExpr<Import>>;
+type ParsedTextContents = InterpolatedTextContents<SubExpr<Import>>;
 
 pub type ParseError = pest::error::Error<Rule>;
 
 pub type ParseResult<T> = Result<T, ParseError>;
 
-fn unspanned(x: ParsedExpr) -> ParsedSubExpr {
-    SubExpr::from_expr_no_note(x)
-}
-
-#[derive(Debug, Clone)]
-pub struct Span {
-    input: Rc<str>,
-    /// # Safety
-    ///
-    /// Must be a valid character boundary index into `input`.
-    start: usize,
-    /// # Safety
-    ///
-    /// Must be a valid character boundary index into `input`.
-    end: usize,
-}
-
-impl Span {
-    fn make(input: Rc<str>, sp: pest::Span) -> Self {
-        Span {
-            input,
-            start: sp.start(),
-            end: sp.end(),
-        }
-    }
-}
-
-fn spanned(span: Span, x: ParsedExpr) -> ParsedSubExpr {
-    SubExpr::new(x, span)
-}
-
 #[derive(Debug)]
 enum Either<A, B> {
     Left(A),
diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs
index 70b224e..95eafe5 100644
--- a/dhall_syntax/src/printer.rs
+++ b/dhall_syntax/src/printer.rs
@@ -111,21 +111,21 @@ enum PrintPhase {
 // Wraps an Expr with a phase, so that phase selsction can be done
 // separate from the actual printing
 #[derive(Clone)]
-struct PhasedExpr<'a, S, A>(&'a SubExpr<S, A>, PrintPhase);
+struct PhasedExpr<'a, A>(&'a SubExpr<A>, PrintPhase);
 
-impl<'a, S: Clone, A: Display + Clone> Display for PhasedExpr<'a, S, A> {
+impl<'a, A: Display + Clone> Display for PhasedExpr<'a, A> {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         self.0.as_ref().fmt_phase(f, self.1)
     }
 }
 
-impl<'a, S: Clone, A: Display + Clone> PhasedExpr<'a, S, A> {
-    fn phase(self, phase: PrintPhase) -> PhasedExpr<'a, S, A> {
+impl<'a, A: Display + Clone> PhasedExpr<'a, A> {
+    fn phase(self, phase: PrintPhase) -> PhasedExpr<'a, A> {
         PhasedExpr(self.0, phase)
     }
 }
 
-impl<S: Clone, A: Display + Clone> Expr<S, A> {
+impl<A: Display + Clone> Expr<A> {
     fn fmt_phase(
         &self,
         f: &mut fmt::Formatter,
@@ -196,7 +196,7 @@ impl<S: Clone, A: Display + Clone> Expr<S, A> {
     }
 }
 
-impl<S: Clone, A: Display + Clone> Display for SubExpr<S, A> {
+impl<A: Display + Clone> Display for SubExpr<A> {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         self.as_ref().fmt_phase(f, PrintPhase::Base)
     }
-- 
cgit v1.2.3


From 77af0bbc171618f48531cc6b1d77e18089928885 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 13 Aug 2019 20:54:15 +0200
Subject: Stop tracking the absence of Embed values at the type level

---
 dhall_syntax/src/core/context.rs |  2 +-
 dhall_syntax/src/core/expr.rs    | 16 ++--------------
 dhall_syntax/src/core/visitor.rs | 15 +--------------
 dhall_syntax/src/printer.rs      |  6 ------
 4 files changed, 4 insertions(+), 35 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/context.rs b/dhall_syntax/src/core/context.rs
index eeec121..6844baa 100644
--- a/dhall_syntax/src/core/context.rs
+++ b/dhall_syntax/src/core/context.rs
@@ -4,7 +4,7 @@ use std::hash::Hash;
 
 /// A `(Context a)` associates `Text` labels with values of type `a`
 ///
-/// The `Context` is used for type-checking when `(a = Expr X)`
+/// The `Context` is used for type-checking when `(a = Expr)`
 ///
 /// * You create a `Context` using `empty` and `insert`
 /// * You transform a `Context` using `fmap`
diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index 0cbece3..e08d816 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -10,9 +10,9 @@ pub type Double = NaiveDouble;
 
 /// An empty type
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum X {}
+pub enum Void {}
 
-pub fn trivial_result<T>(x: Result<T, X>) -> T {
+pub fn trivial_result<T>(x: Result<T, Void>) -> T {
     match x {
         Ok(x) => x,
         Err(e) => match e {},
@@ -351,12 +351,6 @@ impl<E> Expr<E> {
     }
 }
 
-impl Expr<X> {
-    pub fn absurd<E>(&self) -> Expr<E> {
-        self.visit(&mut visitor::AbsurdVisitor)
-    }
-}
-
 impl<E> SubExpr<E> {
     pub fn as_ref(&self) -> &Expr<E> {
         &self.0.as_ref().0
@@ -416,12 +410,6 @@ impl<E> SubExpr<E> {
     }
 }
 
-impl SubExpr<X> {
-    pub fn absurd<T>(&self) -> SubExpr<T> {
-        SubExpr::from_expr_no_span(self.as_ref().absurd())
-    }
-}
-
 impl<E> Clone for SubExpr<E> {
     fn clone(&self) -> Self {
         SubExpr(Rc::clone(&self.0))
diff --git a/dhall_syntax/src/core/visitor.rs b/dhall_syntax/src/core/visitor.rs
index 50ec68a..e39e95b 100644
--- a/dhall_syntax/src/core/visitor.rs
+++ b/dhall_syntax/src/core/visitor.rs
@@ -243,7 +243,7 @@ impl<'a, T, SE1, SE2, E1, E2> ExprFFallibleVisitor<'a, SE1, SE2, E1, E2>
 where
     T: ExprFInFallibleVisitor<'a, SE1, SE2, E1, E2>,
 {
-    type Error = X;
+    type Error = Void;
 
     fn visit_subexpr(&mut self, subexpr: &'a SE1) -> Result<SE2, Self::Error> {
         Ok(self.0.visit_subexpr(subexpr))
@@ -379,16 +379,3 @@ where
         (self.0)(embed)
     }
 }
-
-pub struct AbsurdVisitor;
-
-impl<'a, 'b, E> ExprFInFallibleVisitor<'a, SubExpr<X>, SubExpr<E>, X, E>
-    for &'b mut AbsurdVisitor
-{
-    fn visit_subexpr(&mut self, subexpr: &'a SubExpr<X>) -> SubExpr<E> {
-        SubExpr::from_expr_no_span(subexpr.as_ref().visit(&mut **self))
-    }
-    fn visit_embed(self, embed: &'a X) -> E {
-        match *embed {}
-    }
-}
diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs
index 95eafe5..25d4ca8 100644
--- a/dhall_syntax/src/printer.rs
+++ b/dhall_syntax/src/printer.rs
@@ -491,9 +491,3 @@ impl<Label: Display> Display for V<Label> {
         Ok(())
     }
 }
-
-impl Display for X {
-    fn fmt(&self, _: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        match *self {}
-    }
-}
-- 
cgit v1.2.3


From 51dbaa0b66089bca63aa9cf69a1e0ec59df053b9 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 13 Aug 2019 21:10:59 +0200
Subject: Considerably simplify Embed handling

---
 dhall_syntax/src/core/expr.rs    | 110 +++++++++------------------------------
 dhall_syntax/src/core/visitor.rs |  60 ++++++---------------
 dhall_syntax/src/printer.rs      |   2 +-
 3 files changed, 44 insertions(+), 128 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index e08d816..74eb993 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -245,92 +245,62 @@ impl<SE, E> ExprF<SE, E> {
         v.visit(self)
     }
 
-    pub fn traverse_ref_with_special_handling_of_binders<'a, SE2, E2, Err>(
+    pub fn traverse_ref_with_special_handling_of_binders<'a, SE2, Err>(
         &'a self,
         visit_subexpr: impl FnMut(&'a SE) -> Result<SE2, Err>,
         visit_under_binder: impl FnOnce(&'a Label, &'a SE) -> Result<SE2, Err>,
-        visit_embed: impl FnOnce(&'a E) -> Result<E2, Err>,
-    ) -> Result<ExprF<SE2, E2>, Err> {
+    ) -> Result<ExprF<SE2, E>, Err>
+    where
+        E: Clone,
+    {
         self.visit(visitor::TraverseRefWithBindersVisitor {
             visit_subexpr,
             visit_under_binder,
-            visit_embed,
         })
     }
 
-    fn traverse_ref<'a, SE2, E2, Err>(
+    fn traverse_ref<'a, SE2, Err>(
         &'a self,
         visit_subexpr: impl FnMut(&'a SE) -> Result<SE2, Err>,
-        visit_embed: impl FnOnce(&'a E) -> Result<E2, Err>,
-    ) -> Result<ExprF<SE2, E2>, Err> {
-        self.visit(visitor::TraverseRefVisitor {
-            visit_subexpr,
-            visit_embed,
-        })
+    ) -> Result<ExprF<SE2, E>, Err>
+    where
+        E: Clone,
+    {
+        self.visit(visitor::TraverseRefVisitor { visit_subexpr })
     }
 
-    pub fn map_ref_with_special_handling_of_binders<'a, SE2, E2>(
+    pub fn map_ref_with_special_handling_of_binders<'a, SE2>(
         &'a self,
         mut map_subexpr: impl FnMut(&'a SE) -> SE2,
         mut map_under_binder: impl FnMut(&'a Label, &'a SE) -> SE2,
-        map_embed: impl FnOnce(&'a E) -> E2,
-    ) -> ExprF<SE2, E2> {
+    ) -> ExprF<SE2, E>
+    where
+        E: Clone,
+    {
         trivial_result(self.traverse_ref_with_special_handling_of_binders(
             |x| Ok(map_subexpr(x)),
             |l, x| Ok(map_under_binder(l, x)),
-            |x| Ok(map_embed(x)),
         ))
     }
 
-    pub fn map_ref<'a, SE2, E2>(
+    pub fn map_ref<'a, SE2>(
         &'a self,
         mut map_subexpr: impl FnMut(&'a SE) -> SE2,
-        map_embed: impl FnOnce(&'a E) -> E2,
-    ) -> ExprF<SE2, E2> {
-        trivial_result(
-            self.traverse_ref(|x| Ok(map_subexpr(x)), |x| Ok(map_embed(x))),
-        )
-    }
-
-    pub fn traverse_ref_simple<'a, SE2, Err>(
-        &'a self,
-        visit_subexpr: impl FnMut(&'a SE) -> Result<SE2, Err>,
-    ) -> Result<ExprF<SE2, E>, Err>
-    where
-        E: Clone,
-    {
-        self.traverse_ref(visit_subexpr, |x| Ok(E::clone(x)))
-    }
-
-    pub fn map_ref_simple<'a, SE2>(
-        &'a self,
-        map_subexpr: impl Fn(&'a SE) -> SE2,
     ) -> ExprF<SE2, E>
     where
         E: Clone,
     {
-        self.map_ref(map_subexpr, E::clone)
+        trivial_result(self.traverse_ref(|x| Ok(map_subexpr(x))))
     }
 }
 
-impl<E> Expr<E> {
-    fn traverse_embed<E2, Err>(
-        &self,
-        visit_embed: impl FnMut(&E) -> Result<E2, Err>,
-    ) -> Result<Expr<E2>, Err> {
-        self.visit(&mut visitor::TraverseEmbedVisitor(visit_embed))
-    }
-
-    fn map_embed<E2>(&self, mut map_embed: impl FnMut(&E) -> E2) -> Expr<E2> {
-        trivial_result(self.traverse_embed(|x| Ok(map_embed(x))))
-    }
-
+impl Expr<Import> {
     pub fn traverse_resolve<E2, Err>(
         &self,
-        visit_embed: impl FnMut(&E) -> Result<E2, Err>,
+        visit_import: impl FnMut(&Import) -> Result<E2, Err>,
     ) -> Result<Expr<E2>, Err> {
         self.traverse_resolve_with_visitor(&mut visitor::ResolveVisitor(
-            visit_embed,
+            visit_import,
         ))
     }
 
@@ -339,7 +309,7 @@ impl<E> Expr<E> {
         visitor: &mut visitor::ResolveVisitor<F1>,
     ) -> Result<Expr<E2>, Err>
     where
-        F1: FnMut(&E) -> Result<E2, Err>,
+        F1: FnMut(&Import) -> Result<E2, Err>,
     {
         match self {
             ExprF::BinOp(BinOp::ImportAlt, l, r) => l
@@ -371,42 +341,14 @@ impl<E> SubExpr<E> {
     pub fn rewrap<E2>(&self, x: Expr<E2>) -> SubExpr<E2> {
         SubExpr(Rc::new((x, (self.0).1.clone())))
     }
+}
 
-    pub fn traverse_embed<E2, Err>(
-        &self,
-        visit_embed: impl FnMut(&E) -> Result<E2, Err>,
-    ) -> Result<SubExpr<E2>, Err> {
-        Ok(self.rewrap(self.as_ref().traverse_embed(visit_embed)?))
-    }
-
-    pub fn map_embed<E2>(
-        &self,
-        map_embed: impl FnMut(&E) -> E2,
-    ) -> SubExpr<E2> {
-        self.rewrap(self.as_ref().map_embed(map_embed))
-    }
-
-    pub fn map_subexprs_with_special_handling_of_binders<'a>(
-        &'a self,
-        map_expr: impl FnMut(&'a Self) -> Self,
-        map_under_binder: impl FnMut(&'a Label, &'a Self) -> Self,
-    ) -> Self {
-        match self.as_ref() {
-            ExprF::Embed(_) => SubExpr::clone(self),
-            // This calls ExprF::map_ref
-            e => self.rewrap(e.map_ref_with_special_handling_of_binders(
-                map_expr,
-                map_under_binder,
-                |_| unreachable!(),
-            )),
-        }
-    }
-
+impl SubExpr<Import> {
     pub fn traverse_resolve<E2, Err>(
         &self,
-        visit_embed: impl FnMut(&E) -> Result<E2, Err>,
+        visit_import: impl FnMut(&Import) -> Result<E2, Err>,
     ) -> Result<SubExpr<E2>, Err> {
-        Ok(self.rewrap(self.as_ref().traverse_resolve(visit_embed)?))
+        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 e39e95b..647f76f 100644
--- a/dhall_syntax/src/core/visitor.rs
+++ b/dhall_syntax/src/core/visitor.rs
@@ -278,21 +278,18 @@ where
     }
 }
 
-pub struct TraverseRefWithBindersVisitor<F1, F2, F4> {
+pub struct TraverseRefWithBindersVisitor<F1, F2> {
     pub visit_subexpr: F1,
     pub visit_under_binder: F2,
-    pub visit_embed: F4,
 }
 
-impl<'a, SE, E, SE2, E2, Err, F1, F2, F4>
-    ExprFFallibleVisitor<'a, SE, SE2, E, E2>
-    for TraverseRefWithBindersVisitor<F1, F2, F4>
+impl<'a, SE, E, SE2, Err, F1, F2> ExprFFallibleVisitor<'a, SE, SE2, E, E>
+    for TraverseRefWithBindersVisitor<F1, F2>
 where
     SE: 'a,
-    E: 'a,
+    E: 'a + Clone,
     F1: FnMut(&'a SE) -> Result<SE2, Err>,
     F2: FnOnce(&'a Label, &'a SE) -> Result<SE2, Err>,
-    F4: FnOnce(&'a E) -> Result<E2, Err>,
 {
     type Error = Err;
 
@@ -306,68 +303,45 @@ where
     ) -> Result<SE2, Self::Error> {
         (self.visit_under_binder)(label, subexpr)
     }
-    fn visit_embed(self, embed: &'a E) -> Result<E2, Self::Error> {
-        (self.visit_embed)(embed)
+    fn visit_embed(self, embed: &'a E) -> Result<E, Self::Error> {
+        Ok(embed.clone())
     }
 }
 
-pub struct TraverseRefVisitor<F1, F3> {
+pub struct TraverseRefVisitor<F1> {
     pub visit_subexpr: F1,
-    pub visit_embed: F3,
 }
 
-impl<'a, SE, E, SE2, E2, Err, F1, F3> ExprFFallibleVisitor<'a, SE, SE2, E, E2>
-    for TraverseRefVisitor<F1, F3>
+impl<'a, SE, E, SE2, Err, F1> ExprFFallibleVisitor<'a, SE, SE2, E, E>
+    for TraverseRefVisitor<F1>
 where
     SE: 'a,
-    E: 'a,
+    E: 'a + Clone,
     F1: FnMut(&'a SE) -> Result<SE2, Err>,
-    F3: FnOnce(&'a E) -> Result<E2, Err>,
 {
     type Error = Err;
 
     fn visit_subexpr(&mut self, subexpr: &'a SE) -> Result<SE2, Self::Error> {
         (self.visit_subexpr)(subexpr)
     }
-    fn visit_embed(self, embed: &'a E) -> Result<E2, Self::Error> {
-        (self.visit_embed)(embed)
-    }
-}
-
-pub struct TraverseEmbedVisitor<F1>(pub F1);
-
-impl<'a, 'b, E, E2, Err, F1>
-    ExprFFallibleVisitor<'a, SubExpr<E>, SubExpr<E2>, E, E2>
-    for &'b mut TraverseEmbedVisitor<F1>
-where
-    F1: FnMut(&E) -> Result<E2, Err>,
-{
-    type Error = Err;
-
-    fn visit_subexpr(
-        &mut self,
-        subexpr: &'a SubExpr<E>,
-    ) -> Result<SubExpr<E2>, Self::Error> {
-        Ok(subexpr.rewrap(subexpr.as_ref().visit(&mut **self)?))
-    }
-    fn visit_embed(self, embed: &'a E) -> Result<E2, Self::Error> {
-        (self.0)(embed)
+    fn visit_embed(self, embed: &'a E) -> Result<E, Self::Error> {
+        Ok(embed.clone())
     }
 }
 
 pub struct ResolveVisitor<F1>(pub F1);
 
-impl<'a, 'b, E, E2, Err, F1>
-    ExprFFallibleVisitor<'a, SubExpr<E>, SubExpr<E2>, E, E2>
+impl<'a, 'b, E2, Err, F1>
+    ExprFFallibleVisitor<'a, SubExpr<Import>, SubExpr<E2>, Import, E2>
     for &'b mut ResolveVisitor<F1>
 where
-    F1: FnMut(&E) -> Result<E2, Err>,
+    F1: FnMut(&Import) -> Result<E2, Err>,
 {
     type Error = Err;
 
     fn visit_subexpr(
         &mut self,
-        subexpr: &'a SubExpr<E>,
+        subexpr: &'a SubExpr<Import>,
     ) -> Result<SubExpr<E2>, Self::Error> {
         Ok(subexpr.rewrap(
             subexpr
@@ -375,7 +349,7 @@ where
                 .traverse_resolve_with_visitor(&mut **self)?,
         ))
     }
-    fn visit_embed(self, embed: &'a E) -> Result<E2, Self::Error> {
+    fn visit_embed(self, embed: &'a Import) -> Result<E2, Self::Error> {
         (self.0)(embed)
     }
 }
diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs
index 25d4ca8..48e56be 100644
--- a/dhall_syntax/src/printer.rs
+++ b/dhall_syntax/src/printer.rs
@@ -156,7 +156,7 @@ impl<A: Display + Clone> Expr<A> {
         };
 
         // Annotate subexpressions with the appropriate phase, defaulting to Base
-        let phased_self = match self.map_ref_simple(|e| PhasedExpr(e, Base)) {
+        let phased_self = match self.map_ref(|e| PhasedExpr(e, Base)) {
             Pi(a, b, c) => {
                 if &String::from(&a) == "_" {
                     Pi(a, b.phase(Operator), c)
-- 
cgit v1.2.3


From 07956ccb1daf4a6819f64776f70b6f5f26869184 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 13 Aug 2019 21:38:17 +0200
Subject: Cleanup visitor code

---
 dhall_syntax/src/core/visitor.rs | 193 +++++++++++----------------------------
 1 file changed, 54 insertions(+), 139 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/visitor.rs b/dhall_syntax/src/core/visitor.rs
index 647f76f..f2f3b32 100644
--- a/dhall_syntax/src/core/visitor.rs
+++ b/dhall_syntax/src/core/visitor.rs
@@ -2,52 +2,56 @@ use crate::*;
 use std::iter::FromIterator;
 
 /// A way too generic Visitor trait.
-pub trait GenericVisitor<Input, Return>: Sized {
-    fn visit(self, input: Input) -> Return;
+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_embed` cannot be made using only `traverse_ref`, because
-/// `traverse_ref` takes a `FnMut` so we would need to pass multiple mutable
-/// reverences to this argument to `traverse_ref`. But Rust's ownership system
-/// is all about 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
-/// and TraverseEmbedVisitor.
-/// This is very generic. For a more legible trait, see ExprFInFallibleVisitor
-pub trait ExprFVeryGenericVisitor<'a, Ret, SE1, E1>: Sized {
+/// 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
+/// `traverse_ref`, because `traverse_ref` takes a `FnMut` so we would need to pass multiple
+/// mutable reverences to this argument to `traverse_ref`. But Rust's ownership system is all about
+/// 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 {
     type Error;
-    type SE2;
-    type E2;
 
-    fn visit_subexpr(
-        &mut self,
-        subexpr: &'a SE1,
-    ) -> Result<Self::SE2, Self::Error>;
+    fn visit_subexpr(&mut self, subexpr: &'a SE1) -> Result<SE2, Self::Error>;
+    fn visit_embed(self, embed: &'a E1) -> Result<E2, Self::Error>;
 
     fn visit_subexpr_under_binder(
-        self,
-        label: &'a Label,
+        mut self,
+        _label: &'a Label,
         subexpr: &'a SE1,
-    ) -> Result<Self::SE2, Self::Error>;
+    ) -> Result<SE2, Self::Error> {
+        self.visit_subexpr(subexpr)
+    }
+}
 
-    fn visit_embed_squash(self, embed: &'a E1) -> Result<Ret, Self::Error>;
+/// 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;
 
-    // Called with the result of the map, in the non-embed case.
-    // Useful to change the result type, and/or avoid some loss of info
-    fn visit_resulting_exprf(
-        result: ExprF<Self::SE2, Self::E2>,
-    ) -> Result<Ret, Self::Error>;
+    fn visit_subexpr_under_binder(
+        mut self,
+        _label: &'a Label,
+        subexpr: &'a SE1,
+    ) -> SE2 {
+        self.visit_subexpr(subexpr)
+    }
 }
 
-impl<'a, T, Ret, SE1, E1>
-    GenericVisitor<&'a ExprF<SE1, E1>, Result<Ret, T::Error>> for T
+impl<'a, T, SE1, SE2, E1, E2>
+    GenericVisitor<&'a ExprF<SE1, E1>, Result<ExprF<SE2, E2>, T::Error>> for T
 where
-    T: ExprFVeryGenericVisitor<'a, Ret, SE1, E1>,
+    T: ExprFFallibleVisitor<'a, SE1, SE2, E1, E2>,
 {
-    fn visit(self, input: &'a ExprF<SE1, E1>) -> Result<Ret, T::Error> {
+    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,
@@ -63,27 +67,27 @@ where
                 None => None,
             })
         }
-        fn dupmap<'a, V, Ret, SE, E, T>(
-            x: impl IntoIterator<Item = (&'a Label, &'a SE)>,
+        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
-            SE: 'a,
-            T: FromIterator<(Label, V::SE2)>,
-            V: ExprFVeryGenericVisitor<'a, Ret, SE, E>,
+            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()
         }
-        fn optdupmap<'a, V, Ret, SE, E, T>(
-            x: impl IntoIterator<Item = (&'a Label, &'a Option<SE>)>,
+        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
-            SE: 'a,
-            T: FromIterator<(Label, Option<V::SE2>)>,
-            V: ExprFVeryGenericVisitor<'a, Ret, SE, E>,
+            SE1: 'a,
+            T: FromIterator<(Label, Option<SE2>)>,
+            V: ExprFFallibleVisitor<'a, SE1, SE2, E1, E2>,
         {
             x.into_iter()
                 .map(|(k, x)| {
@@ -100,7 +104,7 @@ where
 
         let mut v = self;
         use crate::ExprF::*;
-        T::visit_resulting_exprf(match input {
+        Ok(match input {
             Var(v) => Var(v.clone()),
             Lam(l, t, e) => {
                 let t = v.visit_subexpr(t)?;
@@ -149,90 +153,18 @@ where
             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)?),
-            Embed(a) => return v.visit_embed_squash(a),
+            Embed(a) => Embed(v.visit_embed(a)?),
         })
     }
 }
 
-/// Like ExprFVeryGenericVisitor, but sets the return
-/// type to ExprF<_>
-pub trait ExprFFallibleVisitor<'a, SE1, SE2, E1, E2>: Sized {
-    type Error;
-
-    fn visit_subexpr(&mut self, subexpr: &'a SE1) -> Result<SE2, Self::Error>;
-    fn visit_embed(self, embed: &'a E1) -> Result<E2, Self::Error>;
-
-    fn visit_subexpr_under_binder(
-        mut self,
-        _label: &'a Label,
-        subexpr: &'a SE1,
-    ) -> Result<SE2, Self::Error> {
-        self.visit_subexpr(subexpr)
-    }
-
-    fn visit_embed_squash(
-        self,
-        embed: &'a E1,
-    ) -> Result<ExprF<SE2, E2>, Self::Error> {
-        Ok(ExprF::Embed(self.visit_embed(embed)?))
-    }
-}
-
-impl<'a, T, SE1, SE2, E1, E2>
-    ExprFVeryGenericVisitor<'a, ExprF<SE2, E2>, SE1, E1> for T
+impl<'a, T, SE1, SE2, E1, E2> GenericVisitor<&'a ExprF<SE1, E1>, ExprF<SE2, E2>>
+    for T
 where
-    T: ExprFFallibleVisitor<'a, SE1, SE2, E1, E2>,
+    T: ExprFInFallibleVisitor<'a, SE1, SE2, E1, E2>,
 {
-    type Error = T::Error;
-    type SE2 = SE2;
-    type E2 = E2;
-
-    fn visit_subexpr(
-        &mut self,
-        subexpr: &'a SE1,
-    ) -> Result<Self::SE2, Self::Error> {
-        self.visit_subexpr(subexpr)
-    }
-
-    fn visit_subexpr_under_binder(
-        self,
-        label: &'a Label,
-        subexpr: &'a SE1,
-    ) -> Result<Self::SE2, Self::Error> {
-        self.visit_subexpr_under_binder(label, subexpr)
-    }
-
-    fn visit_embed_squash(
-        self,
-        embed: &'a E1,
-    ) -> Result<ExprF<SE2, E2>, Self::Error> {
-        self.visit_embed_squash(embed)
-    }
-
-    // Called with the result of the map, in the non-embed case.
-    // Useful to change the result type, and/or avoid some loss of info
-    fn visit_resulting_exprf(
-        result: ExprF<Self::SE2, Self::E2>,
-    ) -> Result<ExprF<SE2, E2>, Self::Error> {
-        Ok(result)
-    }
-}
-
-/// 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;
-
-    fn visit_subexpr_under_binder(
-        mut self,
-        _label: &'a Label,
-        subexpr: &'a SE1,
-    ) -> SE2 {
-        self.visit_subexpr(subexpr)
-    }
-
-    fn visit_embed_squash(self, embed: &'a E1) -> ExprF<SE2, E2> {
-        ExprF::Embed(self.visit_embed(embed))
+    fn visit(self, input: &'a ExprF<SE1, E1>) -> ExprF<SE2, E2> {
+        trivial_result(InfallibleWrapper(self).visit(input))
     }
 }
 
@@ -259,23 +191,6 @@ where
     ) -> Result<SE2, Self::Error> {
         Ok(self.0.visit_subexpr_under_binder(label, subexpr))
     }
-
-    fn visit_embed_squash(
-        self,
-        embed: &'a E1,
-    ) -> Result<ExprF<SE2, E2>, Self::Error> {
-        Ok(self.0.visit_embed_squash(embed))
-    }
-}
-
-impl<'a, T, SE1, SE2, E1, E2> GenericVisitor<&'a ExprF<SE1, E1>, ExprF<SE2, E2>>
-    for T
-where
-    T: ExprFInFallibleVisitor<'a, SE1, SE2, E1, E2>,
-{
-    fn visit(self, input: &'a ExprF<SE1, E1>) -> ExprF<SE2, E2> {
-        trivial_result(InfallibleWrapper(self).visit(input))
-    }
 }
 
 pub struct TraverseRefWithBindersVisitor<F1, F2> {
-- 
cgit v1.2.3


From 8d45d633dfa60e8d64c9e6e742de4e33496bf0fa Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 13 Aug 2019 22:11:45 +0200
Subject: Store Imports in their own node instead of in Embed

---
 dhall_syntax/src/core/expr.rs    | 15 ++++++++++++---
 dhall_syntax/src/core/visitor.rs | 11 ++++++-----
 dhall_syntax/src/parser.rs       | 14 +++++++-------
 dhall_syntax/src/printer.rs      | 16 +++++++++++-----
 4 files changed, 36 insertions(+), 20 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index 74eb993..4c809f8 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -12,6 +12,12 @@ pub type Double = NaiveDouble;
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum Void {}
 
+impl std::fmt::Display for Void {
+    fn fmt(&self, _f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        match *self {}
+    }
+}
+
 pub fn trivial_result<T>(x: Result<T, Void>) -> T {
     match x {
         Ok(x) => x,
@@ -233,7 +239,9 @@ pub enum ExprF<SubExpr, Embed> {
     Field(SubExpr, Label),
     ///  `e.{ x, y, z }`
     Projection(SubExpr, DupTreeSet<Label>),
-    /// Embeds an import or the result of resolving the import
+    /// `./some/path`
+    Import(Import),
+    /// Embeds the result of resolving an import
     Embed(Embed),
 }
 
@@ -294,7 +302,7 @@ impl<SE, E> ExprF<SE, E> {
     }
 }
 
-impl Expr<Import> {
+impl<E> Expr<E> {
     pub fn traverse_resolve<E2, Err>(
         &self,
         visit_import: impl FnMut(&Import) -> Result<E2, Err>,
@@ -316,6 +324,7 @@ impl Expr<Import> {
                 .as_ref()
                 .traverse_resolve_with_visitor(visitor)
                 .or(r.as_ref().traverse_resolve_with_visitor(visitor)),
+            ExprF::Import(import) => Ok(ExprF::Embed((visitor.0)(import)?)),
             _ => self.visit(visitor),
         }
     }
@@ -343,7 +352,7 @@ impl<E> SubExpr<E> {
     }
 }
 
-impl SubExpr<Import> {
+impl<E> SubExpr<E> {
     pub fn traverse_resolve<E2, Err>(
         &self,
         visit_import: impl FnMut(&Import) -> Result<E2, Err>,
diff --git a/dhall_syntax/src/core/visitor.rs b/dhall_syntax/src/core/visitor.rs
index f2f3b32..f3d9194 100644
--- a/dhall_syntax/src/core/visitor.rs
+++ b/dhall_syntax/src/core/visitor.rs
@@ -153,6 +153,7 @@ where
             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(a) => Import(a.clone()),
             Embed(a) => Embed(v.visit_embed(a)?),
         })
     }
@@ -246,8 +247,8 @@ where
 
 pub struct ResolveVisitor<F1>(pub F1);
 
-impl<'a, 'b, E2, Err, F1>
-    ExprFFallibleVisitor<'a, SubExpr<Import>, SubExpr<E2>, Import, E2>
+impl<'a, 'b, E, E2, Err, F1>
+    ExprFFallibleVisitor<'a, SubExpr<E>, SubExpr<E2>, E, E2>
     for &'b mut ResolveVisitor<F1>
 where
     F1: FnMut(&Import) -> Result<E2, Err>,
@@ -256,7 +257,7 @@ where
 
     fn visit_subexpr(
         &mut self,
-        subexpr: &'a SubExpr<Import>,
+        subexpr: &'a SubExpr<E>,
     ) -> Result<SubExpr<E2>, Self::Error> {
         Ok(subexpr.rewrap(
             subexpr
@@ -264,7 +265,7 @@ where
                 .traverse_resolve_with_visitor(&mut **self)?,
         ))
     }
-    fn visit_embed(self, embed: &'a Import) -> Result<E2, Self::Error> {
-        (self.0)(embed)
+    fn visit_embed(self, _embed: &'a E) -> Result<E2, Self::Error> {
+        unimplemented!()
     }
 }
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 1ab6e6d..a8dd359 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -15,10 +15,10 @@ use crate::*;
 // their own crate because they are quite general and useful. For now they
 // are here and hopefully you can figure out how they work.
 
-pub(crate) type ParsedExpr = Expr<Import>;
-pub(crate) type ParsedSubExpr = SubExpr<Import>;
-type ParsedText = InterpolatedText<SubExpr<Import>>;
-type ParsedTextContents = InterpolatedTextContents<SubExpr<Import>>;
+pub(crate) type ParsedExpr = Expr<Void>;
+pub(crate) type ParsedSubExpr = SubExpr<Void>;
+type ParsedText = InterpolatedText<ParsedSubExpr>;
+type ParsedTextContents = InterpolatedTextContents<ParsedSubExpr>;
 
 pub type ParseError = pest::error::Error<Rule>;
 
@@ -691,19 +691,19 @@ make_parser! {
 
     rule!(import<ParsedSubExpr> as expression; span; children!(
         [import_hashed(location_hashed)] => {
-            spanned(span, Embed(Import {
+            spanned(span, Import(crate::Import {
                 mode: ImportMode::Code,
                 location_hashed
             }))
         },
         [import_hashed(location_hashed), Text(_)] => {
-            spanned(span, Embed(Import {
+            spanned(span, Import(crate::Import {
                 mode: ImportMode::RawText,
                 location_hashed
             }))
         },
         [import_hashed(location_hashed), Location(_)] => {
-            spanned(span, Embed(Import {
+            spanned(span, Import(crate::Import {
                 mode: ImportMode::Location,
                 location_hashed
             }))
diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs
index 48e56be..5f5f99b 100644
--- a/dhall_syntax/src/printer.rs
+++ b/dhall_syntax/src/printer.rs
@@ -88,6 +88,7 @@ impl<SE: Display + Clone, E: Display> Display for ExprF<SE, E> {
                 }
                 Ok(())
             })?,
+            Import(a) => a.fmt(f)?,
             Embed(a) => a.fmt(f)?,
         }
         Ok(())
@@ -151,7 +152,9 @@ impl<A: Display + Clone> Expr<A> {
             // Precedence is magically handled by the ordering of BinOps.
             ExprF::BinOp(op, _, _) if phase > PrintPhase::BinOp(*op) => true,
             ExprF::App(_, _) if phase > PrintPhase::App => true,
-            Field(_, _) | Projection(_, _) if phase > Import => true,
+            Field(_, _) | Projection(_, _) if phase > PrintPhase::Import => {
+                true
+            }
             _ => false,
         };
 
@@ -165,8 +168,8 @@ impl<A: Display + Clone> Expr<A> {
                 }
             }
             Merge(a, b, c) => Merge(
-                a.phase(Import),
-                b.phase(Import),
+                a.phase(PrintPhase::Import),
+                b.phase(PrintPhase::Import),
                 c.map(|x| x.phase(PrintPhase::App)),
             ),
             Annot(a, b) => Annot(a.phase(Operator), b),
@@ -175,8 +178,11 @@ impl<A: Display + Clone> Expr<A> {
                 a.phase(PrintPhase::BinOp(op)),
                 b.phase(PrintPhase::BinOp(op)),
             ),
-            SomeLit(e) => SomeLit(e.phase(Import)),
-            ExprF::App(f, a) => ExprF::App(f.phase(Import), a.phase(Import)),
+            SomeLit(e) => SomeLit(e.phase(PrintPhase::Import)),
+            ExprF::App(f, a) => ExprF::App(
+                f.phase(PrintPhase::Import),
+                a.phase(PrintPhase::Import),
+            ),
             Field(a, b) => Field(a.phase(Primitive), b),
             Projection(e, ls) => Projection(e.phase(Primitive), ls),
             e => e,
-- 
cgit v1.2.3


From 43094c8c52319aa82b03e73700ca1b5f65da13c6 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 13 Aug 2019 22:24:04 +0200
Subject: The syntax has very little sharing; no need for Rc anymore

---
 dhall_syntax/src/core/expr.rs | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index 4c809f8..e3f8cec 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -168,8 +168,8 @@ pub enum Builtin {
 }
 
 // Each node carries an annotation. In practice it's either X (no annotation) or a Span.
-#[derive(Debug)]
-pub struct SubExpr<Embed>(Rc<(Expr<Embed>, Option<Span>)>);
+#[derive(Debug, Clone)]
+pub struct SubExpr<Embed>(Box<(Expr<Embed>, Option<Span>)>);
 
 impl<Embed: PartialEq> std::cmp::PartialEq for SubExpr<Embed> {
     fn eq(&self, other: &Self) -> bool {
@@ -336,11 +336,11 @@ impl<E> SubExpr<E> {
     }
 
     pub fn new(x: Expr<E>, n: Span) -> Self {
-        SubExpr(Rc::new((x, Some(n))))
+        SubExpr(Box::new((x, Some(n))))
     }
 
     pub fn from_expr_no_span(x: Expr<E>) -> Self {
-        SubExpr(Rc::new((x, None)))
+        SubExpr(Box::new((x, None)))
     }
 
     pub fn from_builtin(b: Builtin) -> Self {
@@ -348,7 +348,7 @@ impl<E> SubExpr<E> {
     }
 
     pub fn rewrap<E2>(&self, x: Expr<E2>) -> SubExpr<E2> {
-        SubExpr(Rc::new((x, (self.0).1.clone())))
+        SubExpr(Box::new((x, (self.0).1.clone())))
     }
 }
 
@@ -361,12 +361,6 @@ impl<E> SubExpr<E> {
     }
 }
 
-impl<E> Clone for SubExpr<E> {
-    fn clone(&self) -> Self {
-        SubExpr(Rc::clone(&self.0))
-    }
-}
-
 // Should probably rename this
 pub fn rc<E>(x: Expr<E>) -> SubExpr<E> {
     SubExpr::from_expr_no_span(x)
-- 
cgit v1.2.3


From c600bae72198350b78fe19cf993b7f4c6f35225a Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 13 Aug 2019 23:08:48 +0200
Subject: Implement Hash for ParsedSubExpr

---
 dhall_syntax/src/core/expr.rs | 28 +++++++++++++++++++++++-----
 dhall_syntax/src/core/text.rs |  2 +-
 2 files changed, 24 insertions(+), 6 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index e3f8cec..9729efb 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -61,6 +61,15 @@ impl PartialEq for NaiveDouble {
 
 impl Eq for NaiveDouble {}
 
+impl std::hash::Hash for NaiveDouble {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: std::hash::Hasher,
+    {
+        self.0.to_bits().hash(state)
+    }
+}
+
 impl From<f64> for NaiveDouble {
     fn from(x: f64) -> Self {
         NaiveDouble(x)
@@ -74,7 +83,7 @@ impl From<NaiveDouble> for f64 {
 }
 
 /// Constants for a pure type system
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum Const {
     Type,
     Kind,
@@ -86,7 +95,7 @@ pub enum Const {
 /// The `Label` field is the variable's name (i.e. \"`x`\").
 /// The `Int` field is a DeBruijn index.
 /// See dhall-lang/standard/semantics.md for details
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct V<Label>(pub Label, pub usize);
 
 // This is only for the specific `Label` type, not generic
@@ -103,7 +112,7 @@ impl<'a> From<&'a Label> for V<Label> {
 
 // Definition order must match precedence order for
 // pretty-printing to work correctly
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum BinOp {
     /// `x ? y`
     ImportAlt,
@@ -134,7 +143,7 @@ pub enum BinOp {
 }
 
 /// Built-ins
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Builtin {
     Bool,
     Natural,
@@ -179,13 +188,22 @@ impl<Embed: PartialEq> std::cmp::PartialEq for SubExpr<Embed> {
 
 impl<Embed: Eq> std::cmp::Eq for SubExpr<Embed> {}
 
+impl<Embed: std::hash::Hash> std::hash::Hash for SubExpr<Embed> {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: std::hash::Hasher,
+    {
+        (self.0).0.hash(state)
+    }
+}
+
 pub type Expr<Embed> = ExprF<SubExpr<Embed>, Embed>;
 
 /// Syntax tree for expressions
 // Having the recursion out of the enum definition enables writing
 // much more generic code and improves pattern-matching behind
 // smart pointers.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ExprF<SubExpr, Embed> {
     Const(Const),
     ///  `x`
diff --git a/dhall_syntax/src/core/text.rs b/dhall_syntax/src/core/text.rs
index 0ce1e6f..10fd68a 100644
--- a/dhall_syntax/src/core/text.rs
+++ b/dhall_syntax/src/core/text.rs
@@ -1,6 +1,6 @@
 use std::iter::FromIterator;
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct InterpolatedText<SubExpr> {
     head: String,
     tail: Vec<(SubExpr, String)>,
-- 
cgit v1.2.3


From 66260f8e386f7a447352bd8ccbda064b00b698bc Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 13 Aug 2019 23:44:52 +0200
Subject: Implement inline headers parsing

---
 dhall_syntax/src/core/expr.rs    | 17 +++++++----
 dhall_syntax/src/core/import.rs  | 62 ++++++++++++++++++++++++++++++++--------
 dhall_syntax/src/core/visitor.rs |  4 +--
 dhall_syntax/src/parser.rs       | 28 +++++++++---------
 dhall_syntax/src/printer.rs      | 13 ++-------
 5 files changed, 80 insertions(+), 44 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index 9729efb..30ac4eb 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -258,7 +258,7 @@ pub enum ExprF<SubExpr, Embed> {
     ///  `e.{ x, y, z }`
     Projection(SubExpr, DupTreeSet<Label>),
     /// `./some/path`
-    Import(Import),
+    Import(Import<SubExpr>),
     /// Embeds the result of resolving an import
     Embed(Embed),
 }
@@ -323,7 +323,7 @@ impl<SE, E> ExprF<SE, E> {
 impl<E> Expr<E> {
     pub fn traverse_resolve<E2, Err>(
         &self,
-        visit_import: impl FnMut(&Import) -> Result<E2, Err>,
+        visit_import: impl FnMut(&Import<SubExpr<E2>>) -> Result<E2, Err>,
     ) -> Result<Expr<E2>, Err> {
         self.traverse_resolve_with_visitor(&mut visitor::ResolveVisitor(
             visit_import,
@@ -335,15 +335,20 @@ impl<E> Expr<E> {
         visitor: &mut visitor::ResolveVisitor<F1>,
     ) -> Result<Expr<E2>, Err>
     where
-        F1: FnMut(&Import) -> Result<E2, Err>,
+        F1: FnMut(&Import<SubExpr<E2>>) -> Result<E2, Err>,
     {
         match self {
             ExprF::BinOp(BinOp::ImportAlt, l, r) => l
                 .as_ref()
                 .traverse_resolve_with_visitor(visitor)
                 .or(r.as_ref().traverse_resolve_with_visitor(visitor)),
-            ExprF::Import(import) => Ok(ExprF::Embed((visitor.0)(import)?)),
-            _ => self.visit(visitor),
+            _ => {
+                let e = self.visit(&mut *visitor)?;
+                Ok(match &e {
+                    ExprF::Import(import) => ExprF::Embed((visitor.0)(import)?),
+                    _ => e,
+                })
+            }
         }
     }
 }
@@ -373,7 +378,7 @@ impl<E> SubExpr<E> {
 impl<E> SubExpr<E> {
     pub fn traverse_resolve<E2, Err>(
         &self,
-        visit_import: impl FnMut(&Import) -> Result<E2, Err>,
+        visit_import: impl FnMut(&Import<SubExpr<E2>>) -> Result<E2, Err>,
     ) -> Result<SubExpr<E2>, Err> {
         Ok(self.rewrap(self.as_ref().traverse_resolve(visit_import)?))
     }
diff --git a/dhall_syntax/src/core/import.rs b/dhall_syntax/src/core/import.rs
index d41eae2..9329d48 100644
--- a/dhall_syntax/src/core/import.rs
+++ b/dhall_syntax/src/core/import.rs
@@ -13,21 +13,20 @@ pub enum FilePrefix {
 
 /// The location of import (i.e. local vs. remote vs. environment)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum ImportLocation {
+pub enum ImportLocation<SubExpr> {
     Local(FilePrefix, Vec<String>),
-    Remote(URL),
+    Remote(URL<SubExpr>),
     Env(String),
     Missing,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct URL {
+pub struct URL<SubExpr> {
     pub scheme: Scheme,
     pub authority: String,
     pub path: Vec<String>,
     pub query: Option<String>,
-    // TODO: implement inline headers
-    pub headers: Option<Box<ImportHashed>>,
+    pub headers: Option<SubExpr>,
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
@@ -49,15 +48,54 @@ pub enum Hash {
     SHA256(Vec<u8>),
 }
 
+/// Reference to an external resource
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ImportHashed {
-    pub location: ImportLocation,
+pub struct Import<SubExpr> {
+    pub mode: ImportMode,
+    pub location: ImportLocation<SubExpr>,
     pub hash: Option<Hash>,
 }
 
-/// Reference to an external resource
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Import {
-    pub mode: ImportMode,
-    pub location_hashed: ImportHashed,
+impl<SE> URL<SE> {
+    pub fn visit_subexpr<'a, Err, SE2>(
+        &'a self,
+        f: impl FnOnce(&'a SE) -> Result<SE2, Err>,
+    ) -> Result<URL<SE2>, Err> {
+        let headers = self.headers.as_ref().map(f).transpose()?;
+        Ok(URL {
+            scheme: self.scheme,
+            authority: self.authority.clone(),
+            path: self.path.clone(),
+            query: self.query.clone(),
+            headers,
+        })
+    }
+}
+
+impl<SE> ImportLocation<SE> {
+    pub fn visit_subexpr<'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.clone(), path.clone()),
+            Remote(url) => Remote(url.visit_subexpr(f)?),
+            Env(env) => Env(env.clone()),
+            Missing => Missing,
+        })
+    }
+}
+
+impl<SE> Import<SE> {
+    pub fn visit_subexpr<'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)?,
+            hash: self.hash.clone(),
+        })
+    }
 }
diff --git a/dhall_syntax/src/core/visitor.rs b/dhall_syntax/src/core/visitor.rs
index f3d9194..7b4ed4b 100644
--- a/dhall_syntax/src/core/visitor.rs
+++ b/dhall_syntax/src/core/visitor.rs
@@ -153,7 +153,7 @@ where
             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(a) => Import(a.clone()),
+            Import(i) => Import(i.visit_subexpr(|e| v.visit_subexpr(e))?),
             Embed(a) => Embed(v.visit_embed(a)?),
         })
     }
@@ -251,7 +251,7 @@ impl<'a, 'b, E, E2, Err, F1>
     ExprFFallibleVisitor<'a, SubExpr<E>, SubExpr<E2>, E, E2>
     for &'b mut ResolveVisitor<F1>
 where
-    F1: FnMut(&Import) -> Result<E2, Err>,
+    F1: FnMut(&Import<SubExpr<E2>>) -> Result<E2, Err>,
 {
     type Error = Err;
 
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index a8dd359..8ecd0ab 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -598,7 +598,7 @@ make_parser! {
         _ => unreachable!(),
     });
 
-    rule!(http_raw<URL>; children!(
+    rule!(http_raw<URL<ParsedSubExpr>>; children!(
         [scheme(sch), authority(auth), path(p)] => URL {
             scheme: sch,
             authority: auth,
@@ -619,10 +619,10 @@ make_parser! {
 
     rule!(query<String>; captured_str!(s) => s.to_owned());
 
-    rule!(http<URL>; children!(
+    rule!(http<URL<ParsedSubExpr>>; children!(
         [http_raw(url)] => url,
-        [http_raw(url), import_hashed(ih)] =>
-            URL { headers: Some(Box::new(ih)), ..url },
+        [http_raw(url), expression(e)] =>
+            URL { headers: Some(e), ..url },
     ));
 
     rule!(env<String>; children!(
@@ -654,7 +654,7 @@ make_parser! {
 
     token_rule!(missing<()>);
 
-    rule!(import_type<ImportLocation>; children!(
+    rule!(import_type<ImportLocation<ParsedSubExpr>>; children!(
         [missing(_)] => {
             ImportLocation::Missing
         },
@@ -679,33 +679,33 @@ make_parser! {
         Hash::SHA256(hex::decode(hash).unwrap())
     });
 
-    rule!(import_hashed<ImportHashed>; children!(
+    rule!(import_hashed<crate::Import<ParsedSubExpr>>; children!(
         [import_type(location)] =>
-            ImportHashed { location, hash: None },
+            crate::Import {mode: ImportMode::Code, location, hash: None },
         [import_type(location), hash(h)] =>
-            ImportHashed { location, hash: Some(h) },
+            crate::Import {mode: ImportMode::Code, location, hash: Some(h) },
     ));
 
     token_rule!(Text<()>);
     token_rule!(Location<()>);
 
     rule!(import<ParsedSubExpr> as expression; span; children!(
-        [import_hashed(location_hashed)] => {
+        [import_hashed(imp)] => {
             spanned(span, Import(crate::Import {
                 mode: ImportMode::Code,
-                location_hashed
+                ..imp
             }))
         },
-        [import_hashed(location_hashed), Text(_)] => {
+        [import_hashed(imp), Text(_)] => {
             spanned(span, Import(crate::Import {
                 mode: ImportMode::RawText,
-                location_hashed
+                ..imp
             }))
         },
-        [import_hashed(location_hashed), Location(_)] => {
+        [import_hashed(imp), Location(_)] => {
             spanned(span, Import(crate::Import {
                 mode: ImportMode::Location,
-                location_hashed
+                ..imp
             }))
         },
     ));
diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs
index 5f5f99b..256ea65 100644
--- a/dhall_syntax/src/printer.rs
+++ b/dhall_syntax/src/printer.rs
@@ -230,7 +230,7 @@ where
     f.write_str(close)
 }
 
-impl<SubExpr: Display + Clone> Display for InterpolatedText<SubExpr> {
+impl<SubExpr: Display> Display for InterpolatedText<SubExpr> {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         f.write_str("\"")?;
         for x in self.iter() {
@@ -344,10 +344,11 @@ impl Display for Hash {
         }
     }
 }
-impl Display for ImportHashed {
+impl<SubExpr: Display> Display for Import<SubExpr> {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         use FilePrefix::*;
         use ImportLocation::*;
+        use ImportMode::*;
         let fmt_remote_path_component = |s: &str| -> String {
             use percent_encoding::{
                 utf8_percent_encode, PATH_SEGMENT_ENCODE_SET,
@@ -423,14 +424,6 @@ impl Display for ImportHashed {
             write!(f, " ")?;
             hash.fmt(f)?;
         }
-        Ok(())
-    }
-}
-
-impl Display for Import {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        self.location_hashed.fmt(f)?;
-        use ImportMode::*;
         match self.mode {
             Code => {}
             RawText => write!(f, " as Text")?,
-- 
cgit v1.2.3


From e4bdadabeda8ff8dbae0376f9d1c25478b8c8821 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 15 Aug 2019 15:33:53 +0200
Subject: Use precedence climbing to parse expressions with operators

This speeds up parsing around 30%
---
 dhall_syntax/src/parser.rs | 227 +++++++++++++++++++++------------------------
 1 file changed, 108 insertions(+), 119 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 8ecd0ab..5b213d1 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -1,5 +1,6 @@
 use itertools::Itertools;
 use pest::iterators::Pair;
+use pest::prec_climber as pcl;
 use pest::Parser;
 use std::borrow::Cow;
 use std::rc::Rc;
@@ -219,7 +220,7 @@ macro_rules! make_parser {
     );
 }
 
-// Non-recursive implementation to avoid stack overflows
+// (Mostly) non-recursive implementation to avoid stack overflows
 fn do_parse<'a>(
     input: Rc<str>,
     initial_pair: Pair<'a, Rule>,
@@ -232,30 +233,122 @@ fn do_parse<'a>(
     let mut pairs_stack: Vec<StackFrame> =
         vec![Unprocessed(initial_pair.clone())];
     let mut values_stack: Vec<ParsedValue> = vec![];
+
+    let operators = {
+        use Rule::*;
+        // In order of precedence
+        vec![
+            import_alt,
+            bool_or,
+            natural_plus,
+            text_append,
+            list_append,
+            bool_and,
+            combine,
+            prefer,
+            combine_types,
+            natural_times,
+            bool_eq,
+            bool_ne,
+            equivalent,
+        ]
+    };
+    let rule_to_binop = {
+        use crate::BinOp::*;
+        use Rule::*;
+        |r| {
+            Some(match r {
+                import_alt => ImportAlt,
+                bool_or => BoolOr,
+                natural_plus => NaturalPlus,
+                text_append => TextAppend,
+                list_append => ListAppend,
+                bool_and => BoolAnd,
+                combine => RecursiveRecordMerge,
+                prefer => RightBiasedRecordMerge,
+                combine_types => RecursiveRecordTypeMerge,
+                natural_times => NaturalTimes,
+                bool_eq => BoolEQ,
+                bool_ne => BoolNE,
+                equivalent => Equivalence,
+                _ => return None,
+            })
+        }
+    };
+    let climber = pcl::PrecClimber::new(
+        operators
+            .into_iter()
+            .map(|op| pcl::Operator::new(op, pcl::Assoc::Left))
+            .collect(),
+    );
+
     while let Some(p) = pairs_stack.pop() {
         match p {
             Unprocessed(mut pair) => loop {
-                let mut pairs: Vec<_> = pair.clone().into_inner().collect();
-                let n_children = pairs.len();
-                if n_children == 1 && can_be_shortcutted(pair.as_rule()) {
-                    pair = pairs.pop().unwrap();
-                    continue;
+                if can_be_shortcutted(pair.as_rule()) {
+                    let mut i = pair.clone().into_inner();
+                    let first = i.next();
+                    let second = i.next();
+                    match (first, second) {
+                        // If pair has exactly one child, just go on parsing that child
+                        (Some(p), None) => {
+                            pair = p;
+                            continue;
+                        }
+                        // Otherwise parse normally
+                        _ => {}
+                    }
+                }
+
+                // Use precedence climbing to parse operator_expression
+                if pair.as_rule() == Rule::operator_expression {
+                    let val = climber.climb(
+                        pair.clone().into_inner(),
+                        |p| do_parse(input.clone(), p),
+                        |l, p, r| {
+                            let o = match rule_to_binop(p.as_rule()) {
+                                Some(o) => o,
+                                None => Err(custom_parse_error(
+                                    &pair,
+                                    format!(
+                                        "Rule {:?} isn't an operator",
+                                        p.as_rule()
+                                    ),
+                                ))?,
+                            };
+                            use ParsedValue::expression;
+                            match (l?, r?) {
+                                (expression(l), expression(r)) => {
+                                    Ok(expression(unspanned(BinOp(o, l, r))))
+                                }
+                                (l, r) => Err(custom_parse_error(
+                                    &pair,
+                                    format!(
+                                        "Unexpected children: {:?}",
+                                        [l, r]
+                                    ),
+                                ))?,
+                            }
+                        },
+                    )?;
+                    values_stack.push(val);
+                    break;
                 } else {
-                    pairs_stack.push(Processed(pair, n_children));
-                    pairs_stack
-                        .extend(pairs.into_iter().map(StackFrame::Unprocessed));
+                    let n_children = pair.clone().into_inner().count();
+                    pairs_stack.push(Processed(pair.clone(), n_children));
+                    // Push the unparsed children onto the stack
+                    pairs_stack.extend(pair.into_inner().map(Unprocessed));
                     break;
                 }
             },
             Processed(pair, n) => {
+                // Take as many values from the values stack as that pair had children. This
+                // means we get exactly the children of the pair, but now they are parsed.
                 let mut children: Vec<_> =
                     values_stack.split_off(values_stack.len() - n);
                 children.reverse();
-                let val = match parse_any(input.clone(), pair.clone(), children)
-                {
-                    Ok(v) => v,
-                    Err(msg) => Err(custom_parse_error(&pair, msg))?,
-                };
+                let val = parse_any(input.clone(), pair.clone(), children)
+                    .map_err(|msg| custom_parse_error(&pair, msg))?;
                 values_stack.push(val);
             }
         }
@@ -268,19 +361,7 @@ fn can_be_shortcutted(rule: Rule) -> bool {
     use Rule::*;
     match rule {
         expression
-        | import_alt_expression
-        | or_expression
-        | plus_expression
-        | text_append_expression
-        | list_append_expression
-        | and_expression
-        | combine_expression
-        | prefer_expression
-        | combine_types_expression
-        | times_expression
-        | equal_expression
-        | not_equal_expression
-        | equivalent_expression
+        | operator_expression
         | application_expression
         | first_application_expression
         | selector_expression
@@ -765,98 +846,6 @@ make_parser! {
     token_rule!(List<()>);
     token_rule!(Optional<()>);
 
-    rule!(import_alt_expression<ParsedSubExpr> as expression; children!(
-        [expression(e)] => e,
-        [expression(first), expression(rest)..] => {
-            let o = crate::BinOp::ImportAlt;
-            rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
-        },
-    ));
-    rule!(or_expression<ParsedSubExpr> as expression; children!(
-        [expression(e)] => e,
-        [expression(first), expression(rest)..] => {
-            let o = crate::BinOp::BoolOr;
-            rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
-        },
-    ));
-    rule!(plus_expression<ParsedSubExpr> as expression; children!(
-        [expression(e)] => e,
-        [expression(first), expression(rest)..] => {
-            let o = crate::BinOp::NaturalPlus;
-            rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
-        },
-    ));
-    rule!(text_append_expression<ParsedSubExpr> as expression; children!(
-        [expression(e)] => e,
-        [expression(first), expression(rest)..] => {
-            let o = crate::BinOp::TextAppend;
-            rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
-        },
-    ));
-    rule!(list_append_expression<ParsedSubExpr> as expression; children!(
-        [expression(e)] => e,
-        [expression(first), expression(rest)..] => {
-            let o = crate::BinOp::ListAppend;
-            rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
-        },
-    ));
-    rule!(and_expression<ParsedSubExpr> as expression; children!(
-        [expression(e)] => e,
-        [expression(first), expression(rest)..] => {
-            let o = crate::BinOp::BoolAnd;
-            rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
-        },
-    ));
-    rule!(combine_expression<ParsedSubExpr> as expression; children!(
-        [expression(e)] => e,
-        [expression(first), expression(rest)..] => {
-            let o = crate::BinOp::RecursiveRecordMerge;
-            rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
-        },
-    ));
-    rule!(prefer_expression<ParsedSubExpr> as expression; children!(
-        [expression(e)] => e,
-        [expression(first), expression(rest)..] => {
-            let o = crate::BinOp::RightBiasedRecordMerge;
-            rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
-        },
-    ));
-    rule!(combine_types_expression<ParsedSubExpr> as expression; children!(
-        [expression(e)] => e,
-        [expression(first), expression(rest)..] => {
-            let o = crate::BinOp::RecursiveRecordTypeMerge;
-            rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
-        },
-    ));
-    rule!(times_expression<ParsedSubExpr> as expression; children!(
-        [expression(e)] => e,
-        [expression(first), expression(rest)..] => {
-            let o = crate::BinOp::NaturalTimes;
-            rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
-        },
-    ));
-    rule!(equal_expression<ParsedSubExpr> as expression; children!(
-        [expression(e)] => e,
-        [expression(first), expression(rest)..] => {
-            let o = crate::BinOp::BoolEQ;
-            rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
-        },
-    ));
-    rule!(not_equal_expression<ParsedSubExpr> as expression; children!(
-        [expression(e)] => e,
-        [expression(first), expression(rest)..] => {
-            let o = crate::BinOp::BoolNE;
-            rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
-        },
-    ));
-    rule!(equivalent_expression<ParsedSubExpr> as expression; children!(
-        [expression(e)] => e,
-        [expression(first), expression(rest)..] => {
-            let o = crate::BinOp::Equivalence;
-            rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
-        },
-    ));
-
     rule!(annotated_expression<ParsedSubExpr> as expression; span; children!(
         [expression(e)] => e,
         [expression(e), expression(annot)] => {
-- 
cgit v1.2.3


From f20e7fc0101c28f85c67e3566a16be4beaf2098c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 15 Aug 2019 16:15:46 +0200
Subject: No need for manual stack handling in parser anymore

---
 dhall_syntax/src/parser.rs | 238 ++++++++++++++++++---------------------------
 1 file changed, 96 insertions(+), 142 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 5b213d1..52b4426 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -220,140 +220,111 @@ macro_rules! make_parser {
     );
 }
 
-// (Mostly) non-recursive implementation to avoid stack overflows
 fn do_parse<'a>(
     input: Rc<str>,
-    initial_pair: Pair<'a, Rule>,
+    mut pair: Pair<'a, Rule>,
 ) -> ParseResult<ParsedValue<'a>> {
-    enum StackFrame<'a> {
-        Unprocessed(Pair<'a, Rule>),
-        Processed(Pair<'a, Rule>, usize),
-    }
-    use StackFrame::*;
-    let mut pairs_stack: Vec<StackFrame> =
-        vec![Unprocessed(initial_pair.clone())];
-    let mut values_stack: Vec<ParsedValue> = vec![];
-
-    let operators = {
-        use Rule::*;
-        // In order of precedence
-        vec![
-            import_alt,
-            bool_or,
-            natural_plus,
-            text_append,
-            list_append,
-            bool_and,
-            combine,
-            prefer,
-            combine_types,
-            natural_times,
-            bool_eq,
-            bool_ne,
-            equivalent,
-        ]
-    };
-    let rule_to_binop = {
-        use crate::BinOp::*;
-        use Rule::*;
-        |r| {
-            Some(match r {
-                import_alt => ImportAlt,
-                bool_or => BoolOr,
-                natural_plus => NaturalPlus,
-                text_append => TextAppend,
-                list_append => ListAppend,
-                bool_and => BoolAnd,
-                combine => RecursiveRecordMerge,
-                prefer => RightBiasedRecordMerge,
-                combine_types => RecursiveRecordTypeMerge,
-                natural_times => NaturalTimes,
-                bool_eq => BoolEQ,
-                bool_ne => BoolNE,
-                equivalent => Equivalence,
-                _ => return None,
-            })
+    // Avoid parsing while the pair has exactly one child that can be returned as-is
+    loop {
+        if can_be_shortcutted(pair.as_rule()) {
+            let mut i = pair.clone().into_inner();
+            let first = i.next();
+            let second = i.next();
+            match (first, second) {
+                // If pair has exactly one child, just go on parsing that child
+                (Some(p), None) => {
+                    pair = p;
+                    continue;
+                }
+                // Otherwise parse normally
+                _ => break,
+            }
         }
-    };
-    let climber = pcl::PrecClimber::new(
-        operators
-            .into_iter()
-            .map(|op| pcl::Operator::new(op, pcl::Assoc::Left))
-            .collect(),
-    );
+        break;
+    }
 
-    while let Some(p) = pairs_stack.pop() {
-        match p {
-            Unprocessed(mut pair) => loop {
-                if can_be_shortcutted(pair.as_rule()) {
-                    let mut i = pair.clone().into_inner();
-                    let first = i.next();
-                    let second = i.next();
-                    match (first, second) {
-                        // If pair has exactly one child, just go on parsing that child
-                        (Some(p), None) => {
-                            pair = p;
-                            continue;
-                        }
-                        // Otherwise parse normally
-                        _ => {}
+    // Use precedence climbing to parse operator_expression
+    if pair.as_rule() == Rule::operator_expression {
+        let rule_to_binop = {
+            use crate::BinOp::*;
+            use Rule::*;
+            |r| {
+                Some(match r {
+                    import_alt => ImportAlt,
+                    bool_or => BoolOr,
+                    natural_plus => NaturalPlus,
+                    text_append => TextAppend,
+                    list_append => ListAppend,
+                    bool_and => BoolAnd,
+                    combine => RecursiveRecordMerge,
+                    prefer => RightBiasedRecordMerge,
+                    combine_types => RecursiveRecordTypeMerge,
+                    natural_times => NaturalTimes,
+                    bool_eq => BoolEQ,
+                    bool_ne => BoolNE,
+                    equivalent => Equivalence,
+                    _ => return None,
+                })
+            }
+        };
+        let operators = {
+            use Rule::*;
+            // In order of precedence
+            vec![
+                import_alt,
+                bool_or,
+                natural_plus,
+                text_append,
+                list_append,
+                bool_and,
+                combine,
+                prefer,
+                combine_types,
+                natural_times,
+                bool_eq,
+                bool_ne,
+                equivalent,
+            ]
+        };
+        let climber = pcl::PrecClimber::new(
+            operators
+                .into_iter()
+                .map(|op| pcl::Operator::new(op, pcl::Assoc::Left))
+                .collect(),
+        );
+
+        climber.climb(
+            pair.clone().into_inner(),
+            |p| do_parse(input.clone(), p),
+            |l, p, r| {
+                let o = match rule_to_binop(p.as_rule()) {
+                    Some(o) => o,
+                    None => Err(custom_parse_error(
+                        &pair,
+                        format!("Rule {:?} isn't an operator", p.as_rule()),
+                    ))?,
+                };
+                use ParsedValue::expression;
+                match (l?, r?) {
+                    (expression(l), expression(r)) => {
+                        Ok(expression(unspanned(BinOp(o, l, r))))
                     }
-                }
-
-                // Use precedence climbing to parse operator_expression
-                if pair.as_rule() == Rule::operator_expression {
-                    let val = climber.climb(
-                        pair.clone().into_inner(),
-                        |p| do_parse(input.clone(), p),
-                        |l, p, r| {
-                            let o = match rule_to_binop(p.as_rule()) {
-                                Some(o) => o,
-                                None => Err(custom_parse_error(
-                                    &pair,
-                                    format!(
-                                        "Rule {:?} isn't an operator",
-                                        p.as_rule()
-                                    ),
-                                ))?,
-                            };
-                            use ParsedValue::expression;
-                            match (l?, r?) {
-                                (expression(l), expression(r)) => {
-                                    Ok(expression(unspanned(BinOp(o, l, r))))
-                                }
-                                (l, r) => Err(custom_parse_error(
-                                    &pair,
-                                    format!(
-                                        "Unexpected children: {:?}",
-                                        [l, r]
-                                    ),
-                                ))?,
-                            }
-                        },
-                    )?;
-                    values_stack.push(val);
-                    break;
-                } else {
-                    let n_children = pair.clone().into_inner().count();
-                    pairs_stack.push(Processed(pair.clone(), n_children));
-                    // Push the unparsed children onto the stack
-                    pairs_stack.extend(pair.into_inner().map(Unprocessed));
-                    break;
+                    (l, r) => Err(custom_parse_error(
+                        &pair,
+                        format!("Unexpected children: {:?}", [l, r]),
+                    ))?,
                 }
             },
-            Processed(pair, n) => {
-                // Take as many values from the values stack as that pair had children. This
-                // means we get exactly the children of the pair, but now they are parsed.
-                let mut children: Vec<_> =
-                    values_stack.split_off(values_stack.len() - n);
-                children.reverse();
-                let val = parse_any(input.clone(), pair.clone(), children)
-                    .map_err(|msg| custom_parse_error(&pair, msg))?;
-                values_stack.push(val);
-            }
-        }
+        )
+    } else {
+        let children = pair
+            .clone()
+            .into_inner()
+            .map(|p| do_parse(input.clone(), p))
+            .collect::<Result<_, _>>()?;
+        parse_any(input.clone(), pair.clone(), children)
+            .map_err(|msg| custom_parse_error(&pair, msg))
     }
-    Ok(values_stack.pop().unwrap())
 }
 
 // List of rules that can be shortcutted if they have a single child
@@ -985,21 +956,4 @@ pub fn parse_expr(s: &str) -> ParseResult<ParsedSubExpr> {
         ParsedValue::expression(e) => Ok(e),
         _ => unreachable!(),
     }
-    // Ok(BoolLit(false))
-}
-
-#[test]
-fn test_parse() {
-    // let expr = r#"{ x = "foo", y = 4 }.x"#;
-    // let expr = r#"(1 + 2) * 3"#;
-    let expr = r#"(1) + 3 * 5"#;
-    println!("{:?}", parse_expr(expr));
-    match parse_expr(expr) {
-        Err(e) => {
-            println!("{:?}", e);
-            println!("{}", e);
-        }
-        ok => println!("{:?}", ok),
-    };
-    // assert!(false);
 }
-- 
cgit v1.2.3


From ffb5a4c26960960f526719d9b333df80119fef3c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Thu, 15 Aug 2019 17:59:01 +0200
Subject: Include precedence parsing in parser macros

---
 dhall_syntax/src/lib.rs    |   1 +
 dhall_syntax/src/parser.rs | 320 ++++++++++++++++++++++++++-------------------
 2 files changed, 188 insertions(+), 133 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/lib.rs b/dhall_syntax/src/lib.rs
index 193c6ea..8406595 100644
--- a/dhall_syntax/src/lib.rs
+++ b/dhall_syntax/src/lib.rs
@@ -1,5 +1,6 @@
 #![feature(trace_macros)]
 #![feature(slice_patterns)]
+#![feature(try_blocks)]
 #![allow(
     clippy::many_single_char_names,
     clippy::should_implement_trait,
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 52b4426..d467970 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -1,8 +1,10 @@
 use itertools::Itertools;
 use pest::iterators::Pair;
 use pest::prec_climber as pcl;
+use pest::prec_climber::PrecClimber;
 use pest::Parser;
 use std::borrow::Cow;
+use std::collections::HashMap;
 use std::rc::Rc;
 
 use dhall_generated_parser::{DhallParser, Rule};
@@ -125,61 +127,117 @@ macro_rules! make_parser {
     (@filter, token_rule) => (true);
     (@filter, rule_group) => (false);
 
-    (@body,
-        ($($things:tt)*),
-        rule!( $name:ident<$o:ty>; $($args:tt)* )
-    ) => (
-        make_parser!(@body,
-            ($($things)*),
-            rule!( $name<$o> as $name; $($args)* )
+    (@construct_climber,
+        ($map:expr),
+        rule!(
+            $name:ident<$o:ty>
+            as $group:ident;
+            prec_climb!( $climber:expr, $($_rest:tt)* )
         )
-    );
+    ) => ({
+        $map.insert(Rule::$name, $climber)
+    });
+    (@construct_climber, ($($things:tt)*), $($args:tt)*) => (());
+
     (@body,
-        ($_input:expr, $pair:expr, $_children:expr),
+        ($climbers:expr, $input:expr, $pair:expr),
         rule!(
             $name:ident<$o:ty>
             as $group:ident;
+            $span:ident;
             captured_str!($x:pat) => $body:expr
         )
     ) => ({
-        let $x = $pair.as_str();
-        let res: $o = $body;
-        Ok(ParsedValue::$group(res))
+        let res: Result<_, String> = try {
+            let $span = Span::make($input, $pair.as_span());
+            let $x = $pair.as_str();
+            ParsedValue::$group($body)
+        };
+        res.map_err(|msg| custom_parse_error(&$pair, msg))
     });
     (@body,
-        ($_input:expr, $_pair:expr, $children:expr),
+        ($climbers:expr, $input:expr, $pair:expr),
         rule!(
             $name:ident<$o:ty>
             as $group:ident;
+            $span:ident;
             children!( $( [$($args:tt)*] => $body:expr ),* $(,)* )
         )
     ) => ({
-        #[allow(unused_imports)]
-        use ParsedValue::*;
+        let children: Vec<_> = $pair
+            .clone()
+            .into_inner()
+            .map(|p| parse_any($climbers, $input.clone(), p))
+            .collect::<Result<_, _>>()?;
+
         #[allow(unreachable_code)]
-        let res: $o = improved_slice_patterns::match_vec!($children;
-            $( [$($args)*] => $body, )*
-            [x..] => Err(
-                format!("Unexpected children: {:?}", x.collect::<Vec<_>>())
-            )?,
-        ).map_err(|_| -> String { unreachable!() })?;
+        let res: Result<_, String> = try {
+            #[allow(unused_imports)]
+            use ParsedValue::*;
+            let $span = Span::make($input, $pair.as_span());
+
+            improved_slice_patterns::match_vec!(children;
+                $( [$($args)*] => $body, )*
+                [x..] => Err(
+                    format!("Unexpected children: {:?}", x.collect::<Vec<_>>())
+                )?,
+            ).map_err(|_| -> String { unreachable!() })?
+        };
+
+        let res = res.map_err(|msg| custom_parse_error(&$pair, msg))?;
         Ok(ParsedValue::$group(res))
     });
     (@body,
-        ($input:expr, $pair:expr, $children:expr),
+        ($climbers:expr, $input:expr, $pair:expr),
+        rule!(
+            $name:ident<$o:ty>
+            as $group:ident;
+            prec_climb!( $_climber:expr, $args:pat => $body:expr $(,)* )
+        )
+    ) => ({
+        let climber = $climbers.get(&Rule::$name).unwrap();
+        climber.climb(
+            $pair.clone().into_inner(),
+            |p| parse_any($climbers, $input.clone(), p),
+            |l, op, r| {
+                let (l, r) = (l?, r?);
+                let res: Result<_, String> = try {
+                    #[allow(unused_imports)]
+                    use ParsedValue::*;
+                    match (l, op, r) {
+                        $args => ParsedValue::$group($body),
+                        children => Err(
+                            format!("Unexpected children: {:?}", children)
+                        )?,
+                    }
+                };
+                res.map_err(|msg| custom_parse_error(&$pair, msg))
+            },
+        )
+    });
+    (@body,
+        ($($things:tt)*),
+        rule!( $name:ident<$o:ty>; $($args:tt)* )
+    ) => (
+        make_parser!(@body,
+            ($($things)*),
+            rule!( $name<$o> as $name; $($args)* )
+        )
+    );
+    (@body,
+        ($($things:tt)*),
         rule!(
             $name:ident<$o:ty>
             as $group:ident;
-            $span:ident;
             $($args:tt)*
         )
     ) => ({
-        let $span = Span::make($input, $pair.as_span());
         make_parser!(@body,
-            ($input, $pair, $children),
+            ($($things)*),
             rule!(
                 $name<$o>
                 as $group;
+                _span;
                 $($args)*
             )
         )
@@ -201,20 +259,63 @@ macro_rules! make_parser {
             $( $name($o), )*
         }
 
+        fn construct_precclimbers() -> HashMap<Rule, PrecClimber<Rule>> {
+            let mut map = HashMap::new();
+            $(
+                make_parser!(@construct_climber, (map),
+                        $submac!( $name<$o> $($args)* ));
+            )*
+            map
+        }
+
+        struct Parsers;
+
+        impl Parsers {
+            $(
+            #[allow(non_snake_case, unused_variables)]
+            fn $name<'a>(
+                climbers: &HashMap<Rule, PrecClimber<Rule>>,
+                input: Rc<str>,
+                pair: Pair<'a, Rule>,
+            ) -> ParseResult<ParsedValue<'a>> {
+                make_parser!(@body, (climbers, input, pair),
+                               $submac!( $name<$o> $($args)* ))
+            }
+            )*
+        }
+
         fn parse_any<'a>(
+            climbers: &HashMap<Rule, PrecClimber<Rule>>,
             input: Rc<str>,
-            pair: Pair<'a, Rule>,
-            children: Vec<ParsedValue<'a>>,
-        ) -> Result<ParsedValue<'a>, String> {
+            mut pair: Pair<'a, Rule>,
+        ) -> ParseResult<ParsedValue<'a>> {
+            // Avoid parsing while the pair has exactly one child that can be returned as-is
+            loop {
+                if can_be_shortcutted(pair.as_rule()) {
+                    let mut i = pair.clone().into_inner();
+                    let first = i.next();
+                    let second = i.next();
+                    match (first, second) {
+                        // If pair has exactly one child, just go on parsing that child
+                        (Some(p), None) => {
+                            pair = p;
+                            continue;
+                        }
+                        // Otherwise parse normally
+                        _ => break,
+                    }
+                }
+                break;
+            }
+
             match pair.as_rule() {
                 $(
                     make_parser!(@pattern, $submac, $name)
                     if make_parser!(@filter, $submac)
-                    => make_parser!(@body, (input, pair, children),
-                                           $submac!( $name<$o> $($args)* ))
+                    => Parsers::$name(climbers, input, pair)
                     ,
                 )*
-                r => Err(format!("Unexpected {:?}", r)),
+                r => Err(custom_parse_error(&pair, format!("Unexpected {:?}", r))),
             }
         }
     );
@@ -222,109 +323,10 @@ macro_rules! make_parser {
 
 fn do_parse<'a>(
     input: Rc<str>,
-    mut pair: Pair<'a, Rule>,
+    pair: Pair<'a, Rule>,
 ) -> ParseResult<ParsedValue<'a>> {
-    // Avoid parsing while the pair has exactly one child that can be returned as-is
-    loop {
-        if can_be_shortcutted(pair.as_rule()) {
-            let mut i = pair.clone().into_inner();
-            let first = i.next();
-            let second = i.next();
-            match (first, second) {
-                // If pair has exactly one child, just go on parsing that child
-                (Some(p), None) => {
-                    pair = p;
-                    continue;
-                }
-                // Otherwise parse normally
-                _ => break,
-            }
-        }
-        break;
-    }
-
-    // Use precedence climbing to parse operator_expression
-    if pair.as_rule() == Rule::operator_expression {
-        let rule_to_binop = {
-            use crate::BinOp::*;
-            use Rule::*;
-            |r| {
-                Some(match r {
-                    import_alt => ImportAlt,
-                    bool_or => BoolOr,
-                    natural_plus => NaturalPlus,
-                    text_append => TextAppend,
-                    list_append => ListAppend,
-                    bool_and => BoolAnd,
-                    combine => RecursiveRecordMerge,
-                    prefer => RightBiasedRecordMerge,
-                    combine_types => RecursiveRecordTypeMerge,
-                    natural_times => NaturalTimes,
-                    bool_eq => BoolEQ,
-                    bool_ne => BoolNE,
-                    equivalent => Equivalence,
-                    _ => return None,
-                })
-            }
-        };
-        let operators = {
-            use Rule::*;
-            // In order of precedence
-            vec![
-                import_alt,
-                bool_or,
-                natural_plus,
-                text_append,
-                list_append,
-                bool_and,
-                combine,
-                prefer,
-                combine_types,
-                natural_times,
-                bool_eq,
-                bool_ne,
-                equivalent,
-            ]
-        };
-        let climber = pcl::PrecClimber::new(
-            operators
-                .into_iter()
-                .map(|op| pcl::Operator::new(op, pcl::Assoc::Left))
-                .collect(),
-        );
-
-        climber.climb(
-            pair.clone().into_inner(),
-            |p| do_parse(input.clone(), p),
-            |l, p, r| {
-                let o = match rule_to_binop(p.as_rule()) {
-                    Some(o) => o,
-                    None => Err(custom_parse_error(
-                        &pair,
-                        format!("Rule {:?} isn't an operator", p.as_rule()),
-                    ))?,
-                };
-                use ParsedValue::expression;
-                match (l?, r?) {
-                    (expression(l), expression(r)) => {
-                        Ok(expression(unspanned(BinOp(o, l, r))))
-                    }
-                    (l, r) => Err(custom_parse_error(
-                        &pair,
-                        format!("Unexpected children: {:?}", [l, r]),
-                    ))?,
-                }
-            },
-        )
-    } else {
-        let children = pair
-            .clone()
-            .into_inner()
-            .map(|p| do_parse(input.clone(), p))
-            .collect::<Result<_, _>>()?;
-        parse_any(input.clone(), pair.clone(), children)
-            .map_err(|msg| custom_parse_error(&pair, msg))
-    }
+    let climbers = construct_precclimbers();
+    parse_any(&climbers, input, pair)
 }
 
 // List of rules that can be shortcutted if they have a single child
@@ -824,6 +826,58 @@ make_parser! {
         },
     ));
 
+    rule!(operator_expression<ParsedSubExpr> as expression; prec_climb!(
+        {
+            use Rule::*;
+            // In order of precedence
+            let operators = vec![
+                import_alt,
+                bool_or,
+                natural_plus,
+                text_append,
+                list_append,
+                bool_and,
+                combine,
+                prefer,
+                combine_types,
+                natural_times,
+                bool_eq,
+                bool_ne,
+                equivalent,
+            ];
+            PrecClimber::new(
+                operators
+                    .into_iter()
+                    .map(|op| pcl::Operator::new(op, pcl::Assoc::Left))
+                    .collect(),
+            )
+        },
+        (expression(l), op, expression(r)) => {
+            use crate::BinOp::*;
+            use Rule::*;
+            let op = match op.as_rule() {
+                import_alt => ImportAlt,
+                bool_or => BoolOr,
+                natural_plus => NaturalPlus,
+                text_append => TextAppend,
+                list_append => ListAppend,
+                bool_and => BoolAnd,
+                combine => RecursiveRecordMerge,
+                prefer => RightBiasedRecordMerge,
+                combine_types => RecursiveRecordTypeMerge,
+                natural_times => NaturalTimes,
+                bool_eq => BoolEQ,
+                bool_ne => BoolNE,
+                equivalent => Equivalence,
+                r => Err(
+                    format!("Rule {:?} isn't an operator", r),
+                )?,
+            };
+
+            unspanned(BinOp(op, l, r))
+        }
+    ));
+
     token_rule!(Some_<()>);
     token_rule!(toMap<()>);
 
-- 
cgit v1.2.3


From 509743469035582d916e6a2f331fd5018c81447e Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 16 Aug 2019 11:11:28 +0200
Subject: Use `!` type instead of custom empty type

---
 dhall_syntax/src/core/expr.rs    | 14 ++------------
 dhall_syntax/src/core/visitor.rs |  2 +-
 dhall_syntax/src/lib.rs          |  1 +
 dhall_syntax/src/parser.rs       |  4 ++--
 4 files changed, 6 insertions(+), 15 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index 30ac4eb..efbcee2 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -8,20 +8,10 @@ pub type Integer = isize;
 pub type Natural = usize;
 pub type Double = NaiveDouble;
 
-/// An empty type
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum Void {}
-
-impl std::fmt::Display for Void {
-    fn fmt(&self, _f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
-        match *self {}
-    }
-}
-
-pub fn trivial_result<T>(x: Result<T, Void>) -> T {
+pub fn trivial_result<T>(x: Result<T, !>) -> T {
     match x {
         Ok(x) => x,
-        Err(e) => match e {},
+        Err(e) => e,
     }
 }
 
diff --git a/dhall_syntax/src/core/visitor.rs b/dhall_syntax/src/core/visitor.rs
index 7b4ed4b..5a5fcc9 100644
--- a/dhall_syntax/src/core/visitor.rs
+++ b/dhall_syntax/src/core/visitor.rs
@@ -176,7 +176,7 @@ impl<'a, T, SE1, SE2, E1, E2> ExprFFallibleVisitor<'a, SE1, SE2, E1, E2>
 where
     T: ExprFInFallibleVisitor<'a, SE1, SE2, E1, E2>,
 {
-    type Error = Void;
+    type Error = !;
 
     fn visit_subexpr(&mut self, subexpr: &'a SE1) -> Result<SE2, Self::Error> {
         Ok(self.0.visit_subexpr(subexpr))
diff --git a/dhall_syntax/src/lib.rs b/dhall_syntax/src/lib.rs
index 8406595..4566e64 100644
--- a/dhall_syntax/src/lib.rs
+++ b/dhall_syntax/src/lib.rs
@@ -1,6 +1,7 @@
 #![feature(trace_macros)]
 #![feature(slice_patterns)]
 #![feature(try_blocks)]
+#![feature(never_type)]
 #![allow(
     clippy::many_single_char_names,
     clippy::should_implement_trait,
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index d467970..bcaa00e 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -18,8 +18,8 @@ use crate::*;
 // their own crate because they are quite general and useful. For now they
 // are here and hopefully you can figure out how they work.
 
-pub(crate) type ParsedExpr = Expr<Void>;
-pub(crate) type ParsedSubExpr = SubExpr<Void>;
+pub(crate) type ParsedExpr = Expr<!>;
+pub(crate) type ParsedSubExpr = SubExpr<!>;
 type ParsedText = InterpolatedText<ParsedSubExpr>;
 type ParsedTextContents = InterpolatedTextContents<ParsedSubExpr>;
 
-- 
cgit v1.2.3


From 8eb169713ea1220f2d515391c08d34509d75ab73 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 16 Aug 2019 10:34:10 +0200
Subject: Match on rules in parser instead of on ParsedValues

---
 dhall_syntax/src/lib.rs    |   1 +
 dhall_syntax/src/parser.rs | 153 +++++++++++++++++++++++++++++++++++++--------
 2 files changed, 129 insertions(+), 25 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/lib.rs b/dhall_syntax/src/lib.rs
index 4566e64..e4a6077 100644
--- a/dhall_syntax/src/lib.rs
+++ b/dhall_syntax/src/lib.rs
@@ -2,6 +2,7 @@
 #![feature(slice_patterns)]
 #![feature(try_blocks)]
 #![feature(never_type)]
+#![feature(bind_by_move_pattern_guards)]
 #![allow(
     clippy::many_single_char_names,
     clippy::should_implement_trait,
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index bcaa00e..366103e 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -127,17 +127,75 @@ macro_rules! make_parser {
     (@filter, token_rule) => (true);
     (@filter, rule_group) => (false);
 
-    (@construct_climber,
-        ($map:expr),
+    (@child_pattern,
+        $varpat:ident,
+        ($($acc:tt)*),
+        [$variant:ident ($x:pat), $($rest:tt)*]
+    ) => (
+        make_parser!(@child_pattern,
+            $varpat,
+            ($($acc)* , Rule::$variant),
+            [$($rest)*]
+        )
+    );
+    (@child_pattern,
+        $varpat:ident,
+        ($($acc:tt)*),
+        [$variant:ident ($x:ident).., $($rest:tt)*]
+    ) => (
+        make_parser!(@child_pattern,
+            $varpat,
+            ($($acc)* , $varpat..),
+            [$($rest)*]
+        )
+    );
+    (@child_pattern,
+        $varpat:ident,
+        (, $($acc:tt)*), [$(,)*]
+    ) => ([$($acc)*]);
+    (@child_pattern,
+        $varpat:ident,
+        ($($acc:tt)*), [$(,)*]
+    ) => ([$($acc)*]);
+
+    (@child_filter,
+        $varpat:ident,
+        [$variant:ident ($x:pat), $($rest:tt)*]
+    ) => (
+        true &&
+        make_parser!(@child_filter, $varpat, [$($rest)*])
+    );
+    (@child_filter,
+        $varpat:ident,
+        [$variant:ident ($x:ident).., $($rest:tt)*]
+    ) => (
+        $varpat.iter().all(|r| r == &Rule::$variant) &&
+        make_parser!(@child_filter, $varpat, [$($rest)*])
+    );
+    (@child_filter, $varpat:ident, [$(,)*]) => (true);
+
+    (@rule_alias,
+        rule!( $name:ident<$o:ty>; $($args:tt)* )
+    ) => (
+        Rule::$name
+    );
+    (@rule_alias,
         rule!(
             $name:ident<$o:ty>
             as $group:ident;
-            prec_climb!( $climber:expr, $($_rest:tt)* )
+            $($args:tt)*
         )
     ) => ({
-        $map.insert(Rule::$name, $climber)
+        Rule::$group
     });
-    (@construct_climber, ($($things:tt)*), $($args:tt)*) => (());
+    (@rule_alias,
+        token_rule!($name:ident<$o:ty>)
+    ) => ({
+        Rule::$name
+    });
+    (@rule_alias, rule_group!( $name:ident<$o:ty> )) => (
+        unreachable!()
+    );
 
     (@body,
         ($climbers:expr, $input:expr, $pair:expr),
@@ -169,19 +227,43 @@ macro_rules! make_parser {
             .into_inner()
             .map(|p| parse_any($climbers, $input.clone(), p))
             .collect::<Result<_, _>>()?;
+        let children_rules: Vec<Rule> = $pair
+            .clone()
+            .into_inner()
+            .map(|p| p.as_rule())
+            .map(rule_alias)
+            .collect();
 
         #[allow(unreachable_code)]
         let res: Result<_, String> = try {
             #[allow(unused_imports)]
             use ParsedValue::*;
             let $span = Span::make($input, $pair.as_span());
+            #[allow(unused_mut)]
+            let mut iter = children.into_iter();
 
-            improved_slice_patterns::match_vec!(children;
-                $( [$($args)*] => $body, )*
-                [x..] => Err(
-                    format!("Unexpected children: {:?}", x.collect::<Vec<_>>())
-                )?,
-            ).map_err(|_| -> String { unreachable!() })?
+            match children_rules.as_slice() {
+                $(
+                    make_parser!(@child_pattern, x, (), [$($args)*,])
+                    if make_parser!(@child_filter, x, [$($args)*,])
+                    => {
+                        let ret =
+                            improved_slice_patterns::destructure_iter!(iter;
+                                [$($args)*] => $body
+                        );
+                        match ret {
+                            Some(x) => x,
+                            None => Err({
+                                format!("Unexpected children: {:?}", children_rules)
+                            })?
+                        }
+                    }
+                    ,
+                )*
+                [..] => Err({
+                    format!("Unexpected children: {:?}", children_rules)
+                })?,
+            }
         };
 
         let res = res.map_err(|msg| custom_parse_error(&$pair, msg))?;
@@ -252,6 +334,18 @@ macro_rules! make_parser {
         unreachable!()
     );
 
+    (@construct_climber,
+        ($map:expr),
+        rule!(
+            $name:ident<$o:ty>
+            as $group:ident;
+            prec_climb!( $climber:expr, $($_rest:tt)* )
+        )
+    ) => ({
+        $map.insert(Rule::$name, $climber)
+    });
+    (@construct_climber, ($($things:tt)*), $($args:tt)*) => (());
+
     ($( $submac:ident!( $name:ident<$o:ty> $($args:tt)* ); )*) => (
         #[allow(non_camel_case_types, dead_code, clippy::large_enum_variant)]
         #[derive(Debug)]
@@ -284,6 +378,19 @@ macro_rules! make_parser {
             )*
         }
 
+        fn rule_alias(r: Rule) -> Rule {
+            match r {
+                $(
+                    make_parser!(@pattern, $submac, $name)
+                    if make_parser!(@filter, $submac)
+                    => make_parser!(@rule_alias,
+                                    $submac!( $name<$o> $($args)* ))
+                    ,
+                )*
+                r => r,
+            }
+        }
+
         fn parse_any<'a>(
             climbers: &HashMap<Rule, PrecClimber<Rule>>,
             input: Rc<str>,
@@ -520,21 +627,15 @@ make_parser! {
             lines.last_mut().unwrap().push(c);
             lines
         },
-        [single_quote_char("\n"), single_quote_continue(lines)] => {
-            let mut lines = lines;
-            lines.push(vec![]);
-            lines
-        },
-        [single_quote_char("\r\n"), single_quote_continue(lines)] => {
-            let mut lines = lines;
-            lines.push(vec![]);
-            lines
-        },
         [single_quote_char(c), single_quote_continue(lines)] => {
-            // TODO: don't allocate for every char
-            let c = InterpolatedTextContents::Text(c.to_owned());
             let mut lines = lines;
-            lines.last_mut().unwrap().push(c);
+            if c == "\n" || c == "\r\n" {
+                lines.push(vec![]);
+            } else {
+                // TODO: don't allocate for every char
+                let c = InterpolatedTextContents::Text(c.to_owned());
+                lines.last_mut().unwrap().push(c);
+            }
             lines
         },
         [] => {
@@ -631,7 +732,9 @@ make_parser! {
         }
     ));
 
-    rule_group!(local<(FilePrefix, Vec<String>)>);
+    rule!(local<(FilePrefix, Vec<String>)>; children!(
+        [local(l)] => l
+    ));
 
     rule!(parent_path<(FilePrefix, Vec<String>)> as local; children!(
         [path(p)] => (FilePrefix::Parent, p)
-- 
cgit v1.2.3


From 0fa94400492c08c3a38ae6798a0caeab23da5287 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 16 Aug 2019 10:39:15 +0200
Subject: Remove rule_group macro

---
 dhall_syntax/src/parser.rs | 26 ++++----------------------
 1 file changed, 4 insertions(+), 22 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 366103e..b443656 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -120,13 +120,6 @@ fn debug_pair(pair: Pair<Rule>) -> String {
 }
 
 macro_rules! make_parser {
-    (@pattern, rule, $name:ident) => (Rule::$name);
-    (@pattern, token_rule, $name:ident) => (Rule::$name);
-    (@pattern, rule_group, $name:ident) => (_);
-    (@filter, rule) => (true);
-    (@filter, token_rule) => (true);
-    (@filter, rule_group) => (false);
-
     (@child_pattern,
         $varpat:ident,
         ($($acc:tt)*),
@@ -193,9 +186,6 @@ macro_rules! make_parser {
     ) => ({
         Rule::$name
     });
-    (@rule_alias, rule_group!( $name:ident<$o:ty> )) => (
-        unreachable!()
-    );
 
     (@body,
         ($climbers:expr, $input:expr, $pair:expr),
@@ -330,9 +320,6 @@ macro_rules! make_parser {
     ) => ({
         Ok(ParsedValue::$name(()))
     });
-    (@body, ($($things:tt)*), rule_group!( $name:ident<$o:ty> )) => (
-        unreachable!()
-    );
 
     (@construct_climber,
         ($map:expr),
@@ -381,11 +368,9 @@ macro_rules! make_parser {
         fn rule_alias(r: Rule) -> Rule {
             match r {
                 $(
-                    make_parser!(@pattern, $submac, $name)
-                    if make_parser!(@filter, $submac)
-                    => make_parser!(@rule_alias,
-                                    $submac!( $name<$o> $($args)* ))
-                    ,
+                    Rule::$name => {
+                        make_parser!(@rule_alias, $submac!($name<$o> $($args)*))
+                    }
                 )*
                 r => r,
             }
@@ -417,10 +402,7 @@ macro_rules! make_parser {
 
             match pair.as_rule() {
                 $(
-                    make_parser!(@pattern, $submac, $name)
-                    if make_parser!(@filter, $submac)
-                    => Parsers::$name(climbers, input, pair)
-                    ,
+                    Rule::$name => Parsers::$name(climbers, input, pair),
                 )*
                 r => Err(custom_parse_error(&pair, format!("Unexpected {:?}", r))),
             }
-- 
cgit v1.2.3


From f3a66c3603b01cb61334caee4a4749cac166b675 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Fri, 16 Aug 2019 11:05:44 +0200
Subject: Wording

---
 dhall_syntax/src/parser.rs | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index b443656..d11eb18 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -120,52 +120,52 @@ fn debug_pair(pair: Pair<Rule>) -> String {
 }
 
 macro_rules! make_parser {
-    (@child_pattern,
+    (@children_pattern,
         $varpat:ident,
         ($($acc:tt)*),
         [$variant:ident ($x:pat), $($rest:tt)*]
     ) => (
-        make_parser!(@child_pattern,
+        make_parser!(@children_pattern,
             $varpat,
             ($($acc)* , Rule::$variant),
             [$($rest)*]
         )
     );
-    (@child_pattern,
+    (@children_pattern,
         $varpat:ident,
         ($($acc:tt)*),
         [$variant:ident ($x:ident).., $($rest:tt)*]
     ) => (
-        make_parser!(@child_pattern,
+        make_parser!(@children_pattern,
             $varpat,
             ($($acc)* , $varpat..),
             [$($rest)*]
         )
     );
-    (@child_pattern,
+    (@children_pattern,
         $varpat:ident,
         (, $($acc:tt)*), [$(,)*]
     ) => ([$($acc)*]);
-    (@child_pattern,
+    (@children_pattern,
         $varpat:ident,
         ($($acc:tt)*), [$(,)*]
     ) => ([$($acc)*]);
 
-    (@child_filter,
+    (@children_filter,
         $varpat:ident,
         [$variant:ident ($x:pat), $($rest:tt)*]
     ) => (
         true &&
-        make_parser!(@child_filter, $varpat, [$($rest)*])
+        make_parser!(@children_filter, $varpat, [$($rest)*])
     );
-    (@child_filter,
+    (@children_filter,
         $varpat:ident,
         [$variant:ident ($x:ident).., $($rest:tt)*]
     ) => (
         $varpat.iter().all(|r| r == &Rule::$variant) &&
-        make_parser!(@child_filter, $varpat, [$($rest)*])
+        make_parser!(@children_filter, $varpat, [$($rest)*])
     );
-    (@child_filter, $varpat:ident, [$(,)*]) => (true);
+    (@children_filter, $varpat:ident, [$(,)*]) => (true);
 
     (@rule_alias,
         rule!( $name:ident<$o:ty>; $($args:tt)* )
@@ -234,8 +234,8 @@ macro_rules! make_parser {
 
             match children_rules.as_slice() {
                 $(
-                    make_parser!(@child_pattern, x, (), [$($args)*,])
-                    if make_parser!(@child_filter, x, [$($args)*,])
+                    make_parser!(@children_pattern, x, (), [$($args)*,])
+                    if make_parser!(@children_filter, x, [$($args)*,])
                     => {
                         let ret =
                             improved_slice_patterns::destructure_iter!(iter;
-- 
cgit v1.2.3


From c13a100c36c3b54d76dba2207aa75fa6736ebadc Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Mon, 26 Aug 2019 23:18:11 +0200
Subject: Remove rule aliasing

---
 dhall_syntax/src/parser.rs | 200 +++++++++++++++++++++------------------------
 1 file changed, 93 insertions(+), 107 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index d11eb18..2debc8b 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -174,12 +174,11 @@ macro_rules! make_parser {
     );
     (@rule_alias,
         rule!(
-            $name:ident<$o:ty>
-            as $group:ident;
+            $name:ident<$o:ty>;
             $($args:tt)*
         )
     ) => ({
-        Rule::$group
+        Rule::$name
     });
     (@rule_alias,
         token_rule!($name:ident<$o:ty>)
@@ -190,8 +189,7 @@ macro_rules! make_parser {
     (@body,
         ($climbers:expr, $input:expr, $pair:expr),
         rule!(
-            $name:ident<$o:ty>
-            as $group:ident;
+            $name:ident<$o:ty>;
             $span:ident;
             captured_str!($x:pat) => $body:expr
         )
@@ -199,15 +197,14 @@ macro_rules! make_parser {
         let res: Result<_, String> = try {
             let $span = Span::make($input, $pair.as_span());
             let $x = $pair.as_str();
-            ParsedValue::$group($body)
+            ParsedValue::$name($body)
         };
         res.map_err(|msg| custom_parse_error(&$pair, msg))
     });
     (@body,
         ($climbers:expr, $input:expr, $pair:expr),
         rule!(
-            $name:ident<$o:ty>
-            as $group:ident;
+            $name:ident<$o:ty>;
             $span:ident;
             children!( $( [$($args:tt)*] => $body:expr ),* $(,)* )
         )
@@ -257,27 +254,33 @@ macro_rules! make_parser {
         };
 
         let res = res.map_err(|msg| custom_parse_error(&$pair, msg))?;
-        Ok(ParsedValue::$group(res))
+        Ok(ParsedValue::$name(res))
     });
     (@body,
         ($climbers:expr, $input:expr, $pair:expr),
         rule!(
-            $name:ident<$o:ty>
-            as $group:ident;
-            prec_climb!( $_climber:expr, $args:pat => $body:expr $(,)* )
+            $name:ident<$o:ty>;
+            prec_climb!($other_name:ident, $_climber:expr, $args:pat => $body:expr $(,)* )
         )
     ) => ({
-        let climber = $climbers.get(&Rule::$name).unwrap();
+        let climber = $climbers.get(&Rule::$name).expect(&format!("UUUU: {:?}", $climbers));
         climber.climb(
             $pair.clone().into_inner(),
-            |p| parse_any($climbers, $input.clone(), p),
+            |p| {
+                let parsed = parse_any($climbers, $input.clone(), p)?;
+                if let ParsedValue::$other_name(x) = parsed {
+                    Ok(ParsedValue::$name(x))
+                } else {
+                    unreachable!()
+                }
+            },
             |l, op, r| {
                 let (l, r) = (l?, r?);
                 let res: Result<_, String> = try {
                     #[allow(unused_imports)]
                     use ParsedValue::*;
                     match (l, op, r) {
-                        $args => ParsedValue::$group($body),
+                        $args => ParsedValue::$name($body),
                         children => Err(
                             format!("Unexpected children: {:?}", children)
                         )?,
@@ -289,26 +292,13 @@ macro_rules! make_parser {
     });
     (@body,
         ($($things:tt)*),
-        rule!( $name:ident<$o:ty>; $($args:tt)* )
-    ) => (
-        make_parser!(@body,
-            ($($things)*),
-            rule!( $name<$o> as $name; $($args)* )
-        )
-    );
-    (@body,
-        ($($things:tt)*),
-        rule!(
-            $name:ident<$o:ty>
-            as $group:ident;
-            $($args:tt)*
+        rule!( $name:ident<$o:ty>; $($args:tt)*
         )
     ) => ({
         make_parser!(@body,
             ($($things)*),
             rule!(
-                $name<$o>
-                as $group;
+                $name<$o>;
                 _span;
                 $($args)*
             )
@@ -324,9 +314,8 @@ macro_rules! make_parser {
     (@construct_climber,
         ($map:expr),
         rule!(
-            $name:ident<$o:ty>
-            as $group:ident;
-            prec_climb!( $climber:expr, $($_rest:tt)* )
+            $name:ident<$o:ty>;
+            prec_climb!( $other_name:ident, $climber:expr, $($_rest:tt)* )
         )
     ) => ({
         $map.insert(Rule::$name, $climber)
@@ -379,27 +368,8 @@ macro_rules! make_parser {
         fn parse_any<'a>(
             climbers: &HashMap<Rule, PrecClimber<Rule>>,
             input: Rc<str>,
-            mut pair: Pair<'a, Rule>,
+            pair: Pair<'a, Rule>,
         ) -> ParseResult<ParsedValue<'a>> {
-            // Avoid parsing while the pair has exactly one child that can be returned as-is
-            loop {
-                if can_be_shortcutted(pair.as_rule()) {
-                    let mut i = pair.clone().into_inner();
-                    let first = i.next();
-                    let second = i.next();
-                    match (first, second) {
-                        // If pair has exactly one child, just go on parsing that child
-                        (Some(p), None) => {
-                            pair = p;
-                            continue;
-                        }
-                        // Otherwise parse normally
-                        _ => break,
-                    }
-                }
-                break;
-            }
-
             match pair.as_rule() {
                 $(
                     Rule::$name => Parsers::$name(climbers, input, pair),
@@ -418,20 +388,6 @@ fn do_parse<'a>(
     parse_any(&climbers, input, pair)
 }
 
-// List of rules that can be shortcutted if they have a single child
-fn can_be_shortcutted(rule: Rule) -> bool {
-    use Rule::*;
-    match rule {
-        expression
-        | operator_expression
-        | application_expression
-        | first_application_expression
-        | selector_expression
-        | annotated_expression => true,
-        _ => false,
-    }
-}
-
 // Trim the shared indent off of a vec of lines, as defined by the Dhall semantics of multiline
 // literals.
 fn trim_indent(lines: &mut Vec<ParsedText>) {
@@ -591,10 +547,10 @@ make_parser! {
     rule!(single_quote_char<&'a str>;
         captured_str!(s) => s
     );
-    rule!(escaped_quote_pair<&'a str> as single_quote_char;
+    rule!(escaped_quote_pair<&'a str>;
         captured_str!(_) => "''"
     );
-    rule!(escaped_interpolation<&'a str> as single_quote_char;
+    rule!(escaped_interpolation<&'a str>;
         captured_str!(_) => "${"
     );
     rule!(interpolation<ParsedSubExpr>; children!(
@@ -609,6 +565,20 @@ make_parser! {
             lines.last_mut().unwrap().push(c);
             lines
         },
+        [escaped_quote_pair(c), single_quote_continue(lines)] => {
+            let mut lines = lines;
+            // TODO: don't allocate for every char
+            let c = InterpolatedTextContents::Text(c.to_owned());
+            lines.last_mut().unwrap().push(c);
+            lines
+        },
+        [escaped_interpolation(c), single_quote_continue(lines)] => {
+            let mut lines = lines;
+            // TODO: don't allocate for every char
+            let c = InterpolatedTextContents::Text(c.to_owned());
+            lines.last_mut().unwrap().push(c);
+            lines
+        },
         [single_quote_char(c), single_quote_continue(lines)] => {
             let mut lines = lines;
             if c == "\n" || c == "\r\n" {
@@ -682,7 +652,7 @@ make_parser! {
         }
     );
 
-    rule!(identifier<ParsedSubExpr> as expression; span; children!(
+    rule!(identifier<ParsedSubExpr>; span; children!(
         [variable(v)] => {
             spanned(span, Var(v))
         },
@@ -715,19 +685,22 @@ make_parser! {
     ));
 
     rule!(local<(FilePrefix, Vec<String>)>; children!(
-        [local(l)] => l
+        [parent_path(l)] => l,
+        [here_path(l)] => l,
+        [home_path(l)] => l,
+        [absolute_path(l)] => l,
     ));
 
-    rule!(parent_path<(FilePrefix, Vec<String>)> as local; children!(
+    rule!(parent_path<(FilePrefix, Vec<String>)>; children!(
         [path(p)] => (FilePrefix::Parent, p)
     ));
-    rule!(here_path<(FilePrefix, Vec<String>)> as local; children!(
+    rule!(here_path<(FilePrefix, Vec<String>)>; children!(
         [path(p)] => (FilePrefix::Here, p)
     ));
-    rule!(home_path<(FilePrefix, Vec<String>)> as local; children!(
+    rule!(home_path<(FilePrefix, Vec<String>)>; children!(
         [path(p)] => (FilePrefix::Home, p)
     ));
-    rule!(absolute_path<(FilePrefix, Vec<String>)> as local; children!(
+    rule!(absolute_path<(FilePrefix, Vec<String>)>; children!(
         [path(p)] => (FilePrefix::Absolute, p)
     ));
 
@@ -760,7 +733,7 @@ make_parser! {
 
     rule!(http<URL<ParsedSubExpr>>; children!(
         [http_raw(url)] => url,
-        [http_raw(url), expression(e)] =>
+        [http_raw(url), import_expression(e)] =>
             URL { headers: Some(e), ..url },
     ));
 
@@ -828,7 +801,7 @@ make_parser! {
     token_rule!(Text<()>);
     token_rule!(Location<()>);
 
-    rule!(import<ParsedSubExpr> as expression; span; children!(
+    rule!(import<ParsedSubExpr>; span; children!(
         [import_hashed(imp)] => {
             spanned(span, Import(crate::Import {
                 mode: ImportMode::Code,
@@ -857,13 +830,13 @@ make_parser! {
     token_rule!(if_<()>);
     token_rule!(in_<()>);
 
-    rule!(empty_list_literal<ParsedSubExpr> as expression; span; children!(
-        [expression(e)] => {
+    rule!(empty_list_literal<ParsedSubExpr>; span; children!(
+        [application_expression(e)] => {
             spanned(span, EmptyListLit(e))
         },
     ));
 
-    rule!(expression<ParsedSubExpr> as expression; span; children!(
+    rule!(expression<ParsedSubExpr>; span; children!(
         [lambda(()), label(l), expression(typ),
                 arrow(()), expression(body)] => {
             spanned(span, Lam(l, typ, body))
@@ -881,16 +854,17 @@ make_parser! {
                 arrow(()), expression(body)] => {
             spanned(span, Pi(l, typ, body))
         },
-        [expression(typ), arrow(()), expression(body)] => {
+        [operator_expression(typ), arrow(()), expression(body)] => {
             spanned(span, Pi("_".into(), typ, body))
         },
-        [merge(()), expression(x), expression(y), expression(z)] => {
+        [merge(()), import_expression(x), import_expression(y), application_expression(z)] => {
             spanned(span, Merge(x, y, Some(z)))
         },
+        [empty_list_literal(e)] => e,
         [assert(()), expression(x)] => {
             spanned(span, Assert(x))
         },
-        [expression(e)] => e,
+        [annotated_expression(e)] => e,
     ));
 
     rule!(let_binding<(Label, Option<ParsedSubExpr>, ParsedSubExpr)>;
@@ -904,14 +878,14 @@ make_parser! {
     token_rule!(List<()>);
     token_rule!(Optional<()>);
 
-    rule!(annotated_expression<ParsedSubExpr> as expression; span; children!(
-        [expression(e)] => e,
-        [expression(e), expression(annot)] => {
+    rule!(annotated_expression<ParsedSubExpr>; span; children!(
+        [operator_expression(e)] => e,
+        [operator_expression(e), expression(annot)] => {
             spanned(span, Annot(e, annot))
         },
     ));
 
-    rule!(operator_expression<ParsedSubExpr> as expression; prec_climb!(
+    rule!(operator_expression<ParsedSubExpr>; prec_climb!(application_expression,
         {
             use Rule::*;
             // In order of precedence
@@ -937,7 +911,7 @@ make_parser! {
                     .collect(),
             )
         },
-        (expression(l), op, expression(r)) => {
+        (operator_expression(l), op, operator_expression(r)) => {
             use crate::BinOp::*;
             use Rule::*;
             let op = match op.as_rule() {
@@ -966,32 +940,38 @@ make_parser! {
     token_rule!(Some_<()>);
     token_rule!(toMap<()>);
 
-    rule!(application_expression<ParsedSubExpr> as expression; children!(
-        [expression(e)] => e,
-        [expression(first), expression(rest)..] => {
+    rule!(application_expression<ParsedSubExpr>; children!(
+        [first_application_expression(e)] => e,
+        [first_application_expression(first), import_expression(rest)..] => {
             rest.fold(first, |acc, e| unspanned(App(acc, e)))
         },
     ));
 
-    rule!(first_application_expression<ParsedSubExpr> as expression; span;
+    rule!(first_application_expression<ParsedSubExpr>; span;
             children!(
-        [expression(e)] => e,
-        [Some_(()), expression(e)] => {
+        [Some_(()), import_expression(e)] => {
             spanned(span, SomeLit(e))
         },
-        [merge(()), expression(x), expression(y)] => {
+        [merge(()), import_expression(x), import_expression(y)] => {
             spanned(span, Merge(x, y, None))
         },
+        [import_expression(e)] => e,
     ));
 
-    rule!(selector_expression<ParsedSubExpr> as expression; children!(
-        [expression(e)] => e,
-        [expression(first), selector(rest)..] => {
+    rule!(import_expression<ParsedSubExpr>; span;
+            children!(
+        [selector_expression(e)] => e,
+        [import(e)] => e,
+    ));
+
+    rule!(selector_expression<ParsedSubExpr>; children!(
+        [primitive_expression(e)] => e,
+        [primitive_expression(first), selector(rest)..] => {
             rest.fold(first, |acc, e| unspanned(match e {
                 Either::Left(l) => Field(acc, l),
                 Either::Right(ls) => Projection(acc, ls),
             }))
-        }
+        },
     ));
 
     rule!(selector<Either<Label, DupTreeSet<Label>>>; children!(
@@ -1004,24 +984,30 @@ make_parser! {
         [label(ls)..] => ls.collect(),
     ));
 
-    rule!(primitive_expression<ParsedSubExpr> as expression; span; children!(
+    rule!(primitive_expression<ParsedSubExpr>; span; children!(
         [double_literal(n)] => spanned(span, DoubleLit(n)),
         [natural_literal(n)] => spanned(span, NaturalLit(n)),
         [integer_literal(n)] => spanned(span, IntegerLit(n)),
         [double_quote_literal(s)] => spanned(span, TextLit(s)),
         [single_quote_literal(s)] => spanned(span, TextLit(s)),
+        [empty_record_type(e)] => e,
+        [empty_record_literal(e)] => e,
+        [non_empty_record_type_or_literal(e)] => e,
+        [union_type(e)] => e,
+        [non_empty_list_literal(e)] => e,
+        [identifier(e)] => e,
         [expression(e)] => e,
     ));
 
-    rule!(empty_record_literal<ParsedSubExpr> as expression; span;
+    rule!(empty_record_literal<ParsedSubExpr>; span;
         captured_str!(_) => spanned(span, RecordLit(Default::default()))
     );
 
-    rule!(empty_record_type<ParsedSubExpr> as expression; span;
+    rule!(empty_record_type<ParsedSubExpr>; span;
         captured_str!(_) => spanned(span, RecordType(Default::default()))
     );
 
-    rule!(non_empty_record_type_or_literal<ParsedSubExpr> as expression; span;
+    rule!(non_empty_record_type_or_literal<ParsedSubExpr>; span;
           children!(
         [label(first_label), non_empty_record_type(rest)] => {
             let (first_expr, mut map) = rest;
@@ -1057,7 +1043,7 @@ make_parser! {
         [label(name), expression(expr)] => (name, expr)
     ));
 
-    rule!(union_type<ParsedSubExpr> as expression; span; children!(
+    rule!(union_type<ParsedSubExpr>; span; children!(
         [empty_union_type(_)] => {
             spanned(span, UnionType(Default::default()))
         },
@@ -1073,7 +1059,7 @@ make_parser! {
         [label(name)] => (name, None),
     ));
 
-    rule!(non_empty_list_literal<ParsedSubExpr> as expression; span;
+    rule!(non_empty_list_literal<ParsedSubExpr>; span;
           children!(
         [expression(items)..] => spanned(
             span,
@@ -1081,7 +1067,7 @@ make_parser! {
         )
     ));
 
-    rule!(final_expression<ParsedSubExpr> as expression; children!(
+    rule!(final_expression<ParsedSubExpr>; children!(
         [expression(e), EOI(_eoi)] => e
     ));
 }
@@ -1092,7 +1078,7 @@ pub fn parse_expr(s: &str) -> ParseResult<ParsedSubExpr> {
     let expr = do_parse(rc_input, pairs.next().unwrap())?;
     assert_eq!(pairs.next(), None);
     match expr {
-        ParsedValue::expression(e) => Ok(e),
+        ParsedValue::final_expression(e) => Ok(e),
         _ => unreachable!(),
     }
 }
-- 
cgit v1.2.3


From 7b891800afa932660bc889e43c41c5d8f805cdc2 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 27 Aug 2019 13:42:53 +0200
Subject: Rework parse macros to avoid the large ParsedValue enum

---
 dhall_syntax/src/parser.rs | 285 ++++++++++++++++++++++-----------------------
 1 file changed, 139 insertions(+), 146 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 2debc8b..8facb3e 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -119,6 +119,76 @@ fn debug_pair(pair: Pair<Rule>) -> String {
     s
 }
 
+macro_rules! parse_children {
+    // Variable length pattern with a common unary variant
+    (@match_forwards,
+        $parse_args:expr,
+        $iter:expr,
+        ($body:expr),
+        $variant:ident ($x:ident)..,
+        $($rest:tt)*
+    ) => {
+        parse_children!(@match_backwards,
+            $parse_args, $iter,
+            ({
+                let $x = $iter
+                    .map(|x| Parsers::$variant($parse_args, x))
+                    .collect::<Result<Vec<_>, _>>()?
+                    .into_iter();
+                $body
+            }),
+            $($rest)*
+        )
+    };
+    // Single item pattern
+    (@match_forwards,
+        $parse_args:expr,
+        $iter:expr,
+        ($body:expr),
+        $variant:ident ($x:pat),
+        $($rest:tt)*
+    ) => {{
+        let p = $iter.next().unwrap();
+        let $x = Parsers::$variant($parse_args, p)?;
+        parse_children!(@match_forwards,
+            $parse_args, $iter,
+            ($body),
+            $($rest)*
+        )
+    }};
+    // Single item pattern after a variable length one: declare reversed and take from the end
+    (@match_backwards,
+        $parse_args:expr,
+        $iter:expr,
+        ($body:expr),
+        $variant:ident ($x:pat),
+        $($rest:tt)*
+    ) => {
+        parse_children!(@match_backwards, $parse_args, $iter, ({
+            let p = $iter.next_back().unwrap();
+            let $x = Parsers::$variant($parse_args, p)?;
+            $body
+        }), $($rest)*)
+    };
+
+    // Check no elements remain
+    (@match_forwards, $parse_args:expr, $iter:expr, ($body:expr) $(,)*) => {
+        $body
+    };
+    // After a variable length pattern, everything has already been consumed
+    (@match_backwards, $parse_args:expr, $iter:expr, ($body:expr) $(,)*) => {
+        $body
+    };
+
+    ($parse_args:expr, $iter:expr; [$($args:tt)*] => $body:expr) => {
+        parse_children!(@match_forwards,
+            $parse_args, $iter,
+            ($body),
+            $($args)*,
+        )
+    };
+}
+
 macro_rules! make_parser {
     (@children_pattern,
         $varpat:ident,
@@ -155,7 +225,6 @@ macro_rules! make_parser {
         $varpat:ident,
         [$variant:ident ($x:pat), $($rest:tt)*]
     ) => (
-        true &&
         make_parser!(@children_filter, $varpat, [$($rest)*])
     );
     (@children_filter,
@@ -167,25 +236,6 @@ macro_rules! make_parser {
     );
     (@children_filter, $varpat:ident, [$(,)*]) => (true);
 
-    (@rule_alias,
-        rule!( $name:ident<$o:ty>; $($args:tt)* )
-    ) => (
-        Rule::$name
-    );
-    (@rule_alias,
-        rule!(
-            $name:ident<$o:ty>;
-            $($args:tt)*
-        )
-    ) => ({
-        Rule::$name
-    });
-    (@rule_alias,
-        token_rule!($name:ident<$o:ty>)
-    ) => ({
-        Rule::$name
-    });
-
     (@body,
         ($climbers:expr, $input:expr, $pair:expr),
         rule!(
@@ -194,11 +244,9 @@ macro_rules! make_parser {
             captured_str!($x:pat) => $body:expr
         )
     ) => ({
-        let res: Result<_, String> = try {
-            let $span = Span::make($input, $pair.as_span());
-            let $x = $pair.as_str();
-            ParsedValue::$name($body)
-        };
+        let $span = Span::make($input.clone(), $pair.as_span());
+        let $x = $pair.as_str();
+        let res: Result<_, String> = try { $body };
         res.map_err(|msg| custom_parse_error(&$pair, msg))
     });
     (@body,
@@ -209,90 +257,64 @@ macro_rules! make_parser {
             children!( $( [$($args:tt)*] => $body:expr ),* $(,)* )
         )
     ) => ({
-        let children: Vec<_> = $pair
-            .clone()
-            .into_inner()
-            .map(|p| parse_any($climbers, $input.clone(), p))
-            .collect::<Result<_, _>>()?;
         let children_rules: Vec<Rule> = $pair
             .clone()
             .into_inner()
             .map(|p| p.as_rule())
-            .map(rule_alias)
             .collect();
 
+        let $span = Span::make($input.clone(), $pair.as_span());
+        #[allow(unused_mut)]
+        let mut iter = $pair.clone().into_inner();
+
         #[allow(unreachable_code)]
-        let res: Result<_, String> = try {
-            #[allow(unused_imports)]
-            use ParsedValue::*;
-            let $span = Span::make($input, $pair.as_span());
-            #[allow(unused_mut)]
-            let mut iter = children.into_iter();
-
-            match children_rules.as_slice() {
-                $(
-                    make_parser!(@children_pattern, x, (), [$($args)*,])
-                    if make_parser!(@children_filter, x, [$($args)*,])
-                    => {
-                        let ret =
-                            improved_slice_patterns::destructure_iter!(iter;
-                                [$($args)*] => $body
-                        );
-                        match ret {
-                            Some(x) => x,
-                            None => Err({
-                                format!("Unexpected children: {:?}", children_rules)
-                            })?
+        match children_rules.as_slice() {
+            $(
+                make_parser!(@children_pattern, x, (), [$($args)*,])
+                if make_parser!(@children_filter, x, [$($args)*,])
+                => {
+                    parse_children!(($climbers, $input.clone()), iter;
+                        [$($args)*] => {
+                            let res: Result<_, String> = try { $body };
+                            res.map_err(|msg| custom_parse_error(&$pair, msg))
                         }
-                    }
-                    ,
-                )*
-                [..] => Err({
-                    format!("Unexpected children: {:?}", children_rules)
-                })?,
-            }
-        };
-
-        let res = res.map_err(|msg| custom_parse_error(&$pair, msg))?;
-        Ok(ParsedValue::$name(res))
+                    )
+                }
+                ,
+            )*
+            [..] => Err(custom_parse_error(
+                &$pair,
+                format!("Unexpected children: {:?}", children_rules)
+            )),
+        }
     });
     (@body,
         ($climbers:expr, $input:expr, $pair:expr),
         rule!(
             $name:ident<$o:ty>;
-            prec_climb!($other_name:ident, $_climber:expr, $args:pat => $body:expr $(,)* )
+            prec_climb!(
+                $other_rule:ident,
+                $_climber:expr,
+                $args:pat => $body:expr $(,)*
+            )
         )
     ) => ({
-        let climber = $climbers.get(&Rule::$name).expect(&format!("UUUU: {:?}", $climbers));
+        let climber = $climbers.get(&Rule::$name).unwrap();
         climber.climb(
             $pair.clone().into_inner(),
-            |p| {
-                let parsed = parse_any($climbers, $input.clone(), p)?;
-                if let ParsedValue::$other_name(x) = parsed {
-                    Ok(ParsedValue::$name(x))
-                } else {
-                    unreachable!()
-                }
-            },
+            |p| Parsers::$other_rule(($climbers, $input.clone()), p),
             |l, op, r| {
-                let (l, r) = (l?, r?);
-                let res: Result<_, String> = try {
-                    #[allow(unused_imports)]
-                    use ParsedValue::*;
-                    match (l, op, r) {
-                        $args => ParsedValue::$name($body),
-                        children => Err(
-                            format!("Unexpected children: {:?}", children)
-                        )?,
-                    }
-                };
+                let $args = (l?, op, r?);
+                let res: Result<_, String> = try { $body };
                 res.map_err(|msg| custom_parse_error(&$pair, msg))
             },
         )
     });
     (@body,
         ($($things:tt)*),
-        rule!( $name:ident<$o:ty>; $($args:tt)*
+        rule!(
+            $name:ident<$o:ty>;
+            $($args:tt)*
         )
     ) => ({
         make_parser!(@body,
@@ -308,14 +330,14 @@ macro_rules! make_parser {
         ($($things:tt)*),
         token_rule!($name:ident<$o:ty>)
     ) => ({
-        Ok(ParsedValue::$name(()))
+        Ok(())
     });
 
     (@construct_climber,
         ($map:expr),
         rule!(
             $name:ident<$o:ty>;
-            prec_climb!( $other_name:ident, $climber:expr, $($_rest:tt)* )
+            prec_climb!($other_rule:ident, $climber:expr, $($_rest:tt)* )
         )
     ) => ({
         $map.insert(Rule::$name, $climber)
@@ -323,10 +345,19 @@ macro_rules! make_parser {
     (@construct_climber, ($($things:tt)*), $($args:tt)*) => (());
 
     ($( $submac:ident!( $name:ident<$o:ty> $($args:tt)* ); )*) => (
-        #[allow(non_camel_case_types, dead_code, clippy::large_enum_variant)]
-        #[derive(Debug)]
-        enum ParsedValue<'a> {
-            $( $name($o), )*
+        struct Parsers;
+
+        impl Parsers {
+            $(
+            #[allow(non_snake_case, unused_variables)]
+            fn $name<'a>(
+                (climbers, input): (&HashMap<Rule, PrecClimber<Rule>>, Rc<str>),
+                pair: Pair<'a, Rule>,
+            ) -> ParseResult<$o> {
+                make_parser!(@body, (climbers, input, pair),
+                               $submac!( $name<$o> $($args)* ))
+            }
+            )*
         }
 
         fn construct_precclimbers() -> HashMap<Rule, PrecClimber<Rule>> {
@@ -338,56 +369,23 @@ macro_rules! make_parser {
             map
         }
 
-        struct Parsers;
+        struct EntryPoint;
 
-        impl Parsers {
+        impl EntryPoint {
             $(
-            #[allow(non_snake_case, unused_variables)]
+            #[allow(non_snake_case, dead_code)]
             fn $name<'a>(
-                climbers: &HashMap<Rule, PrecClimber<Rule>>,
                 input: Rc<str>,
                 pair: Pair<'a, Rule>,
-            ) -> ParseResult<ParsedValue<'a>> {
-                make_parser!(@body, (climbers, input, pair),
-                               $submac!( $name<$o> $($args)* ))
+            ) -> ParseResult<$o> {
+                let climbers = construct_precclimbers();
+                Parsers::$name((&climbers, input), pair)
             }
             )*
         }
-
-        fn rule_alias(r: Rule) -> Rule {
-            match r {
-                $(
-                    Rule::$name => {
-                        make_parser!(@rule_alias, $submac!($name<$o> $($args)*))
-                    }
-                )*
-                r => r,
-            }
-        }
-
-        fn parse_any<'a>(
-            climbers: &HashMap<Rule, PrecClimber<Rule>>,
-            input: Rc<str>,
-            pair: Pair<'a, Rule>,
-        ) -> ParseResult<ParsedValue<'a>> {
-            match pair.as_rule() {
-                $(
-                    Rule::$name => Parsers::$name(climbers, input, pair),
-                )*
-                r => Err(custom_parse_error(&pair, format!("Unexpected {:?}", r))),
-            }
-        }
     );
 }
 
-fn do_parse<'a>(
-    input: Rc<str>,
-    pair: Pair<'a, Rule>,
-) -> ParseResult<ParsedValue<'a>> {
-    let climbers = construct_precclimbers();
-    parse_any(&climbers, input, pair)
-}
-
 // Trim the shared indent off of a vec of lines, as defined by the Dhall semantics of multiline
 // literals.
 fn trim_indent(lines: &mut Vec<ParsedText>) {
@@ -857,14 +855,18 @@ make_parser! {
         [operator_expression(typ), arrow(()), expression(body)] => {
             spanned(span, Pi("_".into(), typ, body))
         },
-        [merge(()), import_expression(x), import_expression(y), application_expression(z)] => {
+        [merge(()), import_expression(x), import_expression(y),
+                application_expression(z)] => {
             spanned(span, Merge(x, y, Some(z)))
         },
         [empty_list_literal(e)] => e,
         [assert(()), expression(x)] => {
             spanned(span, Assert(x))
         },
-        [annotated_expression(e)] => e,
+        [operator_expression(e)] => e,
+        [operator_expression(e), expression(annot)] => {
+            spanned(span, Annot(e, annot))
+        },
     ));
 
     rule!(let_binding<(Label, Option<ParsedSubExpr>, ParsedSubExpr)>;
@@ -878,14 +880,8 @@ make_parser! {
     token_rule!(List<()>);
     token_rule!(Optional<()>);
 
-    rule!(annotated_expression<ParsedSubExpr>; span; children!(
-        [operator_expression(e)] => e,
-        [operator_expression(e), expression(annot)] => {
-            spanned(span, Annot(e, annot))
-        },
-    ));
-
-    rule!(operator_expression<ParsedSubExpr>; prec_climb!(application_expression,
+    rule!(operator_expression<ParsedSubExpr>; prec_climb!(
+        application_expression,
         {
             use Rule::*;
             // In order of precedence
@@ -911,7 +907,7 @@ make_parser! {
                     .collect(),
             )
         },
-        (operator_expression(l), op, operator_expression(r)) => {
+        (l, op, r) => {
             use crate::BinOp::*;
             use Rule::*;
             let op = match op.as_rule() {
@@ -1075,10 +1071,7 @@ make_parser! {
 pub fn parse_expr(s: &str) -> ParseResult<ParsedSubExpr> {
     let mut pairs = DhallParser::parse(Rule::final_expression, s)?;
     let rc_input = s.to_string().into();
-    let expr = do_parse(rc_input, pairs.next().unwrap())?;
+    let expr = EntryPoint::final_expression(rc_input, pairs.next().unwrap())?;
     assert_eq!(pairs.next(), None);
-    match expr {
-        ParsedValue::final_expression(e) => Ok(e),
-        _ => unreachable!(),
-    }
+    Ok(expr)
 }
-- 
cgit v1.2.3


From cddb3b0a0270cf6d41bbaa1a0e01708e91a9673c Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 27 Aug 2019 22:35:33 +0200
Subject: s/token_rule/rule/

---
 dhall_syntax/src/parser.rs | 40 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 8facb3e..4da1dfc 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -328,7 +328,7 @@ macro_rules! make_parser {
     });
     (@body,
         ($($things:tt)*),
-        token_rule!($name:ident<$o:ty>)
+        rule!($name:ident<$o:ty>)
     ) => ({
         Ok(())
     });
@@ -428,7 +428,7 @@ fn trim_indent(lines: &mut Vec<ParsedText>) {
 }
 
 make_parser! {
-    token_rule!(EOI<()>);
+    rule!(EOI<()>);
 
     rule!(simple_label<Label>;
         captured_str!(s) => Label::from(s.trim().to_owned())
@@ -611,9 +611,9 @@ make_parser! {
         }
     );
 
-    token_rule!(NaN<()>);
-    token_rule!(minus_infinity_literal<()>);
-    token_rule!(plus_infinity_literal<()>);
+    rule!(NaN<()>);
+    rule!(minus_infinity_literal<()>);
+    rule!(plus_infinity_literal<()>);
 
     rule!(numeric_double_literal<core::Double>;
         captured_str!(s) => {
@@ -762,7 +762,7 @@ make_parser! {
         }
     );
 
-    token_rule!(missing<()>);
+    rule!(missing<()>);
 
     rule!(import_type<ImportLocation<ParsedSubExpr>>; children!(
         [missing(_)] => {
@@ -796,8 +796,8 @@ make_parser! {
             crate::Import {mode: ImportMode::Code, location, hash: Some(h) },
     ));
 
-    token_rule!(Text<()>);
-    token_rule!(Location<()>);
+    rule!(Text<()>);
+    rule!(Location<()>);
 
     rule!(import<ParsedSubExpr>; span; children!(
         [import_hashed(imp)] => {
@@ -820,13 +820,13 @@ make_parser! {
         },
     ));
 
-    token_rule!(lambda<()>);
-    token_rule!(forall<()>);
-    token_rule!(arrow<()>);
-    token_rule!(merge<()>);
-    token_rule!(assert<()>);
-    token_rule!(if_<()>);
-    token_rule!(in_<()>);
+    rule!(lambda<()>);
+    rule!(forall<()>);
+    rule!(arrow<()>);
+    rule!(merge<()>);
+    rule!(assert<()>);
+    rule!(if_<()>);
+    rule!(in_<()>);
 
     rule!(empty_list_literal<ParsedSubExpr>; span; children!(
         [application_expression(e)] => {
@@ -877,8 +877,8 @@ make_parser! {
             (name, None, expr),
     ));
 
-    token_rule!(List<()>);
-    token_rule!(Optional<()>);
+    rule!(List<()>);
+    rule!(Optional<()>);
 
     rule!(operator_expression<ParsedSubExpr>; prec_climb!(
         application_expression,
@@ -933,8 +933,8 @@ make_parser! {
         }
     ));
 
-    token_rule!(Some_<()>);
-    token_rule!(toMap<()>);
+    rule!(Some_<()>);
+    rule!(toMap<()>);
 
     rule!(application_expression<ParsedSubExpr>; children!(
         [first_application_expression(e)] => e,
@@ -1048,7 +1048,7 @@ make_parser! {
         },
     ));
 
-    token_rule!(empty_union_type<()>);
+    rule!(empty_union_type<()>);
 
     rule!(union_type_entry<(Label, Option<ParsedSubExpr>)>; children!(
         [label(name), expression(expr)] => (name, Some(expr)),
-- 
cgit v1.2.3


From a981afc465f4279a7a4d6ce3ac5844e04846613b Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 27 Aug 2019 22:58:20 +0200
Subject: clippy

---
 dhall_syntax/src/core/expr.rs   | 2 +-
 dhall_syntax/src/core/import.rs | 2 +-
 dhall_syntax/src/parser.rs      | 6 +++---
 3 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index efbcee2..32166a6 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -331,7 +331,7 @@ impl<E> Expr<E> {
             ExprF::BinOp(BinOp::ImportAlt, l, r) => l
                 .as_ref()
                 .traverse_resolve_with_visitor(visitor)
-                .or(r.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 {
diff --git a/dhall_syntax/src/core/import.rs b/dhall_syntax/src/core/import.rs
index 9329d48..d1f3fca 100644
--- a/dhall_syntax/src/core/import.rs
+++ b/dhall_syntax/src/core/import.rs
@@ -79,7 +79,7 @@ impl<SE> ImportLocation<SE> {
     ) -> Result<ImportLocation<SE2>, Err> {
         use ImportLocation::*;
         Ok(match self {
-            Local(prefix, path) => Local(prefix.clone(), path.clone()),
+            Local(prefix, path) => Local(*prefix, path.clone()),
             Remote(url) => Remote(url.visit_subexpr(f)?),
             Env(env) => Env(env.clone()),
             Missing => Missing,
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 4da1dfc..d631a19 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -349,7 +349,7 @@ macro_rules! make_parser {
 
         impl Parsers {
             $(
-            #[allow(non_snake_case, unused_variables)]
+            #[allow(non_snake_case, unused_variables, clippy::let_unit_value)]
             fn $name<'a>(
                 (climbers, input): (&HashMap<Rule, PrecClimber<Rule>>, Rc<str>),
                 pair: Pair<'a, Rule>,
@@ -508,7 +508,7 @@ make_parser! {
                         0xAFFFE..=0xAFFFF | 0xBFFFE..=0xBFFFF |
                         0xCFFFE..=0xCFFFF | 0xDFFFE..=0xDFFFF |
                         0xEFFFE..=0xEFFFF | 0xFFFFE..=0xFFFFF |
-                        0x10FFFE..=0x10FFFF => {
+                        0x10_FFFE..=0x10_FFFF => {
                             let c_ecapsed = c.escape_unicode();
                             Err(format!("Escape sequences can't contain non-characters: \"{}\"", c_ecapsed))?
                         },
@@ -1064,7 +1064,7 @@ make_parser! {
     ));
 
     rule!(final_expression<ParsedSubExpr>; children!(
-        [expression(e), EOI(_eoi)] => e
+        [expression(e), EOI(_)] => e
     ));
 }
 
-- 
cgit v1.2.3


From a7363042a16364a6dafdd545f4069dcf04a4197e Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Tue, 27 Aug 2019 23:18:13 +0200
Subject: Rename SubExpr to Expr, and Expr to RawExpr

For clarity, and consistency with Value
---
 dhall_syntax/src/core/expr.rs    | 64 ++++++++++++++++++++--------------------
 dhall_syntax/src/core/visitor.rs |  9 +++---
 dhall_syntax/src/parser.rs       | 64 ++++++++++++++++++++--------------------
 dhall_syntax/src/printer.rs      |  6 ++--
 4 files changed, 71 insertions(+), 72 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index 32166a6..2d73a64 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -166,19 +166,21 @@ pub enum Builtin {
     TextShow,
 }
 
-// Each node carries an annotation. In practice it's either X (no annotation) or a Span.
+// Each node carries an annotation.
 #[derive(Debug, Clone)]
-pub struct SubExpr<Embed>(Box<(Expr<Embed>, Option<Span>)>);
+pub struct Expr<Embed>(Box<(RawExpr<Embed>, Option<Span>)>);
 
-impl<Embed: PartialEq> std::cmp::PartialEq for SubExpr<Embed> {
+pub type RawExpr<Embed> = ExprF<Expr<Embed>, Embed>;
+
+impl<Embed: PartialEq> std::cmp::PartialEq for Expr<Embed> {
     fn eq(&self, other: &Self) -> bool {
         self.0.as_ref().0 == other.0.as_ref().0
     }
 }
 
-impl<Embed: Eq> std::cmp::Eq for SubExpr<Embed> {}
+impl<Embed: Eq> std::cmp::Eq for Expr<Embed> {}
 
-impl<Embed: std::hash::Hash> std::hash::Hash for SubExpr<Embed> {
+impl<Embed: std::hash::Hash> std::hash::Hash for Expr<Embed> {
     fn hash<H>(&self, state: &mut H)
     where
         H: std::hash::Hasher,
@@ -187,8 +189,6 @@ impl<Embed: std::hash::Hash> std::hash::Hash for SubExpr<Embed> {
     }
 }
 
-pub type Expr<Embed> = ExprF<SubExpr<Embed>, Embed>;
-
 /// Syntax tree for expressions
 // Having the recursion out of the enum definition enables writing
 // much more generic code and improves pattern-matching behind
@@ -310,11 +310,11 @@ impl<SE, E> ExprF<SE, E> {
     }
 }
 
-impl<E> Expr<E> {
+impl<E> RawExpr<E> {
     pub fn traverse_resolve<E2, Err>(
         &self,
-        visit_import: impl FnMut(&Import<SubExpr<E2>>) -> Result<E2, Err>,
-    ) -> Result<Expr<E2>, Err> {
+        visit_import: impl FnMut(&Import<Expr<E2>>) -> Result<E2, Err>,
+    ) -> Result<RawExpr<E2>, Err> {
         self.traverse_resolve_with_visitor(&mut visitor::ResolveVisitor(
             visit_import,
         ))
@@ -323,9 +323,9 @@ impl<E> Expr<E> {
     pub(crate) fn traverse_resolve_with_visitor<E2, Err, F1>(
         &self,
         visitor: &mut visitor::ResolveVisitor<F1>,
-    ) -> Result<Expr<E2>, Err>
+    ) -> Result<RawExpr<E2>, Err>
     where
-        F1: FnMut(&Import<SubExpr<E2>>) -> Result<E2, Err>,
+        F1: FnMut(&Import<Expr<E2>>) -> Result<E2, Err>,
     {
         match self {
             ExprF::BinOp(BinOp::ImportAlt, l, r) => l
@@ -343,52 +343,52 @@ impl<E> Expr<E> {
     }
 }
 
-impl<E> SubExpr<E> {
-    pub fn as_ref(&self) -> &Expr<E> {
+impl<E> Expr<E> {
+    pub fn as_ref(&self) -> &RawExpr<E> {
         &self.0.as_ref().0
     }
 
-    pub fn new(x: Expr<E>, n: Span) -> Self {
-        SubExpr(Box::new((x, Some(n))))
+    pub fn new(x: RawExpr<E>, n: Span) -> Self {
+        Expr(Box::new((x, Some(n))))
     }
 
-    pub fn from_expr_no_span(x: Expr<E>) -> Self {
-        SubExpr(Box::new((x, None)))
+    pub fn from_expr_no_span(x: RawExpr<E>) -> Self {
+        Expr(Box::new((x, None)))
     }
 
     pub fn from_builtin(b: Builtin) -> Self {
-        SubExpr::from_expr_no_span(ExprF::Builtin(b))
+        Expr::from_expr_no_span(ExprF::Builtin(b))
     }
 
-    pub fn rewrap<E2>(&self, x: Expr<E2>) -> SubExpr<E2> {
-        SubExpr(Box::new((x, (self.0).1.clone())))
+    pub fn rewrap<E2>(&self, x: RawExpr<E2>) -> Expr<E2> {
+        Expr(Box::new((x, (self.0).1.clone())))
     }
 }
 
-impl<E> SubExpr<E> {
+impl<E> Expr<E> {
     pub fn traverse_resolve<E2, Err>(
         &self,
-        visit_import: impl FnMut(&Import<SubExpr<E2>>) -> Result<E2, Err>,
-    ) -> Result<SubExpr<E2>, Err> {
+        visit_import: impl FnMut(&Import<Expr<E2>>) -> Result<E2, Err>,
+    ) -> Result<Expr<E2>, Err> {
         Ok(self.rewrap(self.as_ref().traverse_resolve(visit_import)?))
     }
 }
 
 // Should probably rename this
-pub fn rc<E>(x: Expr<E>) -> SubExpr<E> {
-    SubExpr::from_expr_no_span(x)
+pub fn rc<E>(x: RawExpr<E>) -> Expr<E> {
+    Expr::from_expr_no_span(x)
 }
 
 pub(crate) fn spanned(
     span: Span,
-    x: crate::parser::ParsedExpr,
-) -> crate::parser::ParsedSubExpr {
-    SubExpr::new(x, span)
+    x: crate::parser::ParsedRawExpr,
+) -> crate::parser::ParsedExpr {
+    Expr::new(x, span)
 }
 pub(crate) fn unspanned(
-    x: crate::parser::ParsedExpr,
-) -> crate::parser::ParsedSubExpr {
-    SubExpr::from_expr_no_span(x)
+    x: crate::parser::ParsedRawExpr,
+) -> crate::parser::ParsedExpr {
+    Expr::from_expr_no_span(x)
 }
 
 /// Add an isize to an usize
diff --git a/dhall_syntax/src/core/visitor.rs b/dhall_syntax/src/core/visitor.rs
index 5a5fcc9..49fff60 100644
--- a/dhall_syntax/src/core/visitor.rs
+++ b/dhall_syntax/src/core/visitor.rs
@@ -247,18 +247,17 @@ where
 
 pub struct ResolveVisitor<F1>(pub F1);
 
-impl<'a, 'b, E, E2, Err, F1>
-    ExprFFallibleVisitor<'a, SubExpr<E>, SubExpr<E2>, E, E2>
+impl<'a, 'b, E, E2, Err, F1> ExprFFallibleVisitor<'a, Expr<E>, Expr<E2>, E, E2>
     for &'b mut ResolveVisitor<F1>
 where
-    F1: FnMut(&Import<SubExpr<E2>>) -> Result<E2, Err>,
+    F1: FnMut(&Import<Expr<E2>>) -> Result<E2, Err>,
 {
     type Error = Err;
 
     fn visit_subexpr(
         &mut self,
-        subexpr: &'a SubExpr<E>,
-    ) -> Result<SubExpr<E2>, Self::Error> {
+        subexpr: &'a Expr<E>,
+    ) -> Result<Expr<E2>, Self::Error> {
         Ok(subexpr.rewrap(
             subexpr
                 .as_ref()
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index d631a19..defa79b 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -18,10 +18,10 @@ use crate::*;
 // their own crate because they are quite general and useful. For now they
 // are here and hopefully you can figure out how they work.
 
+pub(crate) type ParsedRawExpr = RawExpr<!>;
 pub(crate) type ParsedExpr = Expr<!>;
-pub(crate) type ParsedSubExpr = SubExpr<!>;
-type ParsedText = InterpolatedText<ParsedSubExpr>;
-type ParsedTextContents = InterpolatedTextContents<ParsedSubExpr>;
+type ParsedText = InterpolatedText<ParsedExpr>;
+type ParsedTextContents = InterpolatedTextContents<ParsedExpr>;
 
 pub type ParseError = pest::error::Error<Rule>;
 
@@ -551,7 +551,7 @@ make_parser! {
     rule!(escaped_interpolation<&'a str>;
         captured_str!(_) => "${"
     );
-    rule!(interpolation<ParsedSubExpr>; children!(
+    rule!(interpolation<ParsedExpr>; children!(
         [expression(e)] => e
     ));
 
@@ -593,7 +593,7 @@ make_parser! {
         },
     ));
 
-    rule!(builtin<ParsedSubExpr>; span;
+    rule!(builtin<ParsedExpr>; span;
         captured_str!(s) => {
             spanned(span, match crate::Builtin::parse(s) {
                 Some(b) => Builtin(b),
@@ -650,7 +650,7 @@ make_parser! {
         }
     );
 
-    rule!(identifier<ParsedSubExpr>; span; children!(
+    rule!(identifier<ParsedExpr>; span; children!(
         [variable(v)] => {
             spanned(span, Var(v))
         },
@@ -708,7 +708,7 @@ make_parser! {
         _ => unreachable!(),
     });
 
-    rule!(http_raw<URL<ParsedSubExpr>>; children!(
+    rule!(http_raw<URL<ParsedExpr>>; children!(
         [scheme(sch), authority(auth), path(p)] => URL {
             scheme: sch,
             authority: auth,
@@ -729,7 +729,7 @@ make_parser! {
 
     rule!(query<String>; captured_str!(s) => s.to_owned());
 
-    rule!(http<URL<ParsedSubExpr>>; children!(
+    rule!(http<URL<ParsedExpr>>; children!(
         [http_raw(url)] => url,
         [http_raw(url), import_expression(e)] =>
             URL { headers: Some(e), ..url },
@@ -764,7 +764,7 @@ make_parser! {
 
     rule!(missing<()>);
 
-    rule!(import_type<ImportLocation<ParsedSubExpr>>; children!(
+    rule!(import_type<ImportLocation<ParsedExpr>>; children!(
         [missing(_)] => {
             ImportLocation::Missing
         },
@@ -789,7 +789,7 @@ make_parser! {
         Hash::SHA256(hex::decode(hash).unwrap())
     });
 
-    rule!(import_hashed<crate::Import<ParsedSubExpr>>; children!(
+    rule!(import_hashed<crate::Import<ParsedExpr>>; children!(
         [import_type(location)] =>
             crate::Import {mode: ImportMode::Code, location, hash: None },
         [import_type(location), hash(h)] =>
@@ -799,7 +799,7 @@ make_parser! {
     rule!(Text<()>);
     rule!(Location<()>);
 
-    rule!(import<ParsedSubExpr>; span; children!(
+    rule!(import<ParsedExpr>; span; children!(
         [import_hashed(imp)] => {
             spanned(span, Import(crate::Import {
                 mode: ImportMode::Code,
@@ -828,13 +828,13 @@ make_parser! {
     rule!(if_<()>);
     rule!(in_<()>);
 
-    rule!(empty_list_literal<ParsedSubExpr>; span; children!(
+    rule!(empty_list_literal<ParsedExpr>; span; children!(
         [application_expression(e)] => {
             spanned(span, EmptyListLit(e))
         },
     ));
 
-    rule!(expression<ParsedSubExpr>; span; children!(
+    rule!(expression<ParsedExpr>; span; children!(
         [lambda(()), label(l), expression(typ),
                 arrow(()), expression(body)] => {
             spanned(span, Lam(l, typ, body))
@@ -869,7 +869,7 @@ make_parser! {
         },
     ));
 
-    rule!(let_binding<(Label, Option<ParsedSubExpr>, ParsedSubExpr)>;
+    rule!(let_binding<(Label, Option<ParsedExpr>, ParsedExpr)>;
             children!(
         [label(name), expression(annot), expression(expr)] =>
             (name, Some(annot), expr),
@@ -880,7 +880,7 @@ make_parser! {
     rule!(List<()>);
     rule!(Optional<()>);
 
-    rule!(operator_expression<ParsedSubExpr>; prec_climb!(
+    rule!(operator_expression<ParsedExpr>; prec_climb!(
         application_expression,
         {
             use Rule::*;
@@ -936,14 +936,14 @@ make_parser! {
     rule!(Some_<()>);
     rule!(toMap<()>);
 
-    rule!(application_expression<ParsedSubExpr>; children!(
+    rule!(application_expression<ParsedExpr>; children!(
         [first_application_expression(e)] => e,
         [first_application_expression(first), import_expression(rest)..] => {
             rest.fold(first, |acc, e| unspanned(App(acc, e)))
         },
     ));
 
-    rule!(first_application_expression<ParsedSubExpr>; span;
+    rule!(first_application_expression<ParsedExpr>; span;
             children!(
         [Some_(()), import_expression(e)] => {
             spanned(span, SomeLit(e))
@@ -954,13 +954,13 @@ make_parser! {
         [import_expression(e)] => e,
     ));
 
-    rule!(import_expression<ParsedSubExpr>; span;
+    rule!(import_expression<ParsedExpr>; span;
             children!(
         [selector_expression(e)] => e,
         [import(e)] => e,
     ));
 
-    rule!(selector_expression<ParsedSubExpr>; children!(
+    rule!(selector_expression<ParsedExpr>; children!(
         [primitive_expression(e)] => e,
         [primitive_expression(first), selector(rest)..] => {
             rest.fold(first, |acc, e| unspanned(match e {
@@ -980,7 +980,7 @@ make_parser! {
         [label(ls)..] => ls.collect(),
     ));
 
-    rule!(primitive_expression<ParsedSubExpr>; span; children!(
+    rule!(primitive_expression<ParsedExpr>; span; children!(
         [double_literal(n)] => spanned(span, DoubleLit(n)),
         [natural_literal(n)] => spanned(span, NaturalLit(n)),
         [integer_literal(n)] => spanned(span, IntegerLit(n)),
@@ -995,15 +995,15 @@ make_parser! {
         [expression(e)] => e,
     ));
 
-    rule!(empty_record_literal<ParsedSubExpr>; span;
+    rule!(empty_record_literal<ParsedExpr>; span;
         captured_str!(_) => spanned(span, RecordLit(Default::default()))
     );
 
-    rule!(empty_record_type<ParsedSubExpr>; span;
+    rule!(empty_record_type<ParsedExpr>; span;
         captured_str!(_) => spanned(span, RecordType(Default::default()))
     );
 
-    rule!(non_empty_record_type_or_literal<ParsedSubExpr>; span;
+    rule!(non_empty_record_type_or_literal<ParsedExpr>; span;
           children!(
         [label(first_label), non_empty_record_type(rest)] => {
             let (first_expr, mut map) = rest;
@@ -1018,28 +1018,28 @@ make_parser! {
     ));
 
     rule!(non_empty_record_type
-          <(ParsedSubExpr, DupTreeMap<Label, ParsedSubExpr>)>; children!(
+          <(ParsedExpr, DupTreeMap<Label, ParsedExpr>)>; children!(
         [expression(expr), record_type_entry(entries)..] => {
             (expr, entries.collect())
         }
     ));
 
-    rule!(record_type_entry<(Label, ParsedSubExpr)>; children!(
+    rule!(record_type_entry<(Label, ParsedExpr)>; children!(
         [label(name), expression(expr)] => (name, expr)
     ));
 
     rule!(non_empty_record_literal
-          <(ParsedSubExpr, DupTreeMap<Label, ParsedSubExpr>)>; children!(
+          <(ParsedExpr, DupTreeMap<Label, ParsedExpr>)>; children!(
         [expression(expr), record_literal_entry(entries)..] => {
             (expr, entries.collect())
         }
     ));
 
-    rule!(record_literal_entry<(Label, ParsedSubExpr)>; children!(
+    rule!(record_literal_entry<(Label, ParsedExpr)>; children!(
         [label(name), expression(expr)] => (name, expr)
     ));
 
-    rule!(union_type<ParsedSubExpr>; span; children!(
+    rule!(union_type<ParsedExpr>; span; children!(
         [empty_union_type(_)] => {
             spanned(span, UnionType(Default::default()))
         },
@@ -1050,12 +1050,12 @@ make_parser! {
 
     rule!(empty_union_type<()>);
 
-    rule!(union_type_entry<(Label, Option<ParsedSubExpr>)>; children!(
+    rule!(union_type_entry<(Label, Option<ParsedExpr>)>; children!(
         [label(name), expression(expr)] => (name, Some(expr)),
         [label(name)] => (name, None),
     ));
 
-    rule!(non_empty_list_literal<ParsedSubExpr>; span;
+    rule!(non_empty_list_literal<ParsedExpr>; span;
           children!(
         [expression(items)..] => spanned(
             span,
@@ -1063,12 +1063,12 @@ make_parser! {
         )
     ));
 
-    rule!(final_expression<ParsedSubExpr>; children!(
+    rule!(final_expression<ParsedExpr>; children!(
         [expression(e), EOI(_)] => e
     ));
 }
 
-pub fn parse_expr(s: &str) -> ParseResult<ParsedSubExpr> {
+pub fn parse_expr(s: &str) -> ParseResult<ParsedExpr> {
     let mut pairs = DhallParser::parse(Rule::final_expression, s)?;
     let rc_input = s.to_string().into();
     let expr = EntryPoint::final_expression(rc_input, pairs.next().unwrap())?;
diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs
index 256ea65..276590e 100644
--- a/dhall_syntax/src/printer.rs
+++ b/dhall_syntax/src/printer.rs
@@ -112,7 +112,7 @@ enum PrintPhase {
 // Wraps an Expr with a phase, so that phase selsction can be done
 // separate from the actual printing
 #[derive(Clone)]
-struct PhasedExpr<'a, A>(&'a SubExpr<A>, PrintPhase);
+struct PhasedExpr<'a, A>(&'a Expr<A>, PrintPhase);
 
 impl<'a, A: Display + Clone> Display for PhasedExpr<'a, A> {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
@@ -126,7 +126,7 @@ impl<'a, A: Display + Clone> PhasedExpr<'a, A> {
     }
 }
 
-impl<A: Display + Clone> Expr<A> {
+impl<A: Display + Clone> RawExpr<A> {
     fn fmt_phase(
         &self,
         f: &mut fmt::Formatter,
@@ -202,7 +202,7 @@ impl<A: Display + Clone> Expr<A> {
     }
 }
 
-impl<A: Display + Clone> Display for SubExpr<A> {
+impl<A: Display + Clone> Display for Expr<A> {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         self.as_ref().fmt_phase(f, PrintPhase::Base)
     }
-- 
cgit v1.2.3


From aba7e62e49ac9dead0a2868f739091d2d15ff0d1 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 31 Aug 2019 21:59:39 +0200
Subject: Implement parsing of `toMap` keyword

---
 dhall_syntax/src/core/expr.rs    |  2 ++
 dhall_syntax/src/core/visitor.rs |  3 +++
 dhall_syntax/src/parser.rs       |  8 +++++++-
 dhall_syntax/src/printer.rs      | 11 +++++++++++
 4 files changed, 23 insertions(+), 1 deletion(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs
index 2d73a64..51b6c47 100644
--- a/dhall_syntax/src/core/expr.rs
+++ b/dhall_syntax/src/core/expr.rs
@@ -243,6 +243,8 @@ pub enum ExprF<SubExpr, Embed> {
     UnionType(DupTreeMap<Label, Option<SubExpr>>),
     ///  `merge x y : t`
     Merge(SubExpr, SubExpr, Option<SubExpr>),
+    ///  `toMap x : t`
+    ToMap(SubExpr, Option<SubExpr>),
     ///  `e.x`
     Field(SubExpr, Label),
     ///  `e.{ x, y, z }`
diff --git a/dhall_syntax/src/core/visitor.rs b/dhall_syntax/src/core/visitor.rs
index 49fff60..435771e 100644
--- a/dhall_syntax/src/core/visitor.rs
+++ b/dhall_syntax/src/core/visitor.rs
@@ -150,6 +150,9 @@ where
                 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)?),
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index defa79b..24ecc1e 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -827,6 +827,7 @@ make_parser! {
     rule!(assert<()>);
     rule!(if_<()>);
     rule!(in_<()>);
+    rule!(toMap<()>);
 
     rule!(empty_list_literal<ParsedExpr>; span; children!(
         [application_expression(e)] => {
@@ -863,6 +864,9 @@ make_parser! {
         [assert(()), expression(x)] => {
             spanned(span, Assert(x))
         },
+        [toMap(()), import_expression(x), application_expression(y)] => {
+            spanned(span, ToMap(x, Some(y)))
+        },
         [operator_expression(e)] => e,
         [operator_expression(e), expression(annot)] => {
             spanned(span, Annot(e, annot))
@@ -934,7 +938,6 @@ make_parser! {
     ));
 
     rule!(Some_<()>);
-    rule!(toMap<()>);
 
     rule!(application_expression<ParsedExpr>; children!(
         [first_application_expression(e)] => e,
@@ -951,6 +954,9 @@ make_parser! {
         [merge(()), import_expression(x), import_expression(y)] => {
             spanned(span, Merge(x, y, None))
         },
+        [toMap(()), import_expression(x)] => {
+            spanned(span, ToMap(x, None))
+        },
         [import_expression(e)] => e,
     ));
 
diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs
index 276590e..8571d11 100644
--- a/dhall_syntax/src/printer.rs
+++ b/dhall_syntax/src/printer.rs
@@ -41,6 +41,12 @@ impl<SE: Display + Clone, E: Display> Display for ExprF<SE, E> {
                     write!(f, " : {}", c)?;
                 }
             }
+            ToMap(a, b) => {
+                write!(f, "toMap {}", a)?;
+                if let Some(b) = b {
+                    write!(f, " : {}", b)?;
+                }
+            }
             Annot(a, b) => {
                 write!(f, "{} : {}", a, b)?;
             }
@@ -144,6 +150,7 @@ impl<A: Display + Clone> RawExpr<A> {
             | NEListLit(_)
             | SomeLit(_)
             | Merge(_, _, _)
+            | ToMap(_, _)
             | Annot(_, _)
                 if phase > Base =>
             {
@@ -172,6 +179,10 @@ impl<A: Display + Clone> RawExpr<A> {
                 b.phase(PrintPhase::Import),
                 c.map(|x| x.phase(PrintPhase::App)),
             ),
+            ToMap(a, b) => ToMap(
+                a.phase(PrintPhase::Import),
+                b.map(|x| x.phase(PrintPhase::App)),
+            ),
             Annot(a, b) => Annot(a.phase(Operator), b),
             ExprF::BinOp(op, a, b) => ExprF::BinOp(
                 op,
-- 
cgit v1.2.3


From befc4cda44a4f1e26aa0a301dfc92b455cbcbf18 Mon Sep 17 00:00:00 2001
From: Nadrieril
Date: Sat, 31 Aug 2019 22:37:48 +0200
Subject: Don't URL-decode path segments

---
 dhall_syntax/src/parser.rs  | 27 ++++++++++++++++++++++-----
 dhall_syntax/src/printer.rs | 22 +++++-----------------
 2 files changed, 27 insertions(+), 22 deletions(-)

(limited to 'dhall_syntax/src')

diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index 24ecc1e..53fd68a 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -669,12 +669,29 @@ make_parser! {
     rule!(unquoted_path_component<&'a str>; captured_str!(s) => s);
     rule!(quoted_path_component<&'a str>; captured_str!(s) => s);
     rule!(path_component<String>; children!(
-        [unquoted_path_component(s)] => {
-            percent_encoding::percent_decode(s.as_bytes())
-                .decode_utf8_lossy()
-                .into_owned()
+        [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()
         },
-        [quoted_path_component(s)] => s.to_string(),
     ));
     rule!(path<Vec<String>>; children!(
         [path_component(components)..] => {
diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs
index 8571d11..f3dc648 100644
--- a/dhall_syntax/src/printer.rs
+++ b/dhall_syntax/src/printer.rs
@@ -360,15 +360,9 @@ impl<SubExpr: Display> Display for Import<SubExpr> {
         use FilePrefix::*;
         use ImportLocation::*;
         use ImportMode::*;
-        let fmt_remote_path_component = |s: &str| -> String {
-            use percent_encoding::{
-                utf8_percent_encode, PATH_SEGMENT_ENCODE_SET,
-            };
-            utf8_percent_encode(s, PATH_SEGMENT_ENCODE_SET).to_string()
-        };
-        let fmt_local_path_component = |s: &str| -> String {
+        let quote_if_needed = |s: &str| -> String {
             if s.chars().all(|c| c.is_ascii_alphanumeric()) {
-                s.to_owned()
+                s.to_string()
             } else {
                 format!("\"{}\"", s)
             }
@@ -383,19 +377,13 @@ impl<SubExpr: Display> Display for Import<SubExpr> {
                     Absolute => "",
                 };
                 write!(f, "{}/", prefix)?;
-                let path: String = path
-                    .iter()
-                    .map(|c| fmt_local_path_component(c.as_ref()))
-                    .join("/");
+                let path: String =
+                    path.iter().map(|c| quote_if_needed(&*c)).join("/");
                 f.write_str(&path)?;
             }
             Remote(url) => {
                 write!(f, "{}://{}/", url.scheme, url.authority,)?;
-                let path: String = url
-                    .path
-                    .iter()
-                    .map(|c| fmt_remote_path_component(c.as_ref()))
-                    .join("/");
+                let path: String = url.path.iter().join("/");
                 f.write_str(&path)?;
                 if let Some(q) = &url.query {
                     write!(f, "?{}", q)?
-- 
cgit v1.2.3