diff --git a/src/protocol/parser/mod.rs b/src/protocol/parser/mod.rs
index 73fdd6dfcd496c0ec23042d8c6bb0c6272a57d99..9ef01e4a58319347b06620e5b7012a140d093c5d 100644
--- a/src/protocol/parser/mod.rs
+++ b/src/protocol/parser/mod.rs
@@ -324,8 +324,8 @@ impl Parser {
                 types: &mut self.type_table,
                 arch: &self.arch,
             };
-            self.pass_rewriting.visit_module(&mut ctx);
-            self.pass_stack_size.visit_module(&mut ctx);
+            self.pass_rewriting.visit_module(&mut ctx)?;
+            self.pass_stack_size.visit_module(&mut ctx)?;
         }
 
         // Write out desired information
@@ -356,7 +356,7 @@ fn insert_builtin_type(type_table: &mut TypeTable, parts: Vec<ConcreteTypePart>,
 }
 
 // Note: args and return type need to be a function because we need to know the function ID.
-fn insert_builtin_function<T: Fn(FunctionDefinitionId) -> (Vec<(&'static str, ParserType)>, ParserType)> (
+fn insert_builtin_function<T: Fn(ProcedureDefinitionId) -> (Vec<(&'static str, ParserType)>, ParserType)> (
     p: &mut Parser, func_name: &str, polymorphic: &[&str], arg_and_return_fn: T
 ) {
     let mut poly_vars = Vec::with_capacity(polymorphic.len());
@@ -365,21 +365,22 @@ fn insert_builtin_function<T: Fn(FunctionDefinitionId) -> (Vec<(&'static str, Pa
     }
 
     let func_ident_ref = p.string_pool.intern(func_name.as_bytes());
-    let func_id = p.heap.alloc_function_definition(|this| FunctionDefinition{
+    let procedure_id = p.heap.alloc_procedure_definition(|this| ProcedureDefinition {
         this,
         defined_in: RootId::new_invalid(),
         builtin: true,
+        kind: ProcedureKind::Function,
         span: InputSpan::new(),
         identifier: Identifier{ span: InputSpan::new(), value: func_ident_ref.clone() },
         poly_vars,
-        return_type: ParserType{ elements: Vec::new(), full_span: InputSpan::new() },
+        return_type: None,
         parameters: Vec::new(),
         scope: ScopeId::new_invalid(),
         body: BlockStatementId::new_invalid(),
         num_expressions_in_body: -1,
     });
 
-    let (arguments, return_type) = arg_and_return_fn(func_id);
+    let (arguments, return_type) = arg_and_return_fn(procedure_id);
 
     let mut parameters = Vec::with_capacity(arguments.len());
     for (arg_name, arg_type) in arguments {
@@ -395,9 +396,9 @@ fn insert_builtin_function<T: Fn(FunctionDefinitionId) -> (Vec<(&'static str, Pa
         parameters.push(param_id);
     }
 
-    let func = &mut p.heap[func_id];
+    let func = &mut p.heap[procedure_id];
     func.parameters = parameters;
-    func.return_type = return_type;
+    func.return_type = Some(return_type);
 
     p.symbol_table.insert_symbol(SymbolScope::Global, Symbol{
         name: func_ident_ref,
@@ -408,7 +409,7 @@ fn insert_builtin_function<T: Fn(FunctionDefinitionId) -> (Vec<(&'static str, Pa
             identifier_span: InputSpan::new(),
             imported_at: None,
             class: DefinitionClass::Function,
-            definition_id: func_id.upcast(),
+            definition_id: procedure_id.upcast(),
         })
     }).unwrap();
 }
\ No newline at end of file