ast: Add Fold, Folder traits, reorganize visit

parser: fix precedence of `BindOp::Let`

src/ast.rs

@@ -4,6 +4,8 @@ pub mod macro_matcher;
 
 pub mod visit;
 
+pub mod fold;
+
 /// An annotation: extra data added on to important AST nodes.
 pub trait Annotation: Clone + std::fmt::Display + std::fmt::Debug + PartialEq + Eq {}
 impl<T: Clone + std::fmt::Debug + std::fmt::Display + PartialEq + Eq> Annotation for T {}
@@ -130,6 +132,7 @@ pub enum Op {
     XorSet, // Expr ^= Expr
     OrSet,  // Expr |= Expr
 }
+
 /// A qualified identifier
 ///
 /// TODO: qualify identifier

src/ast/fold.rs

@@ -0,0 +1,271 @@
+//! A folder (implementer of the [`Fold`] trait) maps ASTs to ASTs
+#![warn(clippy::all, clippy::pedantic)]
+#![allow(clippy::wildcard_imports, clippy::missing_errors_doc)]
+
+use std::mem::MaybeUninit;
+
+use super::*;
+
+/// Deconstructs an entire AST, and reconstructs it from parts.
+///
+/// Each function acts as a customization point.
+///
+/// Aside from [Annotation]s, each node in the AST implements the [`Foldable`] trait,
+/// which provides double dispatch.
+pub trait Fold<A: Annotation> {
+    type Error;
+
+    fn fold_annotation(&mut self, anno: A) -> Result<A, Self::Error> {
+        Ok(anno)
+    }
+
+    /// Consumes an [`Expr`], possibly transforms it, and produces a replacement [`Expr`]
+    fn fold_expr(&mut self, expr: Expr<A>) -> Result<Expr<A>, Self::Error> {
+        expr.children(self)
+    }
+
+    /// Consumes a Symbol, possibly transforms it, and produces a replacement Symbol
+    fn fold_ident(&mut self, name: String) -> Result<String, Self::Error> {
+        name.children(self) // TODO: ^ this should be a symbol
+    }
+
+    /// Consumes a [`Path`], possibly transforms it, and produces a replacement [`Path`]
+    fn fold_path(&mut self, path: Path) -> Result<Path, Self::Error> {
+        path.children(self)
+    }
+
+    /// Consumes a [`Literal`], possibly transforms it, and produces a replacement [`Literal`]
+    fn fold_literal(&mut self, lit: Literal) -> Result<Literal, Self::Error> {
+        lit.children(self)
+    }
+
+    /// Consumes a [`Use`], possibly transforms it, and produces a replacement [`Use`]
+    fn fold_use(&mut self, item: Use) -> Result<Use, Self::Error> {
+        item.children(self)
+    }
+
+    /// Consumes a [`Pat`], possibly transforms it, and produces a replacement [`Pat`]
+    fn fold_pat(&mut self, pat: Pat) -> Result<Pat, Self::Error> {
+        pat.children(self)
+    }
+
+    /// Consumes a [`Bind`], possibly transforms it, and produces a replacement [`Bind`]
+    fn fold_bind(&mut self, bind: Bind<A>) -> Result<Bind<A>, Self::Error> {
+        bind.children(self)
+    }
+
+    /// Consumes a [`Make`], possibly transforms it, and produces a replacement [`Make`]
+    fn fold_make(&mut self, make: Make<A>) -> Result<Make<A>, Self::Error> {
+        make.children(self)
+    }
+
+    /// Consumes a [`MakeArm`], possibly transforms it, and produces a replacement [`MakeArm`]
+    fn fold_makearm(&mut self, arm: MakeArm<A>) -> Result<MakeArm<A>, Self::Error> {
+        arm.children(self)
+    }
+}
+
+pub trait Foldable<A: Annotation>: Sized {
+    /// Calls `Self`'s appropriate [Folder] function(s)
+    fn fold_in<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error>;
+
+    /// Destructures `self`, calling [`Foldable::fold_in`] on all foldable members,
+    /// and rebuilds a `Self` out of the results.
+    #[allow(unused_variables)]
+    fn children<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        Ok(self)
+    }
+}
+
+impl<A: Annotation> Foldable<A> for Expr<A> {
+    fn fold_in<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        folder.fold_expr(self)
+    }
+
+    fn children<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        Ok(match self {
+            Self::Omitted => Self::Omitted,
+            Self::Id(path) => Self::Id(path.fold_in(folder)?),
+            Self::MetId(id) => Self::MetId(id.fold_in(folder)?),
+            Self::Lit(literal) => Self::Lit(literal.fold_in(folder)?),
+            Self::Use(item) => Self::Use(item.fold_in(folder)?),
+            Self::Bind(bind) => Self::Bind(bind.fold_in(folder)?),
+            Self::Make(make) => Self::Make(make.fold_in(folder)?),
+            Self::Op(op, annos) => Self::Op(op, annos.fold_in(folder)?),
+        })
+    }
+}
+
+impl<A: Annotation> Foldable<A> for String {
+    fn fold_in<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        folder.fold_ident(self)
+    }
+}
+
+impl<A: Annotation> Foldable<A> for Path {
+    fn fold_in<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        folder.fold_path(self)
+    }
+
+    fn children<F: Fold<A> + ?Sized>(self, _folder: &mut F) -> Result<Self, F::Error> {
+        Ok(self)
+    }
+}
+
+impl<A: Annotation> Foldable<A> for Literal {
+    fn fold_in<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        folder.fold_literal(self)
+    }
+
+    fn children<F: Fold<A> + ?Sized>(self, _folder: &mut F) -> Result<Self, F::Error> {
+        Ok(self)
+    }
+}
+
+impl<A: Annotation> Foldable<A> for Use {
+    fn fold_in<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        folder.fold_use(self)
+    }
+
+    fn children<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        Ok(match self {
+            Self::Glob => Self::Glob,
+            Self::Name(name) => Self::Name(name),
+            Self::Path(name, rest) => Self::Path(name, rest.fold_in(folder)?),
+            Self::Tree(items) => Self::Tree(items.fold_in(folder)?),
+        })
+    }
+}
+
+impl<A: Annotation> Foldable<A> for Pat {
+    fn fold_in<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        folder.fold_pat(self)
+    }
+
+    fn children<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        Ok(match self {
+            Self::Ignore => Self::Ignore,
+            Self::Never => Self::Never,
+            Self::MetId(name) => Self::MetId(name.fold_in(folder)?),
+            Self::Name(name) => Self::Name(name.fold_in(folder)?),
+            Self::Path(path) => Self::Path(path.fold_in(folder)?),
+            Self::NamedStruct(path, pat) => {
+                Self::NamedStruct(path.fold_in(folder)?, pat.fold_in(folder)?)
+            }
+            Self::NamedTuple(path, pat) => {
+                Self::NamedTuple(path.fold_in(folder)?, pat.fold_in(folder)?)
+            }
+            Self::Lit(literal) => Self::Lit(literal.fold_in(folder)?),
+            Self::Op(op, pats) => Self::Op(op, pats.fold_in(folder)?),
+        })
+    }
+}
+
+impl<A: Annotation> Foldable<A> for Bind<A> {
+    fn fold_in<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        folder.fold_bind(self)
+    }
+
+    fn children<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        let Self(op, gens, pat, exprs) = self;
+        Ok(Self(
+            op,
+            gens.fold_in(folder)?,
+            pat.fold_in(folder)?,
+            exprs.fold_in(folder)?,
+        ))
+    }
+}
+
+impl<A: Annotation> Foldable<A> for Make<A> {
+    fn fold_in<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        folder.fold_make(self)
+    }
+
+    fn children<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        let Self(expr, arms) = self;
+        Ok(Self(expr.fold_in(folder)?, arms.fold_in(folder)?))
+    }
+}
+
+impl<A: Annotation> Foldable<A> for MakeArm<A> {
+    fn fold_in<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        folder.fold_makearm(self)
+    }
+
+    fn children<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        let Self(name, expr) = self;
+        Ok(Self(name, expr.fold_in(folder)?))
+    }
+}
+
+impl<T: Annotation + Foldable<A>, A: Annotation> Foldable<A> for Anno<T, A> {
+    fn fold_in<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        let Self(expr, anno) = self;
+        let anno = folder.fold_annotation(anno)?;
+        Ok(Self(expr.fold_in(folder)?, anno))
+    }
+
+    fn children<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        let Self(expr, anno) = self;
+        Ok(Self(expr.children(folder)?, anno))
+    }
+}
+
+//////////////////////////////////////////////
+//  GENERIC IMPLEMENTATIONS ON COLLECTIONS  //
+//////////////////////////////////////////////
+
+/// Maps the value in the box across `f()` without deallocating
+fn box_try_map<T, E>(boxed: Box<T>, f: impl FnOnce(T) -> Result<T, E>) -> Result<Box<T>, E> {
+    // TODO: replace with Box::take when it stabilizes.
+    let rawbox = Box::into_raw(boxed);
+
+    // Safety: `rawbox` came from a Box, so it is aligned and initialized.
+    //     To prevent further reuse and deallocate on failure, rawbox is
+    //     shadowed by a Box<MaybeUninit<T>>.
+    // Safety: MaybeUninit<T> has the same size and alignment as T.
+    let (value, rawbox) = (unsafe { rawbox.read() }, unsafe {
+        Box::from_raw(rawbox.cast::<MaybeUninit<T>>())
+    });
+
+    // rawbox is reinitialized with f(value)
+    Ok(Box::write(rawbox, f(value)?))
+}
+
+impl<T: Foldable<A>, A: Annotation> Foldable<A> for Box<T> {
+    fn fold_in<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        box_try_map(self, |t| t.fold_in(folder))
+    }
+
+    fn children<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        box_try_map(self, |t| t.children(folder))
+    }
+}
+
+impl<T: Foldable<A>, A: Annotation> Foldable<A> for Vec<T> {
+    fn fold_in<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        self.into_iter().map(|e| e.fold_in(folder)).collect()
+    }
+
+    fn children<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        // TODO: is this correct for generic data structures?
+        self.into_iter().map(|e| e.fold_in(folder)).collect()
+    }
+}
+
+impl<T: Foldable<A>, A: Annotation> Foldable<A> for Option<T> {
+    fn fold_in<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        Ok(match self {
+            Self::Some(value) => Some(value.fold_in(folder)?),
+            Self::None => None,
+        })
+    }
+
+    fn children<F: Fold<A> + ?Sized>(self, folder: &mut F) -> Result<Self, F::Error> {
+        Ok(match self {
+            Self::Some(value) => Some(value.children(folder)?),
+            Self::None => None,
+        })
+    }
+}

