Remove debug implementations in favor of PrettyPrint

Author: lazear

crates/sml-core/src/elaborate.rs

@@ -938,7 +938,7 @@ impl<'ar> Context<'ar> {
                     _ => {
                         self.diags.push(Diagnostic::error(
                             pat.span,
-                            format!("Non-constructor {:?} applied to pattern {:?}", con, p),
+                            format!("Non-constructor applied to pattern"),
                         ));
                         Pat::new(
                             self.arena.pats.wild(),

crates/sml-core/src/lib.rs

@@ -75,7 +75,7 @@ pub struct Pat<'ar> {
     pub span: Span,
 }
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone)]
 pub struct Rule<'ar> {
     pub pat: Pat<'ar>,
     pub expr: Expr<'ar>,
@@ -184,136 +184,3 @@ impl<T> std::ops::Deref for SortedRecord<T> {
         &self.rows
     }
 }
-
-impl<T: fmt::Debug> fmt::Debug for SortedRecord<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "{{ {} }}",
-            self.rows
-                .iter()
-                .map(|r| format!("{:?}={:?}", r.label, r.data))
-                .collect::<Vec<String>>()
-                .join(",")
-        )
-    }
-}
-
-impl<'ar> fmt::Debug for ExprKind<'ar> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use ExprKind::*;
-        match self {
-            App(e1, e2) => write!(f, "{:?} {:?}", e1, e2),
-            Case(casee, rules) => write!(
-                f,
-                "(case {:?} of\n{})",
-                casee,
-                rules
-                    .into_iter()
-                    .map(|r| format!("| {:?} => {:?}\n", r.pat.pat, r.expr))
-                    .collect::<String>()
-            ),
-            Con(con, tys) => write!(f, "{:?} [{:?}]", con, tys),
-            Const(c) => write!(f, "{:?}", c),
-            Handle(tryy, sym, handler) => write!(f, "{:?} handle {:?}", tryy, handler),
-            Lambda(lam) => write!(f, "{:?}", lam),
-            Let(decls, body) => write!(f, "let {:?} in {:?} end", decls, body),
-            List(exprs) => write!(f, "{:?}", exprs),
-            Primitive(sym) => write!(f, "primitive {:?}", sym),
-            Raise(e) => write!(f, "raise {:?}", e),
-            Record(rows) => write!(
-                f,
-                "{{ {} }}",
-                rows.iter()
-                    .map(|r| format!("{:?}={:?}", r.label, r.data))
-                    .collect::<Vec<String>>()
-                    .join(",")
-            ),
-            Seq(exprs) => write!(f, "{:?}", exprs),
-            Var(s) => write!(f, "{:?}", s),
-        }
-    }
-}
-
-impl<'ar> fmt::Debug for PatKind<'ar> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use PatKind::*;
-        match self {
-            App(e1, Some(e2)) => write!(f, "{:?} {:?}", e1.name, e2),
-            App(e1, None) => write!(f, "{:?}", e1.name),
-            // Con(con, tys) => write!(f, "{:?} [{:?}]", con, tys),
-            Const(c) => write!(f, "{:?}", c),
-            Record(rows) => write!(
-                f,
-                "{{ {} }}",
-                rows.iter()
-                    .map(|r| format!("{:?}={:?}", r.label, r.data))
-                    .collect::<Vec<String>>()
-                    .join(",")
-            ),
-            // List(exprs) => write!(f, "{:?}", exprs),
-            Var(s) => write!(f, "{:?}", s),
-            Wild => write!(f, "_"),
-        }
-    }
-}
-
-impl<'ar> fmt::Debug for Expr<'ar> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self.expr)
-    }
-}
-
-impl<'ar> fmt::Debug for Pat<'ar> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self.pat)
-    }
-}
-
-impl<'ar> fmt::Debug for Lambda<'ar> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "fn ({:?} : {:?}) => {:?}", self.arg, self.ty, self.body)
-    }
-}
-
-impl<'ar> fmt::Debug for Decl<'ar> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Decl::Val(rule) => write!(f, "val {:?} = {:?}", rule.pat, rule.expr),
-            Decl::Fun(_, binds) => {
-                let s = binds
-                    .iter()
-                    .map(|(n, l)| format!("val {:?} = {:?}", n, l))
-                    .collect::<Vec<String>>()
-                    .join(";\n");
-                writeln!(f, "{}", s)
-            }
-            Decl::Datatype(dt) => {
-                let vars = dt
-                    .tyvars
-                    .iter()
-                    .map(|u| types::fresh_name(*u))
-                    .collect::<Vec<String>>()
-                    .join(",");
-                let cons = dt
-                    .constructors
-                    .iter()
-                    .map(|(con, ty)| match ty {
-                        Some(ty) => format!("{:?} of {:?}", con.name, ty),
-                        None => format!("{:?}", con.name),
-                    })
-                    .collect::<Vec<String>>()
-                    .join(" | ");
-                match dt.tyvars.len() {
-                    0 => writeln!(f, "datatype {:?} = {}", dt.tycon.name, cons),
-                    1 => writeln!(f, "datatype {} {:?} = {}", vars, dt.tycon.name, cons),
-                    _ => writeln!(f, "datatype ({}) {:?} = {}", vars, dt.tycon.name, cons),
-                }
-            }
-            Decl::Exn(con, ty) => match ty {
-                Some(ty) => writeln!(f, "exception {:?} of {:?}", con.name, ty),
-                None => writeln!(f, "exception {:?}", con.name),
-            },
-        }
-    }
-}

