Clean up some of the SubExpr type-changing methods

6 files changed, 27 insertions, 119 deletions

diff --git a/dhall/src/core/thunk.rs b/dhall/src/core/thunk.rs
index 8775ce2..69c4347 100644
--- a/dhall/src/core/thunk.rs
+++ b/dhall/src/core/thunk.rs
@@ -126,7 +126,7 @@ impl Thunk {
     }
 
     pub(crate) fn from_normalized_expr(e: OutputSubExpr) -> Thunk {
-        Thunk::new(NormalizationContext::new(), e.embed_absurd().note_absurd())
+        Thunk::new(NormalizationContext::new(), e.absurd())
     }
 
     // Normalizes contents to normal form; faster than `normalize_nf` if
@@ -253,7 +253,7 @@ impl TypeThunk {
             TypeThunk::Type(t) => Ok(t.clone()),
             TypeThunk::Thunk(th) => {
                 // TODO: rule out statically
-                mktype(ctx, th.normalize_to_expr().embed_absurd().note_absurd())
+                mktype(ctx, th.normalize_to_expr().absurd())
             }
         }
     }
diff --git a/dhall/src/phase/parse.rs b/dhall/src/phase/parse.rs
index 809faf4..6b426af 100644
--- a/dhall/src/phase/parse.rs
+++ b/dhall/src/phase/parse.rs
@@ -13,7 +13,7 @@ pub(crate) fn parse_file(f: &Path) -> Result<Parsed, Error> {
     File::open(f)?.read_to_string(&mut buffer)?;
     let expr = parse_expr(&*buffer)?;
     let root = ImportRoot::LocalDir(f.parent().unwrap().to_owned());
-    Ok(Parsed(expr.unnote().note_absurd(), root))
+    Ok(Parsed(expr, root))
 }
 
 pub(crate) fn parse_str(s: &str) -> Result<Parsed, Error> {
diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs
index 3e6986f..32c1531 100644
--- a/dhall/src/phase/typecheck.rs
+++ b/dhall/src/phase/typecheck.rs
@@ -230,7 +230,7 @@ pub(crate) fn type_of_const(c: Const) -> Result<Type, TypeError> {
     }
 }
 