src/ast/visit.rs

@@ -9,6 +9,9 @@ pub trait Visit<'a> {
     fn visit(&mut self, walk: &'a impl Walk<'a>) -> Result<(), Self::Error> {
         walk.visit_in(self)
     }
+    fn visit_expr<A: Annotation>(&mut self, expr: &'a Expr<A>) -> Result<(), Self::Error> {
+        expr.children(self)
+    }
     fn visit_ident(&mut self, name: &'a str) -> Result<(), Self::Error> {
         name.children(self)
     }
@@ -33,9 +36,6 @@ pub trait Visit<'a> {
     fn visit_makearm<A: Annotation>(&mut self, item: &'a MakeArm<A>) -> Result<(), Self::Error> {
         item.children(self)
     }
-    fn visit_expr<A: Annotation>(&mut self, expr: &'a Expr<A>) -> Result<(), Self::Error> {
-        expr.children(self)
-    }
 }
 
 pub trait Walk<'a> {
@@ -46,6 +46,26 @@ pub trait Walk<'a> {
     fn visit_in<V: Visit<'a> + ?Sized>(&'a self, v: &mut V) -> Result<(), V::Error>;
 }
 
+impl<'a, A: Annotation> Walk<'a> for Expr<A> {
+    fn children<V: Visit<'a> + ?Sized>(&'a self, v: &mut V) -> Result<(), V::Error> {
+        match self {
+            Self::Omitted => Ok(()),
+            Self::Id(path) => path.visit_in(v),
+            Self::MetId(id) => id.visit_in(v),
+            Self::Lit(literal) => literal.visit_in(v),
+            Self::Use(u) => u.visit_in(v),
+            Self::Bind(bind) => bind.visit_in(v),
+            Self::Make(make) => make.visit_in(v),
+            Self::Op(_op, annos) => annos.visit_in(v),
+        }
+    }
+
+    #[inline]
+    fn visit_in<V: Visit<'a> + ?Sized>(&'a self, v: &mut V) -> Result<(), V::Error> {
+        v.visit_expr(self)
+    }
+}
+
 impl<'a> Walk<'a> for str {
     fn visit_in<V: Visit<'a> + ?Sized>(&'a self, v: &mut V) -> Result<(), V::Error> {
         v.visit_ident(self)
@@ -145,26 +165,6 @@ impl<'a, A: Annotation> Walk<'a> for MakeArm<A> {
     }
 }
 
