diff --git a/src/ast/mod.rs b/src/ast/mod.rs
index 14eabf8..7002b78 100644
--- a/src/ast/mod.rs
+++ b/src/ast/mod.rs
@@ -5,7 +5,7 @@ use crate::lex::token;
 use crate::lex::token::Token;
 use crate::lex::Lexer;
 
-use crate::ast::tree::{File, Operator};
+use crate::ast::tree::{File, Node, Operator};
 use std::fs;
 use std::io;
 
@@ -25,7 +25,7 @@ struct Parser {
     filename: String,
 }
 
-pub fn parse(filename: String) -> io::Result<Result<tree::Node, Error>> {
+pub fn parse(filename: String) -> io::Result<Result<Node, Error>> {
     let raw: String = fs::read_to_string(filename.clone())?;
     let mut p = Parser::new(filename, raw);
     Ok(p.parse_file())
@@ -53,7 +53,7 @@ impl Parser {
     /// File
     ///  : Statement [ File ]
     /// ```
-    pub fn parse_file(&mut self) -> Result<tree::Node, Error> {
+    pub fn parse_file(&mut self) -> Result<Node, Error> {
         let mut nodes = Vec::new();
         self.scope.push(Scope::File);
 
@@ -62,7 +62,7 @@ impl Parser {
         }
 
         self.scope.pop();
-        Ok(tree::Node::File(
+        Ok(Node::File(
             token::Position {
                 file: self.filename.clone(),
                 line: 0,
@@ -84,7 +84,7 @@ impl Parser {
     ///  | TypeStatement
     ///  | ExpressionStatement
     /// ```
-    fn parse_stmt(&mut self) -> Result<tree::Node, Error> {
+    fn parse_stmt(&mut self) -> Result<Node, Error> {
         let token = self.lexer.peek_or_err()?;
         match token.kind {
             token::Kind::BreakKeyword => self.parse_break_stmt(),
@@ -107,11 +107,11 @@ impl Parser {
     /// BreakStatement
     ///  : "break" ";"
     /// ```
-    fn parse_break_stmt(&mut self) -> Result<tree::Node, Error> {
+    fn parse_break_stmt(&mut self) -> Result<Node, Error> {
         let break_keyword = self.lexer.expect_kind(token::Kind::BreakKeyword)?;
         self.assert_scope(Scope::Loop)?;
         self.lexer.expect_kind(token::Kind::Semi)?;
-        Ok(tree::Node::Break(break_keyword.pos))
+        Ok(Node::Break(break_keyword.pos))
     }
 
     /// ```notrust
@@ -121,7 +121,7 @@ impl Parser {
     /// StatementList
     ///  : Statement [ StatementList ]
     /// ```
-    fn parse_block_stmt(&mut self) -> Result<tree::Node, Error> {
+    fn parse_block_stmt(&mut self) -> Result<Node, Error> {
         let mut nodes = Vec::new();
         let obrace = self.lexer.expect_kind(token::Kind::OBrace)?;
         while let Some(result) = self.lexer.peek() {
@@ -133,37 +133,37 @@ impl Parser {
                 _ => nodes.push(self.parse_stmt()?),
             }
         }
-        Ok(tree::Node::Block(obrace.pos, nodes))
+        Ok(Node::Block(obrace.pos, nodes))
     }
 
     /// ```notrust
     /// ReturnStatement
     ///  : "return" Expression ";"
     /// ```
-    fn parse_return_stmt(&mut self) -> Result<tree::Node, Error> {
+    fn parse_return_stmt(&mut self) -> Result<Node, Error> {
         self.assert_scope(Scope::Function)?;
         let return_keyword = self.lexer.expect_kind(token::Kind::ReturnKeyword)?;
         let expr = self.parse_expr(&[token::Kind::Semi])?;
-        Ok(tree::Node::ReturnStmt(return_keyword.pos, Box::new(expr)))
+        Ok(Node::ReturnStmt(return_keyword.pos, Box::new(expr)))
     }
 
     /// ```notrust
     /// TargetStatement
     ///  : "target" Expression BlockStatement
     /// ```
-    fn parse_target_stmt(&mut self) -> Result<tree::Node, Error> {
+    fn parse_target_stmt(&mut self) -> Result<Node, Error> {
         self.assert_scope(Scope::File)?;
         self.assert_scope_not(Scope::Target)?;
         self.scope.push(Scope::Target);
 
         let target_keyword = self.lexer.expect_kind(token::Kind::TargetKeyword)?;
         let name_token = self.lexer.expect_kind(token::Kind::Ident)?;
-        let name = tree::Node::Ident(name_token.pos, name_token.raw);
+        let name = Node::Ident(name_token.pos, name_token.raw);
 
         let children = self.parse_block_stmt()?;
 
         self.scope.pop();
-        Ok(tree::Node::make_target_stmt(
+        Ok(Node::make_target_stmt(
             target_keyword.pos,
             name,
             children,
@@ -174,20 +174,20 @@ impl Parser {
     /// DependStatement
     ///  : "depend" Expression ";"
     /// ```
-    fn parse_depend_stmt(&mut self) -> Result<tree::Node, Error> {
+    fn parse_depend_stmt(&mut self) -> Result<Node, Error> {
         self.assert_scope(Scope::Target)?;
         self.scope.push(Scope::DepList);
         let depend_keyword = self.lexer.expect_kind(token::Kind::DependKeyword)?;
         let rvalue = self.parse_expr(&[token::Kind::Semi])?;
         self.scope.pop();
-        Ok(tree::Node::DepList(depend_keyword.pos, Box::new(rvalue)))
+        Ok(Node::DepList(depend_keyword.pos, Box::new(rvalue)))
     }
 
     /// ```notrust
     /// IfStatement
     ///  : "if" "(" Expression ")" BlockStatement [ "else" BlockStatement ]
     /// ```
-    fn parse_if_stmt(&mut self) -> Result<tree::Node, Error> {
+    fn parse_if_stmt(&mut self) -> Result<Node, Error> {
         let if_keyword = self.lexer.expect_kind(token::Kind::IfKeyword)?;
         self.lexer.expect_kind(token::Kind::OParen)?;
         let condition = self.parse_expr(&[token::Kind::CParen])?;
@@ -197,7 +197,7 @@ impl Parser {
         } else {
             None
         };
-        Ok(tree::Node::make_if_stmt(
+        Ok(Node::make_if_stmt(
             if_keyword.pos,
             condition,
             then_block,
@@ -209,14 +209,14 @@ impl Parser {
     /// WhileStatement
     ///  : "while" "(" Expression ")" BlockStatement
     /// ```
-    fn parse_while_stmt(&mut self) -> Result<tree::Node, Error> {
+    fn parse_while_stmt(&mut self) -> Result<Node, Error> {
         let while_keyword = self.lexer.expect_kind(token::Kind::WhileKeyword)?;
         self.scope.push(Scope::Loop);
         self.lexer.expect_kind(token::Kind::OParen)?;
         let condition = self.parse_expr(&[token::Kind::CParen])?;
         let body = self.parse_block_stmt()?;
         self.scope.pop();
-        Ok(tree::Node::make_while_stmt(
+        Ok(Node::make_while_stmt(
             while_keyword.pos,
             condition,
             body,
@@ -227,7 +227,7 @@ impl Parser {
     /// ForStatement
     ///  : "for" "(" [ Expression ] ";" [ Expression ] ";" [ Expression ] ")" BlockStatement
     /// ```
-    fn parse_for_stmt(&mut self) -> Result<tree::Node, Error> {
+    fn parse_for_stmt(&mut self) -> Result<Node, Error> {
         let for_keyword = self.lexer.expect_kind(token::Kind::ForKeyword)?;
         self.scope.push(Scope::Loop);
         self.lexer.expect_kind(token::Kind::OParen)?;
@@ -245,7 +245,7 @@ impl Parser {
         let exec = exprs.pop().unwrap();
         let condition = exprs.pop().unwrap();
         let setup = exprs.pop().unwrap();
-        Ok(tree::Node::make_for_stmt(
+        Ok(Node::make_for_stmt(
             for_keyword.pos,
             setup,
             condition,
@@ -258,14 +258,14 @@ impl Parser {
     /// SetStatement
     ///  : "set" AssignmentExpression ";"
     /// ```
-    fn parse_set_stmt(&mut self) -> Result<tree::Node, Error> {
+    fn parse_set_stmt(&mut self) -> Result<Node, Error> {
         self.assert_scope(Scope::File)?;
         let set_keyword = self.lexer.expect_kind(token::Kind::SetKeyword)?;
         let expr = self.parse_expr(&[token::Kind::Semi])?;
         match expr {
-            tree::Node::BinaryExpr(_, expr) => {
+            Node::BinaryExpr(_, expr) => {
                 if expr.op == Operator::Eq {
-                    Ok(tree::Node::make_set_stmt(
+                    Ok(Node::make_set_stmt(
                         set_keyword.pos,
                         *expr.lhs,
                         *expr.rhs,
@@ -285,31 +285,31 @@ impl Parser {
     /// TypeStatement
     ///  : "type" Expression ";"
     /// ```
-    fn parse_type_stmt(&mut self) -> Result<tree::Node, Error> {
+    fn parse_type_stmt(&mut self) -> Result<Node, Error> {
         let type_keyword = self.lexer.expect_kind(token::Kind::TypeKeyword)?;
         self.assert_scope(Scope::Target)?;
         let expr = self.parse_expr(&[token::Kind::Semi])?;
-        Ok(tree::Node::TypeStmt(type_keyword.pos, Box::new(expr)))
+        Ok(Node::TypeStmt(type_keyword.pos, Box::new(expr)))
     }
 
     /// ```notrust
     /// SourceStatement
     ///  : "source" Expression ";"
     /// ```
-    fn parse_source_stmt(&mut self) -> Result<tree::Node, Error> {
+    fn parse_source_stmt(&mut self) -> Result<Node, Error> {
         let source_keyword = self.lexer.expect_kind(token::Kind::SourceKeyword)?;
         self.assert_scope(Scope::Target)?;
         self.scope.push(Scope::SourceList);
         let source = self.parse_expr(&[token::Kind::Semi])?;
         self.scope.pop();
-        Ok(tree::Node::SourceList(source_keyword.pos, Box::new(source)))
+        Ok(Node::SourceList(source_keyword.pos, Box::new(source)))
     }
 
     /// ```notrust
     /// ExpressionStatement
     ///  : Expression ";"
     /// ```
-    fn parse_expr_stmt(&mut self) -> Result<tree::Node, Error> {
+    fn parse_expr_stmt(&mut self) -> Result<Node, Error> {
         self.parse_expr(&[token::Kind::Semi])
     }
 
@@ -320,7 +320,7 @@ impl Parser {
     ///  | UnaryExpression
     ///  | PrimaryExpression
     /// ```
-    fn parse_expr(&mut self, terminators: &[token::Kind]) -> Result<tree::Node, Error> {
+    fn parse_expr(&mut self, terminators: &[token::Kind]) -> Result<Node, Error> {
         self.assert_scope(Scope::File)?;
         let expr = if let Some(result) = self.lexer.peek() {
             let token = result?;
@@ -356,7 +356,7 @@ impl Parser {
     fn parse_assignment_expr_or_higher(
         &mut self,
         terminators: &[token::Kind],
-    ) -> Result<tree::Node, Error> {
+    ) -> Result<Node, Error> {
         // we speculate on this being an assignment expression, so we need to
         // be able to undo our work in case this speculation doesn't hold true
         // so parse_binary_expr_or_higher() can do its thing
@@ -368,7 +368,7 @@ impl Parser {
                 let op_token = self.lexer.require_next()?;
                 let op = Operator::from_token(&op_token)?;
                 let rhs = self.parse_binary_expr_or_higher(terminators)?;
-                return Ok(tree::Node::make_binary_expr(op_token.pos, lhs, op, rhs));
+                return Ok(Node::make_binary_expr(op_token.pos, lhs, op, rhs));
             } else if token.kind.binary_op_precedence().is_some() {
                 // shoot, this wasn't an assignment, all of our work was useless
                 self.lexer.restore(bookmark);
@@ -396,7 +396,7 @@ impl Parser {
     fn parse_binary_expr_or_higher(
         &mut self,
         terminators: &[token::Kind],
-    ) -> Result<tree::Node, Error> {
+    ) -> Result<Node, Error> {
         let mut lhs = self.parse_unary_expr_or_higher()?;
 
         while let Some(Ok(token)) = self.lexer.peek() {
@@ -408,7 +408,7 @@ impl Parser {
             let op = Operator::from_token(&token)?;
             self.lexer.next();
             let precedence = token.kind.binary_op_precedence().unwrap();
-            lhs = tree::Node::make_binary_expr(
+            lhs = Node::make_binary_expr(
                 token.pos,
                 lhs,
                 op,
@@ -443,7 +443,7 @@ impl Parser {
         &mut self,
         precedence: u32,
         terminators: &[token::Kind],
-    ) -> Result<tree::Node, Error> {
+    ) -> Result<Node, Error> {
         let mut lhs = self.parse_unary_expr_or_higher()?;
 
         while let Some(Ok(token)) = self.lexer.peek() {
@@ -451,7 +451,7 @@ impl Parser {
                 if new_precedence > precedence {
                     let op = Operator::from_token(&token)?;
                     self.lexer.next();
-                    lhs = tree::Node::make_binary_expr(
+                    lhs = Node::make_binary_expr(
                         token.pos,
                         lhs,
                         op,
@@ -475,14 +475,14 @@ impl Parser {
     /// UnaryOperator
     ///  : "!" | "-"
     /// ```
-    fn parse_unary_expr_or_higher(&mut self) -> Result<tree::Node, Error> {
+    fn parse_unary_expr_or_higher(&mut self) -> Result<Node, Error> {
         if let Some(result) = self.lexer.peek() {
             let token = result?;
             if token.kind == token::Kind::Bang || token.kind == token::Kind::Minus {
                 self.lexer.next(); // consume unary operator token
                 let op = Operator::from_token(&token)?;
                 let expr = self.parse_primary_expr()?;
-                return Ok(tree::Node::make_unary_expr(token.pos, op, expr));
+                return Ok(Node::make_unary_expr(token.pos, op, expr));
             }
         }
         self.parse_primary_expr()
@@ -513,7 +513,7 @@ impl Parser {
     /// MemberExpression
     ///  : PrimaryExpression "." PrimaryExpression
     /// ```
-    fn parse_primary_expr(&mut self) -> Result<tree::Node, Error> {
+    fn parse_primary_expr(&mut self) -> Result<Node, Error> {
         let token = self.lexer.require_next()?;
         match token.kind {
             token::Kind::OParen => {
@@ -521,7 +521,7 @@ impl Parser {
                 self.parse_primary_expr_rest(expr)
             }
             token::Kind::Ident => {
-                let ident = tree::Node::Ident(token.pos, String::from(token.raw));
+                let ident = Node::Ident(token.pos, String::from(token.raw));
                 self.parse_primary_expr_rest(ident)
             }
             token::Kind::IntLiteral => {
@@ -533,11 +533,11 @@ impl Parser {
                     _ => raw.parse(),
                 }
                 .unwrap();
-                Ok(tree::Node::Int(token.pos, num))
+                Ok(Node::Int(token.pos, num))
             }
-            token::Kind::StringLiteral => Ok(tree::Node::String(token.pos, token.raw)),
-            token::Kind::TrueKeyword => Ok(tree::Node::Bool(token.pos, true)),
-            token::Kind::FalseKeyword => Ok(tree::Node::Bool(token.pos, false)),
+            token::Kind::StringLiteral => Ok(Node::String(token.pos, token.raw)),
+            token::Kind::TrueKeyword => Ok(Node::Bool(token.pos, true)),
+            token::Kind::FalseKeyword => Ok(Node::Bool(token.pos, false)),
             token::Kind::FnKeyword => {
                 self.lexer.prev(); // parse_fn() expects to consume the keyword
                 self.parse_fn(true)
@@ -545,7 +545,7 @@ impl Parser {
             token::Kind::OBracket => {
                 let elements =
                     self.parse_delimited_list(token::Kind::Comma, token::Kind::CBracket, true)?;
-                Ok(tree::Node::Array(token.pos, elements))
+                Ok(Node::Array(token.pos, elements))
             }
             _ => self.syntax_error(format!("Unexpected token {}", token.kind), &token),
         }
@@ -561,7 +561,7 @@ impl Parser {
     /// function_returning_an_array(params)[index]
     /// (fn(a, b) { return a + b; })(1, 2)
     /// ```
-    fn parse_primary_expr_rest(&mut self, start: tree::Node) -> Result<tree::Node, Error> {
+    fn parse_primary_expr_rest(&mut self, start: Node) -> Result<Node, Error> {
         if let Some(Ok(token)) = self.lexer.peek() {
             match token.kind {
                 token::Kind::OParen => {
@@ -569,7 +569,7 @@ impl Parser {
                     self.lexer.next();
                     let params =
                         self.parse_delimited_list(token::Kind::Comma, token::Kind::CParen, false)?;
-                    self.parse_primary_expr_rest(tree::Node::make_call_expr(
+                    self.parse_primary_expr_rest(Node::make_call_expr(
                         token.pos, start, params,
                     ))
                 }
@@ -577,7 +577,7 @@ impl Parser {
                     // array index
                     self.lexer.next();
                     let index = self.parse_expr(&[token::Kind::CBracket])?;
-                    self.parse_primary_expr_rest(tree::Node::make_array_expr(
+                    self.parse_primary_expr_rest(Node::make_array_expr(
                         token.pos, start, index,
                     ))
                 }
@@ -585,11 +585,11 @@ impl Parser {
                     // member access
                     self.lexer.next();
                     let member = self.lexer.expect_kind(token::Kind::Ident)?;
-                    self.parse_primary_expr_rest(tree::Node::make_binary_expr(
+                    self.parse_primary_expr_rest(Node::make_binary_expr(
                         token.pos,
                         start,
                         Operator::Dot,
-                        tree::Node::Ident(member.pos, member.raw),
+                        Node::Ident(member.pos, member.raw),
                     ))
                 }
                 _ => Ok(start),
@@ -606,7 +606,7 @@ impl Parser {
     /// ParameterList
     ///  : Identifier [ "," ParameterList ]
     /// ```
-    fn parse_fn(&mut self, allow_anonymous: bool) -> Result<tree::Node, Error> {
+    fn parse_fn(&mut self, allow_anonymous: bool) -> Result<Node, Error> {
         self.scope.push(Scope::Function);
         let fn_keyword = self.lexer.expect_kind(token::Kind::FnKeyword)?;
 
@@ -614,7 +614,7 @@ impl Parser {
         let name = if let Some(Ok(token)) = self.lexer.peek() {
             if token.kind == token::Kind::Ident {
                 self.lexer.next();
-                Some(tree::Node::Ident(token.pos, token.raw))
+                Some(Node::Ident(token.pos, token.raw))
             } else {
                 None
             }
@@ -631,7 +631,7 @@ impl Parser {
         let params = self.parse_delimited_list(token::Kind::Comma, token::Kind::CParen, false)?;
         for p in &params {
             match p {
-                tree::Node::Ident(_, _) => continue,
+                Node::Ident(_, _) => continue,
                 _ => {
                     return self
                         .syntax_error(format!("Not an identifier"), &self.lexer.current().unwrap())
@@ -642,7 +642,7 @@ impl Parser {
         let body = self.parse_block_stmt()?;
 
         self.scope.pop();
-        Ok(tree::Node::make_fn(fn_keyword.pos, name, params, body))
+        Ok(Node::make_fn(fn_keyword.pos, name, params, body))
     }
 
     /// Parse a terminated, delimited list of expressions.  This is used for
@@ -652,7 +652,7 @@ impl Parser {
         delimiter: token::Kind,
         terminator: token::Kind,
         allow_trailing_delimiter: bool,
-    ) -> Result<Vec<tree::Node>, Error> {
+    ) -> Result<Vec<Node>, Error> {
         let mut list = Vec::new();
 
         // In the simplest case, we immediately see the terminator.