REFACTOR: Remove the err field, rename indent -> indent_size

src/ast/printer/mod.rs

@@ -23,13 +23,12 @@ pub struct AstPrinter<'a, W>
 where
     W: Write,
 {
-    indent: usize,
+    indent_size: usize,
     curr_indent: usize,
     w: W,
     // Indexed by line that the comment was on.
     // We use this to determine when to print a comment in our AstPrinter
     comment_map: Option<&'a CommentMap>,
-    pub err: Option<std::io::Error>,
 }
 
 // TODO(jwall): At some point we probably want to be more aware of line length
@@ -40,11 +39,10 @@ where
 {
     pub fn new(indent: usize, w: W) -> Self {
         AstPrinter {
-            indent: indent,
+            indent_size: indent,
             curr_indent: 0,
             comment_map: None,
             w: w,
-            err: None,
         }
     }
 
@@ -81,7 +79,7 @@ where
 
     fn render_list_def(&mut self, def: &ListDef) -> std::io::Result<()> {
         write!(self.w, "[")?;
-        self.curr_indent += self.indent;
+        self.curr_indent += self.indent_size;
         let indent = self.make_indent();
         let has_fields = def.elems.len() > 0;
         if has_fields {
@@ -92,7 +90,7 @@ where
             self.render_expr(e)?;
             write!(self.w, ",\n")?;
         }
-        self.curr_indent -= self.indent;
+        self.curr_indent -= self.indent_size;
         if has_fields {
             write!(self.w, "{}", self.make_indent())?;
         }
@@ -103,7 +101,7 @@ where
     fn render_tuple_def(&mut self, def: &Vec<(Token, Expression)>) -> std::io::Result<()> {
         self.w.write(&['{' as u8])?;
         // If the field list is just 1 we might be able to collapse the tuple.
-        self.curr_indent += self.indent;
+        self.curr_indent += self.indent_size;
         let indent = self.make_indent();
         let has_fields = def.len() > 0;
         if has_fields {
@@ -120,7 +118,7 @@ where
             write!(&mut self.w, ",")?;
             write!(self.w, "\n")?;
         }
-        self.curr_indent -= self.indent;
+        self.curr_indent -= self.indent_size;
         if has_fields {
             write!(self.w, "{}", self.make_indent())?;
         }
@@ -187,7 +185,7 @@ where
             Expression::Call(_def) => {
                 self.render_value(&_def.funcref)?;
                 self.w.write("(".as_bytes())?;
-                self.curr_indent += self.indent;
+                self.curr_indent += self.indent_size;
                 let indent = self.make_indent();
                 let has_args = _def.arglist.len() > 1;
                 if has_args {
@@ -202,7 +200,7 @@ where
                         self.w.write(",\n".as_bytes())?;
                     }
                 }
-                self.curr_indent -= self.indent;
+                self.curr_indent -= self.indent_size;
                 if has_args {
                     write!(self.w, "{}", self.make_indent())?;
                 }
@@ -229,7 +227,7 @@ where
                     }
                     FormatArgs::List(ref es) => {
                         self.w.write("(\n".as_bytes())?;
-                        self.curr_indent += self.indent;
+                        self.curr_indent += self.indent_size;
                         let indent = self.make_indent();
                         let mut prefix = "";
                         for e in es.iter() {
@@ -237,7 +235,7 @@ where
                             self.render_expr(e)?;
                             prefix = ",\n";
                         }
-                        self.curr_indent -= self.indent;
+                        self.curr_indent -= self.indent_size;
                         self.w.write(")".as_bytes())?;
                     }
                 }
@@ -311,13 +309,13 @@ where
                     write!(self.w, ") ")?;
                 }
                 write!(self.w, "{{\n")?;
-                self.curr_indent += self.indent;
+                self.curr_indent += self.indent_size;
                 let indent = self.make_indent();
                 for stmt in _def.statements.iter() {
                     write!(self.w, "{}", indent)?;
                     self.render_stmt(stmt)?;
                 }