-impl<'a, A: Annotation> Walk<'a> for Expr<A> {
-    fn children<V: Visit<'a> + ?Sized>(&'a self, v: &mut V) -> Result<(), V::Error> {
-        match self {
-            Self::Omitted => Ok(()),
-            Self::Id(path) => path.visit_in(v),
-            Self::MetId(id) => id.visit_in(v),
-            Self::Lit(literal) => literal.visit_in(v),
-            Self::Use(u) => u.visit_in(v),
-            Self::Bind(bind) => bind.visit_in(v),
-            Self::Make(make) => make.visit_in(v),
-            Self::Op(_op, annos) => annos.visit_in(v),
-        }
-    }
-
-    #[inline]
-    fn visit_in<V: Visit<'a> + ?Sized>(&'a self, v: &mut V) -> Result<(), V::Error> {
-        v.visit_expr(self)
-    }
-}
-
 impl<'a, T: Annotation + Walk<'a>, A: Annotation> Walk<'a> for Anno<T, A> {
     #[inline]
     fn children<V: Visit<'a> + ?Sized>(&'a self, v: &mut V) -> Result<(), V::Error> {

src/parser/expr.rs

@@ -507,7 +507,7 @@ fn parse_for(p: &mut Parser<'_>, _level: ()) -> PResult<Expr> {
 fn from_bind(p: &mut Parser<'_>) -> PResult<(BindOp, PPrec, Option<TKind>, Option<Prec>, Option<Prec>)> {
     let bk = match p.peek()?.kind {
         // Token            Operator        Pat prec      Body Token             Body prec            Else prec
-        TKind::Let =>    (BindOp::Let,    PPrec::Tuple, Some(TKind::Eq),       Some(Prec::Compare), Some(Prec::Body)),
+        TKind::Let =>    (BindOp::Let,    PPrec::Tuple, Some(TKind::Eq),       Some(Prec::Tuple), Some(Prec::Body)),
         TKind::Const =>  (BindOp::Const,  PPrec::Tuple, Some(TKind::Eq),       Some(Prec::Assign),  None),
         TKind::Static => (BindOp::Static, PPrec::Tuple, Some(TKind::Eq),       Some(Prec::Assign),  None),
         TKind::Type =>   (BindOp::Type,   PPrec::Tuple, Some(TKind::Eq),       Some(Prec::Project), None),