Add in better unification errors

Author: lazear

crates/sml-core/src/elaborate.rs

@@ -137,7 +137,7 @@ impl<'a> Print for Type<'a> {
 }
 
 impl<'a> Type<'a> {
-    fn print_rename<'b, 'c>(
+    pub fn print_rename<'b, 'c>(
         &self,
         pp: &'b mut PrettyPrinter<'c>,
         map: &mut HashMap<usize, String>,

crates/sml-core/src/pretty_print/core.rs

@@ -98,6 +98,47 @@ impl<'a> PrettyPrinter<'a> {
         Ok(())
     }
 
+    pub fn write_fmt<W: std::fmt::Write>(&mut self, w: &mut W) -> std::fmt::Result {
+        while let Some(cmd) = self.commands.pop_front() {
+            use Command::*;
+            match cmd {
+                Indent(w) => {
+                    self.indent += w;
+                }
+                Dedent(w) => {
+                    self.indent -= w;
+                }
+                Wrap(width) => {
+                    self.prev_max.push(self.max);
+                    self.max = width;
+                }
+                Unwrap => {
+                    // should never fail anyway
+                    self.max = self.prev_max.pop().unwrap_or(120);
+                }
+                Line => {
+                    if self.width == self.indent {
+                        continue;
+                    }
+                    let spaces = (0..self.indent).map(|_| ' ').collect::<String>();
+                    write!(w, "\n{}", spaces)?;
+                    self.width = self.indent;
+                }
+                Text(s) => {
+                    if self.width + s.len() >= self.max {
+                        let spaces = (0..self.indent).map(|_| ' ').collect::<String>();
+                        write!(w, "\n{}{}", spaces, s)?;
+                        self.width = self.indent + s.len();
+                    } else {
+                        self.width += s.len();
+                        write!(w, "{}", s)?;
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
     pub fn wrap<F>(&mut self, width: usize, f: F) -> &mut Self
     where
         for<'b> F: Fn(&'b mut PrettyPrinter<'a>) -> &'b mut PrettyPrinter<'a>,

crates/sml-core/src/pretty_print/mod.rs

@@ -75,11 +75,11 @@ impl<'a> Compiler<'a> {
         match res {
             Ok(d) => {
                 let mut check = sml_core::check::Check::default();
-                self.measure("checking", |c| check.check_decl(&d));
+                self.measure("checking", |_| check.check_decl(&d));
                 diags.extend(check.diags);
 
                 let decls = self.measure("elaboration", |c| c.elab.elaborate_decl(&d));
-                diags.extend(std::mem::replace(&mut self.elab.diags, Vec::new()));
+                diags.extend(self.elab.diagnostics(&self.interner));
 
                 match self.verbosity {
                     0 => {}

crates/sml-driver/src/main.rs

@@ -1,6 +1,14 @@
 use goldentests::{TestConfig, TestResult};
 
 #[test]
+#[cfg(target_family = "windows")]
+fn goldentests() -> TestResult<()> {
+    let config = TestConfig::new("../../target/debug/sml-driver.exe", "../../tests/", "-- ")?;
+    config.run_tests()
+}
+
+#[test]
+#[cfg(target_family = "unix")]
 fn goldentests() -> TestResult<()> {
     let config = TestConfig::new("../../target/debug/sml-driver", "../../tests/", "-- ")?;
     config.run_tests()

crates/sml-driver/tests/integration.rs

@@ -54,7 +54,7 @@ fun merge xs [] = xs
   | merge (x::xs) (y::ys) = x::y::(merge xs ys);
 
 (* example from Compiling Pattern Matching *)
-let 
+val _ = let 
   datatype u = T | F
   val x = (T, F, T) 
 in 

scratch.sml

@@ -10,7 +10,7 @@
 
 -- expected stderr:
 -- Error
--- 22,9 Can't unify type constructors interned symbol and interned symbol
+-- 22,9 Type unification: can't unify function with argument types. Type constructors differ: int, bool
 
 *)
 

tests/typecheck/cantunify.sml

@@ -2,10 +2,10 @@
 
 -- expected stderr:
 -- Error
--- 18,21 Cyclic type detected: 'i#1 interned symbol
+-- 18,21 Type unification: can't unify function with argument types. Cyclic type detected: 'a list, 'a
 -- 
 -- Error
--- 18,5 Cyclic type detected: 'i#1 interned symbol
+-- 18,5 Type unification: function clause body doesn't match with return type. Cyclic type detected: 'a, 'a list
 
 -- expected stdout:
 -- 0 warnings, 2 errors