crates/sml-core/src/match_compile.rs

@@ -164,13 +164,13 @@ fn preflight<'a>(ctx: &Context<'a>, rules: Vec<Rule<'a>>) -> (Vec<Decl<'a>>, Vec
     (decls, finished)
 }
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub enum Fact {
     Con(Constructor, Option<Symbol>),
     Record(SortedRecord<Symbol>),
 }
 
-#[derive(Default, Debug, Clone)]
+#[derive(Default, Clone)]
 pub struct Facts {
     v: Vec<(Symbol, Fact)>,
 }
@@ -194,22 +194,22 @@ impl Facts {
             match pat.pat {
                 PatKind::Var(x) => {
                     if let Some(_) = map.insert(*x, (*var, pat.ty)) {
-                        panic!("Bug: Facts.bind rebinding of {:?} => {:?}", var, x)
+                        panic!("Bug: Facts.bind rebinding")
                     }
                 }
                 PatKind::App(_, Some(pat)) => match facts.get(var) {
                     Some(Fact::Con(_, Some(x))) => {
                         queue.push_back((x, pat));
                     }
-                    x => panic!("Bug: Facts.bind constructor {:?} {:?}", var, x),
+                    x => panic!("Bug: Facts.bind constructor"),
                 },
                 PatKind::Record(rp) => match facts.get(var) {
                     Some(Fact::Record(rx)) => {
                         for (rp, rx) in rp.iter().zip(rx.iter()) {
                             queue.push_back((&rx.data, &rp.data));
                         }
                     }
-                    x => panic!("Bug: Facts.bind record {:?} {:?}", var, x),
+                    x => panic!("Bug: Facts.bind record"),
                 },
                 _ => continue,
             }
@@ -582,24 +582,6 @@ impl<'a, 'ctx> Matrix<'a, 'ctx> {
     }
 }
 
-impl fmt::Debug for Matrix<'_, '_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "matrix {:?}\n", self.vars)?;
-        for (pats, exprs) in self.pats.iter().zip(self.rules.iter()) {
-            writeln!(
-                f,
-                "{:?} => {:?}",
-                pats.iter()
-                    .map(|pat| format!("{:?}", pat))
-                    .collect::<Vec<String>>()
-                    .join(","),
-                exprs
-            )?;
-        }
-        Ok(())
-    }
-}
-
 fn collect_vars<'a>(pat: Pat<'a>) -> Vec<Var<'a>> {
     let mut v = Vec::new();
     let mut queue = VecDeque::new();