-                self.curr_indent -= self.indent;
+                self.curr_indent -= self.indent_size;
                 write!(self.w, "}}")?;
             }
             Expression::Not(_def) => {
@@ -360,30 +358,25 @@ where
             }
             Statement::Expression(_expr) => {
                 self.render_expr(&_expr)?;
-                //
             }
             Statement::Assert(def) => {
                 write!(&mut self.w, "assert ")?;
                 self.render_expr(&def)?;
-                //
             }
             Statement::Output(_, _tok, _expr) => {
                 write!(&mut self.w, "out {} ", _tok.fragment)?;
                 self.render_expr(&_expr)?;
-                //
             }
         };
         write!(self.w, ";\n")?;
         Ok(())
     }
 
-    pub fn render(&mut self, stmts: &Vec<Statement>) {
+    pub fn render(&mut self, stmts: &Vec<Statement>) -> std::io::Result<()> {
         for v in stmts {
-            if let Err(e) = self.render_stmt(v) {
+            self.render_stmt(v)?;
-                self.err = Some(e);
-                return;
-            }
         }
+        Ok(())
     }
 }
 

src/ast/printer/test.rs

@@ -26,8 +26,7 @@ fn test_simple_value_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(0, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -37,8 +36,7 @@ fn test_simple_selector_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(0, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -48,8 +46,7 @@ fn test_simple_quoted_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(0, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -59,8 +56,7 @@ fn test_escaped_quoted_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(0, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -70,8 +66,7 @@ fn test_empty_tuple_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -81,8 +76,7 @@ fn test_empty_list_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -92,8 +86,7 @@ fn test_non_empty_tuple_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -103,8 +96,7 @@ fn test_nested_empty_tuple_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -114,8 +106,7 @@ fn test_list_nested_empty_tuple_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -125,8 +116,7 @@ fn test_nested_non_empty_tuple_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -136,8 +126,7 @@ fn test_nested_non_empty_list_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -147,8 +136,7 @@ fn test_simple_quoted_field_tuple_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(
         String::from_utf8(buffer).unwrap(),
         format!("{}\n", "{\n  foo = {\n    bar = 1,\n  },\n};")
@@ -161,8 +149,7 @@ fn test_special_quoted_field_tuple_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -172,8 +159,7 @@ fn test_let_statement_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -183,8 +169,7 @@ fn test_call_expr_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -194,8 +179,7 @@ fn test_call_expr_one_arg_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -205,8 +189,7 @@ fn test_copy_expr_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -216,8 +199,7 @@ fn test_copy_expr_one_arg_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -227,8 +209,7 @@ fn test_out_expr_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -238,8 +219,7 @@ fn test_select_expr_no_default_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -249,8 +229,7 @@ fn test_select_expr_with_default_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -260,8 +239,7 @@ fn test_not_expr_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -271,8 +249,7 @@ fn test_fail_expr_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -282,8 +259,7 @@ fn test_trace_expr_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -303,8 +279,7 @@ fn test_module_no_out_expr_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -324,8 +299,7 @@ fn test_module_with_out_expr_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -338,8 +312,7 @@ fn test_func_expr_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -351,8 +324,7 @@ fn test_func_expr_single_arg_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -364,8 +336,7 @@ fn test_format_expr_single_arg_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }
 
@@ -377,7 +348,6 @@ fn test_format_expr_list_arg_printing() {
     let stmts = assert_parse(input, None);
     let mut buffer: Vec<u8> = Vec::new();
     let mut printer = AstPrinter::new(2, &mut buffer);
-    printer.render(&stmts);
+    assert!(printer.render(&stmts).is_ok());
-    assert!(printer.err.is_none());
     assert_eq!(String::from_utf8(buffer).unwrap(), format!("{}\n", input));
 }