-fn type_of_builtin<E>(b: Builtin) -> Expr<X, E> {
+fn type_of_builtin(b: Builtin) -> Expr<X, X> {
     use dhall_syntax::Builtin::*;
     match b {
         Bool | Natural | Integer | Double | Text => dhall::expr!(Type),
@@ -635,7 +635,7 @@ fn type_last_layer(
         }
         Const(c) => Ok(RetTyped(Typed::from_const(c))),
         Builtin(b) => {
-            Ok(RetType(mktype(ctx, rc(type_of_builtin(b)).note_absurd())?))
+            Ok(RetType(mktype(ctx, rc(type_of_builtin(b)).absurd())?))
         }
         BoolLit(_) => Ok(RetType(builtin_to_type(Bool)?)),
         NaturalLit(_) => Ok(RetType(builtin_to_type(Natural)?)),
@@ -712,7 +712,7 @@ pub(crate) fn typecheck_with(
     ty: &Type,
 ) -> Result<Typed, TypeError> {
     let expr: SubExpr<_, _> = e.0;
-    let ty: SubExpr<_, _> = ty.to_expr().embed_absurd().note_absurd();
+    let ty: SubExpr<_, _> = ty.to_expr().absurd();
     type_of(expr.rewrap(ExprF::Annot(expr.clone(), ty)))
 }
 pub(crate) fn skip_typecheck(e: Resolved) -> Typed {
diff --git a/dhall_proc_macros/src/quote.rs b/dhall_proc_macros/src/quote.rs
index eaf4946..77ed5de 100644
--- a/dhall_proc_macros/src/quote.rs
+++ b/dhall_proc_macros/src/quote.rs
@@ -7,7 +7,7 @@ use std::collections::BTreeMap;
 
 pub fn expr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input_str = input.to_string();
-    let expr: SubExpr<_, Import> = parse_expr(&input_str).unwrap().unnote();
+    let expr: SubExpr<_, Import> = parse_expr(&input_str).unwrap();
     let no_import =
         |_: &Import| -> X { panic!("Don't use import in dhall::expr!()") };
     let expr = expr.map_embed(no_import);
@@ -17,7 +17,7 @@ pub fn expr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
 
 pub fn subexpr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input_str = input.to_string();
-    let expr: SubExpr<_, Import> = parse_expr(&input_str).unwrap().unnote();
+    let expr: SubExpr<_, Import> = parse_expr(&input_str).unwrap();
     let no_import =
         |_: &Import| -> X { panic!("Don't use import in dhall::subexpr!()") };
     let expr = expr.map_embed(no_import);
@@ -94,8 +94,8 @@ where
 
 // Returns an expression of type SubExpr<_, _>. Expects interpolated variables
 // to be of type SubExpr<_, _>.
-fn quote_subexpr(
-    expr: &SubExpr<X, X>,
+fn quote_subexpr<N>(
+    expr: &SubExpr<N, X>,
     ctx: &Context<Label, ()>,
 ) -> TokenStream {
     use dhall_syntax::ExprF::*;
@@ -131,7 +131,7 @@ fn quote_subexpr(
 
 // Returns an expression of type Expr<_, _>. Expects interpolated variables
 // to be of type SubExpr<_, _>.
-fn quote_expr(expr: &Expr<X, X>, ctx: &Context<Label, ()>) -> TokenStream {
+fn quote_expr<N>(expr: &Expr<N, X>, ctx: &Context<Label, ()>) -> TokenStream {
     use dhall_syntax::ExprF::*;
     match expr.map_ref_with_special_handling_of_binders(
         |e| quote_subexpr(e, ctx),
diff --git a/dhall_syntax/src/core.rs b/dhall_syntax/src/core.rs
index 7cdda64..2b76b9a 100644
--- a/dhall_syntax/src/core.rs
+++ b/dhall_syntax/src/core.rs
@@ -343,15 +343,11 @@ impl<N, E> Expr<N, E> {
     {
         trivial_result(self.traverse_embed(|x| Ok(map_embed(x))))
     }
+}
 
-    pub fn squash_embed<E2>(
-        &self,
-        f: impl FnMut(&E) -> SubExpr<N, E2>,
-    ) -> SubExpr<N, E2>
-    where
-        N: Clone,
-    {
-        trivial_result(self.visit(&mut visitor::SquashEmbedVisitor(f)))
+impl Expr<X, X> {
+    pub fn absurd<N, E>(&self) -> Expr<N, E> {
+        self.visit(&mut visitor::AbsurdVisitor)
     }
 }
 
@@ -361,12 +357,6 @@ impl<E: Clone> Expr<X, E> {
     }
 }
 
-impl<N: Clone> Expr<N, X> {
-    pub fn embed_absurd<E>(&self) -> Expr<N, E> {
-        self.visit(&mut visitor::EmbedAbsurdVisitor)
-    }
-}
-
 impl<N, E> SubExpr<N, E> {
     pub fn as_ref(&self) -> &Expr<N, E> {
         &self.0.as_ref().0
@@ -380,17 +370,6 @@ impl<N, E> SubExpr<N, E> {
         SubExpr(Rc::new((x, None)))
     }
 
-    pub fn unnote(&self) -> SubExpr<X, E>
-    where
-        E: Clone,
-    {
-        SubExpr::from_expr_no_note(
-            self.as_ref().visit(&mut visitor::UnNoteVisitor),
-        )
-    }
-}
-
-impl<N: Clone, E> SubExpr<N, E> {
     pub fn rewrap<E2>(&self, x: Expr<N, E2>) -> SubExpr<N, E2>
     where
         N: Clone,
@@ -422,7 +401,10 @@ impl<N: Clone, E> SubExpr<N, E> {
         &'a self,
         map_expr: impl FnMut(&'a Self) -> Self,
         map_under_binder: impl FnMut(&'a Label, &'a Self) -> Self,
-    ) -> Self {
+    ) -> Self
+    where
+        N: Clone,
+    {
         match self.as_ref() {
             ExprF::Embed(_) => SubExpr::clone(self),
             // This calls ExprF::map_ref
@@ -436,9 +418,9 @@ impl<N: Clone, E> SubExpr<N, E> {
     }
 }
 
-impl<N: Clone> SubExpr<N, X> {
-    pub fn embed_absurd<T>(&self) -> SubExpr<N, T> {
-        self.rewrap(self.as_ref().embed_absurd())
+impl SubExpr<X, X> {
+    pub fn absurd<N: Clone, T>(&self) -> SubExpr<N, T> {
+        SubExpr::from_expr_no_note(self.as_ref().absurd())
     }
 }
 
diff --git a/dhall_syntax/src/visitor.rs b/dhall_syntax/src/visitor.rs
index 7fdf217..20bfc72 100644
--- a/dhall_syntax/src/visitor.rs
+++ b/dhall_syntax/src/visitor.rs
@@ -421,78 +421,6 @@ where
     }
 }
 
-pub struct SquashEmbedVisitor<F1>(pub F1);
-
-impl<'a, 'b, N, E1, E2, F1>
-    ExprFVeryGenericVisitor<'a, SubExpr<N, E2>, SubExpr<N, E1>, Label, E1>
-    for &'b mut SquashEmbedVisitor<F1>
-where
-    N: Clone + 'a,
-    F1: FnMut(&E1) -> SubExpr<N, E2>,
-{
-    type Error = X;
-    type SE2 = SubExpr<N, E2>;
-    type L2 = Label;
-    type E2 = E2;
-
-    fn visit_subexpr(
-        &mut self,
-        subexpr: &'a SubExpr<N, E1>,
-    ) -> Result<Self::SE2, Self::Error> {
-        Ok(subexpr.as_ref().visit(&mut **self)?)
-    }
-
-    fn visit_label(
-        &mut self,
-        label: &'a Label,
-    ) -> Result<Self::L2, Self::Error> {
-        Ok(Label::clone(label))
-    }
-
-    fn visit_binder(
-        mut self,
-        label: &'a Label,
-        subexpr: &'a SubExpr<N, E1>,
-    ) -> Result<(Self::L2, Self::SE2), Self::Error> {
-        Ok((self.visit_label(label)?, self.visit_subexpr(subexpr)?))
-    }
-
-    fn visit_embed_squash(
-        self,
-        embed: &'a E1,
-    ) -> Result<SubExpr<N, E2>, Self::Error> {
-        Ok((self.0)(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::L2, Self::E2>,
-    ) -> Result<SubExpr<N, E2>, Self::Error> {
-        // TODO: don't lose note
-        Ok(SubExpr::from_expr_no_note(result))
-    }
-}
-
-pub struct UnNoteVisitor;
-
-impl<'a, 'b, N, E>
-    ExprFInFallibleVisitor<'a, SubExpr<N, E>, SubExpr<X, E>, Label, Label, E, E>
-    for &'b mut UnNoteVisitor
-where
-    E: Clone + 'a,
-{
-    fn visit_subexpr(&mut self, subexpr: &'a SubExpr<N, E>) -> SubExpr<X, E> {
-        SubExpr::from_expr_no_note(subexpr.as_ref().visit(&mut **self))
-    }
-    fn visit_embed(self, embed: &'a E) -> E {
-        E::clone(embed)
-    }
-    fn visit_label(&mut self, label: &'a Label) -> Label {
-        Label::clone(label)
-    }
-}
-
 pub struct NoteAbsurdVisitor;
 
 impl<'a, 'b, N, E>
@@ -512,16 +440,14 @@ where
     }
 }
 
-pub struct EmbedAbsurdVisitor;
+pub struct AbsurdVisitor;
 
 impl<'a, 'b, N, E>
-    ExprFInFallibleVisitor<'a, SubExpr<N, X>, SubExpr<N, E>, Label, Label, X, E>
-    for &'b mut EmbedAbsurdVisitor
-where
-    N: Clone + 'a,
+    ExprFInFallibleVisitor<'a, SubExpr<X, X>, SubExpr<N, E>, Label, Label, X, E>
+    for &'b mut AbsurdVisitor
 {
-    fn visit_subexpr(&mut self, subexpr: &'a SubExpr<N, X>) -> SubExpr<N, E> {
-        subexpr.rewrap(subexpr.as_ref().visit(&mut **self))
+    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_embed(self, embed: &'a X) -> E {
         match *embed {}