CSY/reowolf Changeset - ba57649f36e2 · Centrum Wiskunde & Informatica (CWI)

Changeset - ba57649f36e2

Parent rev.

Child rev.

[Not reviewed]

0 9 0

MH - 4 years ago 2021-07-27 13:10:10
contact@maxhenger.nl

finished type loop resolving and memory layout algorithm

9 files changed with 677 insertions and 426 deletions:

src/protocol/ast_printer.rs

src/protocol/parser/mod.rs

src/protocol/parser/pass_typing.rs

src/protocol/parser/pass_validation_linking.rs

src/protocol/parser/type_table.rs

307

196

src/protocol/parser/visitor.rs

src/protocol/tests/parser_monomorphs.rs

src/protocol/tests/parser_types.rs

src/protocol/tests/utils.rs

0 comments (0 inline, 0 general)

src/protocol/ast_printer.rs

➞

Show inline comments

                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
                 target.push_str("[..]");
+            }
             CTP::Input => {
                 target.push_str("in<");
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
                 target.push('>');
             },
             CTP::Output => {
                 target.push_str("out<");
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
                 target.push('>')
             },
             CTP::Instance(definition_id, num_embedded) => {
                 let identifier = heap[*definition_id].identifier();
                 target.push_str(identifier.value.as_str());
                 target.push('<');
                 for idx_embedded in 0..*num_embedded {
                     if idx_embedded != 0 {
                         target.push_str(", ");
+                    }
                     idx = write_concrete_part(target, heap, def_id, t, idx + 1);
+                }
                 target.push('>');
+            }
             },
             CTP::Function(_, _) => todo!("AST printer for ConcreteTypePart::Function"),
             CTP::Component(_, _) => todo!("AST printer for ConcreteTypePart::Component"),
+        }
         idx + 1
+    }
     write_concrete_part(target, heap, def_id, t, 0);
+}
 fn write_expression_parent(target: &mut String, parent: &ExpressionParent) {
     use ExpressionParent as EP;
     *target = match parent {
         EP::None => String::from("None"),
         EP::If(id) => format!("IfStmt({})", id.0.index),
         EP::While(id) => format!("WhileStmt({})", id.0.index),
         EP::Return(id) => format!("ReturnStmt({})", id.0.index),
         EP::New(id) => format!("NewStmt({})", id.0.index),
         EP::ExpressionStmt(id) => format!("ExprStmt({})", id.0.index),
         EP::Expression(id, idx) => format!("Expr({}, {})", id.index, idx)
     };
+}
@@ \ No newline at end of file @@

src/protocol/parser/mod.rs

➞

Show inline comments

@@ @@ -190,73 +190,79 @@ impl Parser { @@
             pool: &mut self.string_pool,
             arch: &self.arch,
         };
         // Advance all modules to the phase where all symbols are scanned
         for module_idx in 0..self.modules.len() {
             self.pass_symbols.parse(&mut self.modules, module_idx, &mut pass_ctx)?;
+        }
         // With all symbols scanned, perform further compilation until we can
         // add all base types to the type table.
         for module_idx in 0..self.modules.len() {
             self.pass_import.parse(&mut self.modules, module_idx, &mut pass_ctx)?;
             self.pass_definitions.parse(&mut self.modules, module_idx, &mut pass_ctx)?;
+        }
         // Add every known type to the type table
         self.type_table.build_base_types(&mut self.modules, &mut pass_ctx)?;
         // Continue compilation with the remaining phases now that the types
         // are all in the type table
         for module_idx in 0..self.modules.len() {
             let mut ctx = visitor::Ctx{
                 heap: &mut self.heap,
                 module: &mut self.modules[module_idx],
                 modules: &mut self.modules,
                 module_idx,
                 symbols: &mut self.symbol_table,
                 types: &mut self.type_table,
                 arch: &self.arch,
             };
             self.pass_validation.visit_module(&mut ctx)?;
+        }
         // Perform typechecking on all modules
         let mut queue = ResolveQueue::new();
-        for module in &mut self.modules {
+        for module_idx in 0..self.modules.len() {
             let mut ctx = visitor::Ctx{
                 heap: &mut self.heap,
                 module,
                 modules: &mut self.modules,
                 module_idx,
                 symbols: &mut self.symbol_table,
                 types: &mut self.type_table,
                 arch: &self.arch,
             };
             PassTyping::queue_module_definitions(&mut ctx, &mut queue);
         };
         while !queue.is_empty() {
             let top = queue.pop().unwrap();
             let mut ctx = visitor::Ctx{
                 heap: &mut self.heap,
                 module: &mut self.modules[top.root_id.index as usize],
                 modules: &mut self.modules,
                 module_idx: top.root_id.index as usize,
                 symbols: &mut self.symbol_table,
                 types: &mut self.type_table,
                 arch: &self.arch,
             };
             self.pass_typing.handle_module_definition(&mut ctx, &mut queue, top)?;
+        }
         // Write out desired information
         if let Some(filename) = &self.write_ast_to {
             let mut writer = ASTWriter::new();
             let mut file = std::fs::File::create(std::path::Path::new(filename)).unwrap();
             writer.write_ast(&mut file, &self.heap);
+        }
         Ok(())
+    }
+}
 // 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)> (
     p: &mut Parser, func_name: &str, polymorphic: &[&str], arg_and_return_fn: T) {
     let mut poly_vars = Vec::with_capacity(polymorphic.len());
     for poly_var in polymorphic {
         poly_vars.push(Identifier{ span: InputSpan::new(), value: p.string_pool.intern(poly_var.as_bytes()) });
+    }

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -538,56 +538,57 @@ impl InferenceType { @@
             if part_a.is_marker() { idx_a += 1; continue; }
             if part_b.is_marker() { idx_b += 1; continue; }
             if let Some(depth_change) = Self::check_part_for_single_type(
                 type_parts_a, &mut idx_a, type_parts_b, &mut idx_b
             ) {
                 depth += depth_change;
                 continue;
+            }
             if let Some(depth_change) = Self::check_part_for_single_type(
                 type_parts_b, &mut idx_b, type_parts_a, &mut idx_a
             ) {
                 depth += depth_change;
                 continue;
+            }
             return false;
+        }
         true
+    }
     /// Performs the conversion of the inference type into a concrete type.
     /// By calling this function you must make sure that no unspecified types
     /// (e.g. Unknown or IntegerLike) exist in the type.
     /// (e.g. Unknown or IntegerLike) exist in the type. Will not clear or check
     /// if the supplied `ConcreteType` is empty, will simply append to the parts
     /// vector.
     fn write_concrete_type(&self, concrete_type: &mut ConcreteType) {
         use InferenceTypePart as ITP;
         use ConcreteTypePart as CTP;
         // Make sure inference type is specified but concrete type is not yet specified
         debug_assert!(!self.parts.is_empty());
         debug_assert!(concrete_type.parts.is_empty());
         concrete_type.parts.reserve(self.parts.len());
         let mut idx = 0;
         while idx < self.parts.len() {
             let part = &self.parts[idx];
             let converted_part = match part {
                 ITP::Marker(_) => {
                     // Markers are removed when writing to the concrete type.
                     idx += 1;
                     continue;
                 },
                 ITP::Unknown | ITP::NumberLike |
                 ITP::IntegerLike | ITP::ArrayLike | ITP::PortLike => {
                     // Should not happen if type inferencing works correctly: we
                     // should have returned a programmer-readable error or have
                     // inferred all types.
                     unreachable!("attempted to convert inference type part {:?} into concrete type", part);
                 },
                 ITP::Void => CTP::Void,
                 ITP::Message => CTP::Message,
                 ITP::Bool => CTP::Bool,
                 ITP::UInt8 => CTP::UInt8,
                 ITP::UInt16 => CTP::UInt16,
                 ITP::UInt32 => CTP::UInt32,
@@ @@ -786,64 +787,56 @@ impl DualInferenceResult { @@
+}
 #[derive(Debug, PartialEq, Eq)]
 enum SingleInferenceResult {
     Unmodified,
     Modified,
     Incompatible
+}
 enum DefinitionType{
     Component(ComponentDefinitionId),
     Function(FunctionDefinitionId),
+}
 impl DefinitionType {
     fn definition_id(&self) -> DefinitionId {
         match self {
             DefinitionType::Component(v) => v.upcast(),
             DefinitionType::Function(v) => v.upcast(),
+        }
+    }
+}
 pub(crate) struct ResolveQueueElement {
     // Note that using the `definition_id` and the `monomorph_idx` one may
     // query the type table for the full procedure type, thereby retrieving
     // the polymorphic arguments to the procedure.
     pub(crate) root_id: RootId,
     pub(crate) definition_id: DefinitionId,
     pub(crate) monomorph_types: Vec<ConcreteType>,
     pub(crate) reserved_monomorph_idx: i32,
+}
 impl PartialEq for ResolveQueueElement {
     fn eq(&self, other: &Self) -> bool {
         return
             self.root_id == other.root_id &&
             self.definition_id == other.definition_id &&
             self.monomorph_types == other.monomorph_types;
+    }
+}
 impl Eq for ResolveQueueElement {}
 pub(crate) type ResolveQueue = Vec<ResolveQueueElement>;
 #[derive(Clone)]
 struct InferenceExpression {
     expr_type: InferenceType,       // result type from expression
     expr_id: ExpressionId,          // expression that is evaluated
     field_or_monomorph_idx: i32,    // index of field, of index of monomorph array in type table
     extra_data_idx: i32,     // index of extra data needed for inference
+}
 impl Default for InferenceExpression {
     fn default() -> Self {
         Self{
             expr_type: InferenceType::default(),
             expr_id: ExpressionId::new_invalid(),
             field_or_monomorph_idx: -1,
             extra_data_idx: -1,
+        }
+    }
+}
 /// This particular visitor will recurse depth-first into the AST and ensures
 /// that all expressions have the appropriate types.
 pub(crate) struct PassTyping {
@@ @@ -906,84 +899,107 @@ impl VarData { @@
+    }
     fn new_local(var_type: InferenceType) -> Self {
         Self{ var_type, used_at: Vec::new(), linked_var: None }
+    }
+}
 impl PassTyping {
     pub(crate) fn new() -> Self {
         PassTyping {
             reserved_idx: -1,
             definition_type: DefinitionType::Function(FunctionDefinitionId::new_invalid()),
             poly_vars: Vec::new(),
             stmt_buffer: Vec::with_capacity(STMT_BUFFER_INIT_CAPACITY),
             expr_buffer: Vec::with_capacity(EXPR_BUFFER_INIT_CAPACITY),
             var_types: HashMap::new(),
             expr_types: Vec::new(),
             extra_data: Vec::new(),
             expr_queued: DequeSet::new(),
+        }
+    }
     // TODO: @cleanup Unsure about this, maybe a pattern will arise after
     //  a while.
     pub(crate) fn queue_module_definitions(ctx: &mut Ctx, queue: &mut ResolveQueue) {
         debug_assert_eq!(ctx.module.phase, ModuleCompilationPhase::ValidatedAndLinked);
         let root_id = ctx.module.root_id;
         debug_assert_eq!(ctx.module().phase, ModuleCompilationPhase::ValidatedAndLinked);
         let root_id = ctx.module().root_id;
         let root = &ctx.heap.protocol_descriptions[root_id];
         for definition_id in &root.definitions {
             let definition = &ctx.heap[*definition_id];
             let should_add_to_queue = match definition {
                 Definition::Function(definition) => definition.poly_vars.is_empty(),
                 Definition::Component(definition) => definition.poly_vars.is_empty(),
                 Definition::Enum(_) | Definition::Struct(_) | Definition::Union(_) => false,
             let first_concrete_part = match definition {
                 Definition::Function(definition) => {
                     if definition.poly_vars.is_empty() {
                         Some(ConcreteTypePart::Function(*definition_id, 0))
                     } else {
                         None
+                    }
+                }
                 Definition::Component(definition) => {
                     if definition.poly_vars.is_empty() {
                         Some(ConcreteTypePart::Component(*definition_id, 0))
                     } else {
                         None
+                    }
                 },
                 Definition::Enum(_) | Definition::Struct(_) | Definition::Union(_) => None,
             };
             if should_add_to_queue {
                 let reserved_idx = ctx.types.reserve_procedure_monomorph_index(definition_id, None);
             if let Some(first_concrete_part) = first_concrete_part {
                 let concrete_type = ConcreteType{ parts: vec![first_concrete_part] };
                 let reserved_idx = ctx.types.reserve_procedure_monomorph_index(definition_id, concrete_type);
                 queue.push(ResolveQueueElement{
                     root_id,
                     definition_id: *definition_id,
                     monomorph_types: Vec::new(),
                     reserved_monomorph_idx: reserved_idx,
                 })
+            }
+        }
+    }
     pub(crate) fn handle_module_definition(
         &mut self, ctx: &mut Ctx, queue: &mut ResolveQueue, element: ResolveQueueElement
     ) -> VisitorResult {
         // Visit the definition
         debug_assert_eq!(ctx.module.root_id, element.root_id);
         self.reset();
         debug_assert_eq!(ctx.module().root_id, element.root_id);
         debug_assert!(self.poly_vars.is_empty());
         // Prepare for visiting the definition
         self.reserved_idx = element.reserved_monomorph_idx;
         self.poly_vars = element.monomorph_types;
         self.visit_definition(ctx, element.definition_id)?;
         // Keep resolving types
         let proc_base = ctx.types.get_base_definition(&element.definition_id).unwrap();
         if proc_base.is_polymorph {
             let proc_monos = proc_base.definition.procedure_monomorphs();
             let proc_mono = &(*proc_monos)[element.reserved_monomorph_idx as usize];
             for poly_arg in proc_mono.concrete_type.embedded_iter(0) {
                 self.poly_vars.push(ConcreteType{ parts: Vec::from(poly_arg) });
+            }
+        }
         // Visit the definition, setting up the type resolving process, then
         // (attempt to) resolve all types
         self.visit_definition(ctx, element.definition_id)?;
         self.resolve_types(ctx, queue)?;
         Ok(())
+    }
     fn reset(&mut self) {
         self.reserved_idx = -1;
         self.definition_type = DefinitionType::Function(FunctionDefinitionId::new_invalid());
         self.poly_vars.clear();
         self.stmt_buffer.clear();
         self.expr_buffer.clear();
         self.var_types.clear();
         self.expr_types.clear();
         self.extra_data.clear();
         self.expr_queued.clear();
+    }
+}
 impl Visitor for PassTyping {
     // Definitions
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {
         self.definition_type = DefinitionType::Component(id);
         let comp_def = &ctx.heap[id];
@@ @@ -1373,200 +1389,194 @@ impl Visitor for PassTyping { @@
         self.progress_variable_expr(ctx, id)
+    }
+}
 impl PassTyping {
     #[allow(dead_code)] // used when debug flag at the top of this file is true.
     fn debug_get_display_name(&self, ctx: &Ctx, expr_id: ExpressionId) -> String {
         let expr_idx = ctx.heap[expr_id].get_unique_id_in_definition();
         let expr_type = &self.expr_types[expr_idx as usize].expr_type;
         expr_type.display_name(&ctx.heap)
+    }
     fn resolve_types(&mut self, ctx: &mut Ctx, queue: &mut ResolveQueue) -> Result<(), ParseError> {
         // Keep inferring until we can no longer make any progress
         while !self.expr_queued.is_empty() {
             let next_expr_idx = self.expr_queued.pop_front().unwrap();
             self.progress_expr(ctx, next_expr_idx)?;
+        }
         // Helper for transferring polymorphic variables to concrete types and
         // checking if they're completely specified
         fn inference_type_to_concrete_type(
             ctx: &Ctx, expr_id: ExpressionId, inference: &Vec<InferenceType>,
             first_concrete_part: ConcreteTypePart,
-        ) -> Result<(ConcreteType, Vec<ConcreteType>), ParseError> {
         ) -> Result<ConcreteType, ParseError> {
             // Prepare storage vector
             let mut num_inference_parts = 0;
             for inference_type in inference {
                 num_inference_parts += inference_type.parts.len();
+            }
             let mut concrete_full_parts = Vec::with_capacity(1 + num_inference_parts);
             concrete_full_parts.push(first_concrete_part);
             let mut concrete_poly_args = Vec::with_capacity(inference.len());
             let mut concrete_type = ConcreteType{
                 parts: Vec::with_capacity(1 + num_inference_parts),
             };
             concrete_type.parts.push(first_concrete_part);
             // Go through all polymorphic arguments and add them to the concrete
             // types.
             for (poly_idx, poly_type) in inference.iter().enumerate() {
                 if !poly_type.is_done {
                     let expr = &ctx.heap[expr_id];
                     let definition = match expr {
                         Expression::Call(expr) => expr.definition,
                         Expression::Literal(expr) => match &expr.value {
                             Literal::Enum(lit) => lit.definition,
                             Literal::Union(lit) => lit.definition,
                             Literal::Struct(lit) => lit.definition,
                             _ => unreachable!()
                         },
                         _ => unreachable!(),
                     };
                     let poly_vars = ctx.heap[definition].poly_vars();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, expr.operation_span(), format!(
+                        &ctx.module().source, expr.operation_span(), format!(
                             "could not fully infer the type of polymorphic variable '{}' of this expression (got '{}')",
                             poly_vars[poly_idx].value.as_str(), poly_type.display_name(&ctx.heap)
+                        )
                     ));
+                }
                 let mut concrete_type = ConcreteType::default();
                 poly_type.write_concrete_type(&mut concrete_type);
                 concrete_full_parts.extend_from_slice(&concrete_type.parts);
                 concrete_poly_args.push(concrete_type);
+            }
-            Ok((ConcreteType{ parts: concrete_full_parts }, concrete_poly_args))
+            Ok(concrete_type)
+        }
         // Inference is now done. But we may still have uninferred types. So we
         // check for these.
         for (infer_expr_idx, infer_expr) in self.expr_types.iter_mut().enumerate() {
             let expr_type = &mut infer_expr.expr_type;
             if !expr_type.is_done {
                 // Auto-infer numberlike/integerlike types to a regular int
                 if expr_type.parts.len() == 1 && expr_type.parts[0] == InferenceTypePart::IntegerLike {
                     expr_type.parts[0] = InferenceTypePart::SInt32;
                     self.expr_queued.push_back(infer_expr_idx as i32);
                 } else {
                     let expr = &ctx.heap[infer_expr.expr_id];
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, expr.full_span(), format!(
+                        &ctx.module().source, expr.full_span(), format!(
                             "could not fully infer the type of this expression (got '{}')",
                             expr_type.display_name(&ctx.heap)
+                        )
                     ));
+                }
+            }
             // Expression is fine, check if any extra data is attached
             if infer_expr.extra_data_idx < 0 { continue; }
             // Extra data is attached, perform typechecking and transfer
             // resolved information to the expression
             let extra_data = &self.extra_data[infer_expr.extra_data_idx as usize];
             if extra_data.poly_vars.is_empty() { continue; }
             // Note that only call and literal expressions need full inference.
             // Select expressions also use `extra_data`, but only for temporary
             // storage of the struct type whose field it is selecting.
             match &ctx.heap[extra_data.expr_id] {
                 Expression::Call(expr) => {
                     // Check if it is not a builtin function. If not, then
                     // construct the first part of the concrete type.
                     let first_concrete_part = if expr.method == Method::UserFunction {
                         ConcreteTypePart::Function(expr.definition, extra_data.poly_vars.len() as u32)
                     } else if expr.method == Method::UserComponent {
                         ConcreteTypePart::Component(expr.definition, extra_data.poly_vars.len() as u32)
                     } else {
                         // Builtin function
                         continue;
                     };
                     let definition_id = expr.definition;
-                    let (concrete_type, poly_types) = inference_type_to_concrete_type(
                     let concrete_type = inference_type_to_concrete_type(
                         ctx, extra_data.expr_id, &extra_data.poly_vars, first_concrete_part
                     )?;
-                    match ctx.types.get_procedure_monomorph_index(&definition_id, &poly_types) {
+                    match ctx.types.get_procedure_monomorph_index(&definition_id, &concrete_type) {
                         Some(reserved_idx) => {
                             // Already typechecked, or already put into the resolve queue
                             infer_expr.field_or_monomorph_idx = reserved_idx;
                         },
                         None => {
                             // Not typechecked yet, so add an entry in the queue
-                            let reserved_idx = ctx.types.reserve_procedure_monomorph_index(&definition_id, Some(poly_types.clone()));
+                            let reserved_idx = ctx.types.reserve_procedure_monomorph_index(&definition_id, concrete_type);
                             infer_expr.field_or_monomorph_idx = reserved_idx;
                             queue.push(ResolveQueueElement{
                                 root_id: ctx.heap[definition_id].defined_in(),
                                 definition_id,
                                 monomorph_types: poly_types,
                                 reserved_monomorph_idx: reserved_idx,
                             });
+                        }
+                    }
                 },
                 Expression::Literal(expr) => {
                     let definition_id = match &expr.value {
                         Literal::Enum(lit) => lit.definition,
                         Literal::Union(lit) => lit.definition,
                         Literal::Struct(lit) => lit.definition,
                         _ => unreachable!(),
                     };
                     let first_concrete_part = ConcreteTypePart::Instance(definition_id, extra_data.poly_vars.len() as u32);
-                    let (concrete_type, poly_types) = inference_type_to_concrete_type(
                     let concrete_type = inference_type_to_concrete_type(
                         ctx, extra_data.expr_id, &extra_data.poly_vars, first_concrete_part
                     )?;
-                    let mono_index = ctx.types.add_data_monomorph(modules, ctx, &definition_id, concrete_type)?;
+                    let mono_index = ctx.types.add_data_monomorph(ctx.modules, ctx.heap, ctx.arch, definition_id, concrete_type)?;
                     infer_expr.field_or_monomorph_idx = mono_index;
                 },
                 Expression::Select(_) => {
                     debug_assert!(infer_expr.field_or_monomorph_idx >= 0);
                 },
                 _ => {
                     unreachable!("handling extra data for expression {:?}", &ctx.heap[extra_data.expr_id]);
+                }
+            }
+        }
         // If we did any implicit type forcing, then our queue isn't empty
         // anymore
         while !self.expr_queued.is_empty() {
             let expr_idx = self.expr_queued.pop_back().unwrap();
             self.progress_expr(ctx, expr_idx)?;
+        }
         // Every expression checked, and new monomorphs are queued. Transfer the
         // expression information to the type table.
         let definition_id = match &self.definition_type {
             DefinitionType::Component(id) => id.upcast(),
             DefinitionType::Function(id) => id.upcast(),
         };
         let target = ctx.types.get_procedure_expression_data_mut(&definition_id, self.reserved_idx);
         debug_assert!(target.poly_args == self.poly_vars);
         debug_assert!(target.expr_data.is_empty()); // makes sure we never queue something twice
         target.expr_data.reserve(self.expr_types.len());
         for infer_expr in self.expr_types.iter() {
             let mut concrete = ConcreteType::default();
             infer_expr.expr_type.write_concrete_type(&mut concrete);
             target.expr_data.push(MonomorphExpression{
                 expr_type: concrete,
                 field_or_monomorph_idx: infer_expr.field_or_monomorph_idx
             });
+        }
         Ok(())
+    }
     fn progress_expr(&mut self, ctx: &mut Ctx, idx: i32) -> Result<(), ParseError> {
         let id = self.expr_types[idx as usize].expr_id; // TODO: @Temp
         match &ctx.heap[id] {
             Expression::Assignment(expr) => {
                 let id = expr.this;
                 self.progress_assignment_expr(ctx, id)
             },
             Expression::Binding(expr) => {
                 let id = expr.this;
@@ @@ -1997,89 +2007,89 @@ impl PassTyping { @@
                 } else {
                     // Expected an instance of something
                     return Err(())
+                }
+            }
             // Nothing is concrete yet
             Ok(None)
+        }
         if infer_expr.field_or_monomorph_idx < 0 {
             // We don't know the field or the definition it is pointing to yet
             // Not yet known, check if we can determine it
             let subject_type = &self.expr_types[subject_expr_idx as usize].expr_type;
             let type_def = determine_inference_type_instance(&ctx.types, subject_type);
             match type_def {
                 Ok(Some(type_def)) => {
                     // Subject type is known, check if it is a
                     // struct and the field exists on the struct
                     let struct_def = if let DefinedTypeVariant::Struct(struct_def) = &type_def.definition {
                         struct_def
                     } else {
                         return Err(ParseError::new_error_at_span(
                             &ctx.module.source, select_expr.field_name.span, format!(
+                            &ctx.module().source, select_expr.field_name.span, format!(
                                 "Can only apply field access to structs, got a subject of type '{}'",
                                 subject_type.display_name(&ctx.heap)
+                            )
                         ));
                     };
                     let mut struct_def_id = None;
                     for (field_def_idx, field_def) in struct_def.fields.iter().enumerate() {
                         if field_def.identifier == select_expr.field_name {
                             // Set field definition and index
                             let infer_expr = &mut self.expr_types[expr_idx as usize];
                             infer_expr.field_or_monomorph_idx = field_def_idx as i32;
                             struct_def_id = Some(type_def.ast_definition);
                             break;
+                        }
+                    }
                     if struct_def_id.is_none() {
                         let ast_struct_def = ctx.heap[type_def.ast_definition].as_struct();
                         return Err(ParseError::new_error_at_span(
                             &ctx.module.source, select_expr.field_name.span, format!(
+                            &ctx.module().source, select_expr.field_name.span, format!(
                                 "this field does not exist on the struct '{}'",
                                 ast_struct_def.identifier.value.as_str()
+                            )
                         ))
+                    }
                     // Encountered definition and field index for the
                     // first time
                     self.insert_initial_select_polymorph_data(ctx, id, struct_def_id.unwrap());
                 },
                 Ok(None) => {
                     // Type of subject is not yet known, so we
                     // cannot make any progress yet
                     return Ok(())
                 },
                 Err(()) => {
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, select_expr.field_name.span, format!(
+                        &ctx.module().source, select_expr.field_name.span, format!(
                             "Can only apply field access to structs, got a subject of type '{}'",
                             subject_type.display_name(&ctx.heap)
+                        )
                     ));
+                }
+            }
+        }
         // If here then field index is known, and the referenced struct type
         // information is inserted into `extra_data`. Check to see if we can
         // do some mutual inference.
         let poly_data = &mut self.extra_data[extra_idx as usize];
         let mut poly_progress = HashSet::new();
         // Apply to struct's type
         let signature_type: *mut _ = &mut poly_data.embedded[0];
         let subject_type: *mut _ = &mut self.expr_types[subject_expr_idx as usize].expr_type;
         let (_, progress_subject) = Self::apply_equal2_signature_constraint(
             ctx, upcast_id, Some(subject_id), poly_data, &mut poly_progress,
             signature_type, 0, subject_type, 0
         )?;
         if progress_subject {
@@ @@ -2463,51 +2473,51 @@ impl PassTyping { @@
         // Valid casts: (bool, integer, character) can always be cast to one
         // another. A cast from a type to itself is also valid.
         fn is_bool_int_or_char(parts: &[InferenceTypePart]) -> bool {
             return parts.len() == 1 && (
                 parts[0] == InferenceTypePart::Bool ||
                 parts[0] == InferenceTypePart::Character ||
                 parts[0].is_concrete_integer()
             );
+        }
         let is_valid = if is_bool_int_or_char(&expr_type.parts) && is_bool_int_or_char(&subject_type.parts) {
             true
         } else if expr_type.parts == subject_type.parts {
             true
         } else {
             false
         };
         debug_log!("   - Casting is valid: {}", is_valid);
         if !is_valid {
             let cast_expr = &ctx.heap[id];
             let subject_expr = &ctx.heap[cast_expr.subject];
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, cast_expr.full_span, "invalid casting operation"
+                &ctx.module().source, cast_expr.full_span, "invalid casting operation"
             ).with_info_at_span(
                 &ctx.module.source, subject_expr.full_span(), format!(
+                &ctx.module().source, subject_expr.full_span(), format!(
                     "cannot cast the argument type '{}' to the cast type '{}'",
                     subject_type.display_name(&ctx.heap),
                     expr_type.display_name(&ctx.heap)
+                )
             ));
+        }
         Ok(())
+    }
     // TODO: @cleanup, see how this can be cleaned up once I implement
     //  polymorphic struct/enum/union literals. These likely follow the same
     //  pattern as here.
     fn progress_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> Result<(), ParseError> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let expr_idx = expr.unique_id_in_definition;
         let extra_idx = self.expr_types[expr_idx as usize].extra_data_idx;
         debug_log!("Call expr '{}': {}", ctx.heap[expr.definition].identifier().value.as_str(), upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Expr type: {}", self.debug_get_display_name(ctx, upcast_id));
         debug_log!(" * During (inferring types from arguments and return type):");
@@ @@ -2613,54 +2623,54 @@ impl PassTyping { @@
         Ok(())
+    }
     fn progress_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> Result<(), ParseError> {
         let upcast_id = id.upcast();
         let var_expr = &ctx.heap[id];
         let var_expr_idx = var_expr.unique_id_in_definition;
         let var_id = var_expr.declaration.unwrap();
         debug_log!("Variable expr '{}': {}", ctx.heap[var_id].identifier.value.as_str(), upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Var  type: {}", self.var_types.get(&var_id).unwrap().var_type.display_name(&ctx.heap));
         debug_log!("   - Expr type: {}", self.debug_get_display_name(ctx, upcast_id));
         // Retrieve shared variable type and expression type and apply inference
         let var_data = self.var_types.get_mut(&var_id).unwrap();
         let expr_type = &mut self.expr_types[var_expr_idx as usize].expr_type;
         let infer_res = unsafe{ InferenceType::infer_subtrees_for_both_types(
             &mut var_data.var_type as *mut _, 0, expr_type, 0
         ) };
         if infer_res == DualInferenceResult::Incompatible {
             let var_decl = &ctx.heap[var_id];
             return Err(ParseError::new_error_at_span(
                 &ctx.module.source, var_decl.identifier.span, format!(
+                &ctx.module().source, var_decl.identifier.span, format!(
                     "Conflicting types for this variable, previously assigned the type '{}'",
                     var_data.var_type.display_name(&ctx.heap)
+                )
             ).with_info_at_span(
                 &ctx.module.source, var_expr.identifier.span, format!(
+                &ctx.module().source, var_expr.identifier.span, format!(
                     "But inferred to have incompatible type '{}' here",
                     expr_type.display_name(&ctx.heap)
+                )
             ))
+        }
         let progress_var = infer_res.modified_lhs();
         let progress_expr = infer_res.modified_rhs();
         if progress_var {
             // Let other variable expressions using this type progress as well
             for other_expr in var_data.used_at.iter() {
                 if *other_expr != upcast_id {
                     let other_expr_idx = ctx.heap[*other_expr].get_unique_id_in_definition();
                     self.expr_queued.push_back(other_expr_idx);
+                }
+            }
             // Let a linked port know that our type has updated
             if let Some(linked_id) = var_data.linked_var {
                 // Only perform one-way inference to prevent updating our type,
                 // this would lead to an inconsistency in the type inference
                 // algorithm otherwise.
                 let var_type: *mut _ = &mut var_data.var_type;
@@ @@ -2668,54 +2678,54 @@ impl PassTyping { @@
                 debug_assert!(
                     unsafe{&*var_type}.parts[0] == InferenceTypePart::Input ||
                     unsafe{&*var_type}.parts[0] == InferenceTypePart::Output
                 );
                 debug_assert!(
                     link_data.var_type.parts[0] == InferenceTypePart::Input ||
                     link_data.var_type.parts[0] == InferenceTypePart::Output
                 );
                 match InferenceType::infer_subtree_for_single_type(&mut link_data.var_type, 1, &unsafe{&*var_type}.parts, 1, false) {
                     SingleInferenceResult::Modified => {
                         for other_expr in &link_data.used_at {
                             let other_expr_idx = ctx.heap[*other_expr].get_unique_id_in_definition();
                             self.expr_queued.push_back(other_expr_idx);
+                        }
                     },
                     SingleInferenceResult::Unmodified => {},
                     SingleInferenceResult::Incompatible => {
                         let var_data = self.var_types.get(&var_id).unwrap();
                         let link_data = self.var_types.get(&linked_id).unwrap();
                         let var_decl = &ctx.heap[var_id];
                         let link_decl = &ctx.heap[linked_id];
                         return Err(ParseError::new_error_at_span(
                             &ctx.module.source, var_decl.identifier.span, format!(
+                            &ctx.module().source, var_decl.identifier.span, format!(
                                 "Conflicting types for this variable, assigned the type '{}'",
                                 var_data.var_type.display_name(&ctx.heap)
+                            )
                         ).with_info_at_span(
                             &ctx.module.source, link_decl.identifier.span, format!(
+                            &ctx.module().source, link_decl.identifier.span, format!(
                                 "Because it is incompatible with this variable, assigned the type '{}'",
                                 link_data.var_type.display_name(&ctx.heap)
+                            )
                         ));
+                    }
+                }
+            }
+        }
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         debug_log!(" * After:");
         debug_log!("   - Var  type [{}]: {}", progress_var, self.var_types.get(&var_id).unwrap().var_type.display_name(&ctx.heap));
         debug_log!("   - Expr type [{}]: {}", progress_expr, self.debug_get_display_name(ctx, upcast_id));
         Ok(())
+    }
     fn queue_expr_parent(&mut self, ctx: &Ctx, expr_id: ExpressionId) {
         if let ExpressionParent::Expression(parent_expr_id, _) = &ctx.heap[expr_id].parent() {
             let expr_idx = ctx.heap[*parent_expr_id].get_unique_id_in_definition();
             self.expr_queued.push_back(expr_idx);
+        }
+    }
@@ @@ -2832,52 +2842,52 @@ impl PassTyping { @@
     ) -> Result<(bool, bool), ParseError> {
         // Safety: all pointers distinct
         // Infer the signature and expression type
         let infer_res = unsafe {
             InferenceType::infer_subtrees_for_both_types(
                 signature_type, signature_start_idx,
                 expression_type, expression_start_idx
+            )
         };
         if infer_res == DualInferenceResult::Incompatible {
             // TODO: Check if I still need to use this
             let outer_span = ctx.heap[outer_expr_id].full_span();
             let (span_name, span) = match expr_id {
                 Some(expr_id) => ("argument's", ctx.heap[expr_id].full_span()),
                 None => ("type's", outer_span)
             };
             let (signature_display_type, expression_display_type) = unsafe { (
                 (&*signature_type).display_name(&ctx.heap),
                 (&*expression_type).display_name(&ctx.heap)
             ) };
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, outer_span,
+                &ctx.module().source, outer_span,
                 "failed to fully resolve the types of this expression"
             ).with_info_at_span(
                 &ctx.module.source, span, format!(
+                &ctx.module().source, span, format!(
                     "because the {} signature has been resolved to '{}', but the expression has been resolved to '{}'",
                     span_name, signature_display_type, expression_display_type
+                )
             ));
+        }
         // Try to see if we can progress any of the polymorphic variables
         let progress_sig = infer_res.modified_lhs();
         let progress_expr = infer_res.modified_rhs();
         if progress_sig {
             let signature_type = unsafe{&mut *signature_type};
             debug_assert!(
                 signature_type.has_marker,
                 "made progress on signature type, but it doesn't have a marker"
             );
             for (poly_idx, poly_section) in signature_type.marker_iter() {
                 let polymorph_type = &mut polymorph_data.poly_vars[poly_idx as usize];
                 match Self::apply_template_constraint_to_types(
                     polymorph_type, 0, poly_section, 0
                 ) {
                     Ok(true) => { polymorph_progress.insert(poly_idx); },
                     Ok(false) => {},
                     Err(()) => { return Err(Self::construct_poly_arg_error(ctx, polymorph_data, outer_expr_id))}
@@ @@ -3546,98 +3556,98 @@ impl PassTyping { @@
                 CTP::Instance(id, num) => parser_type.push(ITP::Instance(*id, *num)),
                 CTP::Function(_, _) => unreachable!("function type during concrete to inference type conversion"),
                 CTP::Component(_, _) => unreachable!("component type during concrete to inference type conversion"),
+            }
+        }
+    }
     /// Construct an error when an expression's type does not match. This
     /// happens if we infer the expression type from its arguments (e.g. the
     /// expression type of an addition operator is the type of the arguments)
     /// But the expression type was already set due to our parent (e.g. an
     /// "if statement" or a "logical not" always expecting a boolean)
     fn construct_expr_type_error(
         &self, ctx: &Ctx, expr_id: ExpressionId, arg_id: ExpressionId
     ) -> ParseError {
         // TODO: Expand and provide more meaningful information for humans
         let expr = &ctx.heap[expr_id];
         let arg_expr = &ctx.heap[arg_id];
         let expr_idx = expr.get_unique_id_in_definition();
         let arg_expr_idx = arg_expr.get_unique_id_in_definition();
         let expr_type = &self.expr_types[expr_idx as usize].expr_type;
         let arg_type = &self.expr_types[arg_expr_idx as usize].expr_type;
         return ParseError::new_error_at_span(
             &ctx.module.source, expr.operation_span(), format!(
+            &ctx.module().source, expr.operation_span(), format!(
                 "incompatible types: this expression expected a '{}'",
                 expr_type.display_name(&ctx.heap)
+            )
         ).with_info_at_span(
             &ctx.module.source, arg_expr.full_span(), format!(
+            &ctx.module().source, arg_expr.full_span(), format!(
                 "but this expression yields a '{}'",
                 arg_type.display_name(&ctx.heap)
+            )
+        )
+    }
     fn construct_arg_type_error(
         &self, ctx: &Ctx, expr_id: ExpressionId,
         arg1_id: ExpressionId, arg2_id: ExpressionId
     ) -> ParseError {
         let expr = &ctx.heap[expr_id];
         let arg1 = &ctx.heap[arg1_id];
         let arg2 = &ctx.heap[arg2_id];
         let arg1_idx = arg1.get_unique_id_in_definition();
         let arg1_type = &self.expr_types[arg1_idx as usize].expr_type;
         let arg2_idx = arg2.get_unique_id_in_definition();
         let arg2_type = &self.expr_types[arg2_idx as usize].expr_type;
         return ParseError::new_error_str_at_span(
             &ctx.module.source, expr.operation_span(),
+            &ctx.module().source, expr.operation_span(),
             "incompatible types: cannot apply this expression"
         ).with_info_at_span(
             &ctx.module.source, arg1.full_span(), format!(
+            &ctx.module().source, arg1.full_span(), format!(
                 "Because this expression has type '{}'",
                 arg1_type.display_name(&ctx.heap)
+            )
         ).with_info_at_span(
             &ctx.module.source, arg2.full_span(), format!(
+            &ctx.module().source, arg2.full_span(), format!(
                 "But this expression has type '{}'",
                 arg2_type.display_name(&ctx.heap)
+            )
+        )
+    }
     fn construct_template_type_error(
         &self, ctx: &Ctx, expr_id: ExpressionId, template: &[InferenceTypePart]
     ) -> ParseError {
         let expr = &ctx.heap[expr_id];
         let expr_idx = expr.get_unique_id_in_definition();
         let expr_type = &self.expr_types[expr_idx as usize].expr_type;
         return ParseError::new_error_at_span(
             &ctx.module.source, expr.full_span(), format!(
+            &ctx.module().source, expr.full_span(), format!(
                 "incompatible types: got a '{}' but expected a '{}'",
                 expr_type.display_name(&ctx.heap),
                 InferenceType::partial_display_name(&ctx.heap, template)
+            )
+        )
+    }
     /// Constructs a human interpretable error in the case that type inference
     /// on a polymorphic variable to a function call or literal construction
     /// failed. This may only be caused by a pair of inference types (which may
     /// come from arguments or the return type) having two different inferred
     /// values for that polymorphic variable.
     ///
     /// So we find this pair and construct the error using it.
     ///
     /// We assume that the expression is a function call or a struct literal,
     /// and that an actual error has occurred.
     fn construct_poly_arg_error(
         ctx: &Ctx, poly_data: &ExtraData, expr_id: ExpressionId
     ) -> ParseError {
         // Helper function to check for polymorph mismatch between two inference
         // types.
         fn has_poly_mismatch<'a>(type_a: &'a InferenceType, type_b: &'a InferenceType) -> Option<(u32, &'a [InferenceTypePart], &'a [InferenceTypePart])> {
             if !type_a.has_marker || !type_b.has_marker {
@@ @@ -3671,198 +3681,198 @@ impl PassTyping { @@
                 let poly_section = &poly_vars[marker as usize].parts;
                 if !InferenceType::check_subtrees(poly_section, 0, section, 0) {
                     return Some((marker, poly_section, section))
+                }
+            }
             None
+        }
         // Helpers function to retrieve polyvar name and definition name
         fn get_poly_var_and_definition_name<'a>(ctx: &'a Ctx, poly_var_idx: u32, definition_id: DefinitionId) -> (&'a str, &'a str) {
             let definition = &ctx.heap[definition_id];
             let poly_var = definition.poly_vars()[poly_var_idx as usize].value.as_str();
             let func_name = definition.identifier().value.as_str();
             (poly_var, func_name)
+        }
         // Helper function to construct initial error
         fn construct_main_error(ctx: &Ctx, poly_data: &ExtraData, poly_var_idx: u32, expr: &Expression) -> ParseError {
             match expr {
                 Expression::Call(expr) => {
                     let (poly_var, func_name) = get_poly_var_and_definition_name(ctx, poly_var_idx, poly_data.definition_id);
                     return ParseError::new_error_at_span(
                         &ctx.module.source, expr.func_span, format!(
+                        &ctx.module().source, expr.func_span, format!(
                             "Conflicting type for polymorphic variable '{}' of '{}'",
                             poly_var, func_name
+                        )
+                    )
                 },
                 Expression::Literal(expr) => {
                     let (poly_var, type_name) = get_poly_var_and_definition_name(ctx, poly_var_idx, poly_data.definition_id);
                     return ParseError::new_error_at_span(
                         &ctx.module.source, expr.span, format!(
+                        &ctx.module().source, expr.span, format!(
                             "Conflicting type for polymorphic variable '{}' of instantiation of '{}'",
                             poly_var, type_name
+                        )
                     );
                 },
                 Expression::Select(expr) => {
                     let (poly_var, struct_name) = get_poly_var_and_definition_name(ctx, poly_var_idx, poly_data.definition_id);
                     return ParseError::new_error_at_span(
                         &ctx.module.source, expr.full_span, format!(
+                        &ctx.module().source, expr.full_span, format!(
                             "Conflicting type for polymorphic variable '{}' while accessing field '{}' of '{}'",
                             poly_var, expr.field_name.value.as_str(), struct_name
+                        )
+                    )
+                }
                 _ => unreachable!("called construct_poly_arg_error without an expected expression, got: {:?}", expr)
+            }
+        }
         // Actual checking
         let expr = &ctx.heap[expr_id];
         let (expr_args, expr_return_name) = match expr {
             Expression::Call(expr) =>
+                (
                     expr.arguments.clone(),
                     "return type"
                 ),
             Expression::Literal(expr) => {
                 let expressions = match &expr.value {
                     Literal::Struct(v) => v.fields.iter()
                         .map(|f| f.value)
                         .collect(),
                     Literal::Enum(_) => Vec::new(),
                     Literal::Union(v) => v.values.clone(),
                     _ => unreachable!()
                 };
                 ( expressions, "literal" )
             },
             Expression::Select(expr) =>
                 // Select expression uses the polymorphic variables of the
                 // struct it is accessing, so get the subject expression.
+                (
                     vec![expr.subject],
                     "selected field"
                 ),
             _ => unreachable!(),
         };
         // - check return type with itself
         if let Some((poly_idx, section_a, section_b)) = has_poly_mismatch(
             &poly_data.returned, &poly_data.returned
         ) {
             return construct_main_error(ctx, poly_data, poly_idx, expr)
                 .with_info_at_span(
                     &ctx.module.source, expr.full_span(), format!(
+                    &ctx.module().source, expr.full_span(), format!(
                         "The {} inferred the conflicting types '{}' and '{}'",
                         expr_return_name,
                         InferenceType::partial_display_name(&ctx.heap, section_a),
                         InferenceType::partial_display_name(&ctx.heap, section_b)
+                    )
                 );
+        }
         // - check arguments with each other argument and with return type
         for (arg_a_idx, arg_a) in poly_data.embedded.iter().enumerate() {
             for (arg_b_idx, arg_b) in poly_data.embedded.iter().enumerate() {
                 if arg_b_idx > arg_a_idx {
                     break;
+                }
                 if let Some((poly_idx, section_a, section_b)) = has_poly_mismatch(&arg_a, &arg_b) {
                     let error = construct_main_error(ctx, poly_data, poly_idx, expr);
                     if arg_a_idx == arg_b_idx {
                         // Same argument
                         let arg = &ctx.heap[expr_args[arg_a_idx]];
                         return error.with_info_at_span(
                             &ctx.module.source, arg.full_span(), format!(
+                            &ctx.module().source, arg.full_span(), format!(
                                 "This argument inferred the conflicting types '{}' and '{}'",
                                 InferenceType::partial_display_name(&ctx.heap, section_a),
                                 InferenceType::partial_display_name(&ctx.heap, section_b)
+                            )
                         );
                     } else {
                         let arg_a = &ctx.heap[expr_args[arg_a_idx]];
                         let arg_b = &ctx.heap[expr_args[arg_b_idx]];
                         return error.with_info_at_span(
                             &ctx.module.source, arg_a.full_span(), format!(
+                            &ctx.module().source, arg_a.full_span(), format!(
                                 "This argument inferred it to '{}'",
                                 InferenceType::partial_display_name(&ctx.heap, section_a)
+                            )
                         ).with_info_at_span(
                             &ctx.module.source, arg_b.full_span(), format!(
+                            &ctx.module().source, arg_b.full_span(), format!(
                                 "While this argument inferred it to '{}'",
                                 InferenceType::partial_display_name(&ctx.heap, section_b)
+                            )
+                        )
+                    }
+                }
+            }
             // Check with return type
             if let Some((poly_idx, section_arg, section_ret)) = has_poly_mismatch(arg_a, &poly_data.returned) {
                 let arg = &ctx.heap[expr_args[arg_a_idx]];
                 return construct_main_error(ctx, poly_data, poly_idx, expr)
                     .with_info_at_span(
                         &ctx.module.source, arg.full_span(), format!(
+                        &ctx.module().source, arg.full_span(), format!(
                             "This argument inferred it to '{}'",
                             InferenceType::partial_display_name(&ctx.heap, section_arg)
+                        )
+                    )
                     .with_info_at_span(
                         &ctx.module.source, expr.full_span(), format!(
+                        &ctx.module().source, expr.full_span(), format!(
                             "While the {} inferred it to '{}'",
                             expr_return_name,
                             InferenceType::partial_display_name(&ctx.heap, section_ret)
+                        )
                     );
+            }
+        }
         // Now check against the explicitly specified polymorphic variables (if
         // any).
         for (arg_idx, arg) in poly_data.embedded.iter().enumerate() {
             if let Some((poly_idx, poly_section, arg_section)) = has_explicit_poly_mismatch(&poly_data.poly_vars, arg) {
                 let arg = &ctx.heap[expr_args[arg_idx]];
                 return construct_main_error(ctx, poly_data, poly_idx, expr)
                     .with_info_at_span(
                         &ctx.module.source, arg.full_span(), format!(
+                        &ctx.module().source, arg.full_span(), format!(
                             "The polymorphic variable has type '{}' (which might have been partially inferred) while the argument inferred it to '{}'",
                             InferenceType::partial_display_name(&ctx.heap, poly_section),
                             InferenceType::partial_display_name(&ctx.heap, arg_section)
+                        )
                     );
+            }
+        }
         if let Some((poly_idx, poly_section, ret_section)) = has_explicit_poly_mismatch(&poly_data.poly_vars, &poly_data.returned) {
             return construct_main_error(ctx, poly_data, poly_idx, expr)
                 .with_info_at_span(
                     &ctx.module.source, expr.full_span(), format!(
+                    &ctx.module().source, expr.full_span(), format!(
                         "The polymorphic variable has type '{}' (which might have been partially inferred) while the {} inferred it to '{}'",
                         InferenceType::partial_display_name(&ctx.heap, poly_section),
                         expr_return_name,
                         InferenceType::partial_display_name(&ctx.heap, ret_section)
+                    )
+                )
+        }
         unreachable!("construct_poly_arg_error without actual error found?")
+    }
+}
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::protocol::arena::Id;
     use InferenceTypePart as ITP;
     use InferenceType as IT;
     #[test]
     fn test_single_part_inference() {
         // lhs argument inferred from rhs
         let pairs = [
             (ITP::NumberLike, ITP::UInt8),

src/protocol/parser/pass_validation_linking.rs

➞

Show inline comments

@@ @@ -111,59 +111,59 @@ impl PassValidationLinking { @@
         self.next_expr_index = 0
+    }
+}
 macro_rules! assign_then_erase_next_stmt {
     ($self:ident, $ctx:ident, $stmt_id:expr) => {
         if !$self.prev_stmt.is_invalid() {
             $ctx.heap[$self.prev_stmt].link_next($stmt_id);
             $self.prev_stmt = StatementId::new_invalid();
+        }
+    }
+}
 macro_rules! assign_and_replace_next_stmt {
     ($self:ident, $ctx:ident, $stmt_id:expr) => {
         if !$self.prev_stmt.is_invalid() {
             $ctx.heap[$self.prev_stmt].link_next($stmt_id);
+        }
         $self.prev_stmt = $stmt_id;
+    }
+}
 impl Visitor for PassValidationLinking {
     fn visit_module(&mut self, ctx: &mut Ctx) -> VisitorResult {
         debug_assert_eq!(ctx.module.phase, ModuleCompilationPhase::TypesAddedToTable);
+        debug_assert_eq!(ctx.module().phase, ModuleCompilationPhase::TypesAddedToTable);
         let root = &ctx.heap[ctx.module.root_id];
+        let root = &ctx.heap[ctx.module().root_id];
         let section = self.definition_buffer.start_section_initialized(&root.definitions);
         for definition_idx in 0..section.len() {
             let definition_id = section[definition_idx];
             self.visit_definition(ctx, definition_id)?;
+        }
         section.forget();
-        ctx.module.phase = ModuleCompilationPhase::ValidatedAndLinked;
+        ctx.module_mut().phase = ModuleCompilationPhase::ValidatedAndLinked;
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Definition visitors
     //--------------------------------------------------------------------------
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {
         self.reset_state();
         self.def_type = match &ctx.heap[id].variant {
             ComponentVariant::Primitive => DefinitionType::Primitive(id),
             ComponentVariant::Composite => DefinitionType::Composite(id),
         };
         self.cur_scope = Scope::Definition(id.upcast());
         self.expr_parent = ExpressionParent::None;
         // Visit parameters and assign a unique scope ID
         let definition = &ctx.heap[id];
         let body_id = definition.body;
         let section = self.variable_buffer.start_section_initialized(&definition.parameters);
         for variable_idx in 0..section.len() {
             let variable_id = section[variable_idx];
             let variable = &mut ctx.heap[variable_id];
             variable.unique_id_in_scope = variable_idx as i32;
@@ @@ -322,421 +322,424 @@ impl Visitor for PassValidationLinking { @@
     fn visit_continue_stmt(&mut self, ctx: &mut Ctx, id: ContinueStatementId) -> VisitorResult {
         // Resolve continue target
         let target_while_id = {
             let stmt = &ctx.heap[id];
             self.resolve_break_or_continue_target(ctx, stmt.span, &stmt.label)?
         };
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         let stmt = &mut ctx.heap[id];
         stmt.target = Some(target_while_id);
         Ok(())
+    }
     fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {
         // Check for validity of synchronous statement
         let sync_stmt = &ctx.heap[id];
         let end_sync_id = sync_stmt.end_sync;
         let cur_sync_span = sync_stmt.span;
         if !self.in_sync.is_invalid() {
             // Nested synchronous statement
             let old_sync_span = ctx.heap[self.in_sync].span;
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, cur_sync_span, "Illegal nested synchronous statement"
+                &ctx.module().source, cur_sync_span, "Illegal nested synchronous statement"
             ).with_info_str_at_span(
                 &ctx.module.source, old_sync_span, "It is nested in this synchronous statement"
+                &ctx.module().source, old_sync_span, "It is nested in this synchronous statement"
             ));
+        }
         if !self.def_type.is_primitive() {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, cur_sync_span,
+                &ctx.module().source, cur_sync_span,
                 "synchronous statements may only be used in primitive components"
             ));
+        }
         // Synchronous statement implicitly moves to its block
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         let sync_body = ctx.heap[id].body;
         debug_assert!(self.in_sync.is_invalid());
         self.in_sync = id;
         self.visit_block_stmt_with_hint(ctx, sync_body, Some(id))?;
         assign_and_replace_next_stmt!(self, ctx, end_sync_id.upcast());
         self.in_sync = SynchronousStatementId::new_invalid();
         Ok(())
+    }
     fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {
         // Check if "return" occurs within a function
         let stmt = &ctx.heap[id];
         if !self.def_type.is_function() {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, stmt.span,
+                &ctx.module().source, stmt.span,
                 "return statements may only appear in function bodies"
             ));
+        }
         // If here then we are within a function
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         debug_assert_eq!(ctx.heap[id].expressions.len(), 1);
         self.expr_parent = ExpressionParent::Return(id);
         self.visit_expr(ctx, ctx.heap[id].expressions[0])?;
         self.expr_parent = ExpressionParent::None;
         Ok(())
+    }
     fn visit_goto_stmt(&mut self, ctx: &mut Ctx, id: GotoStatementId) -> VisitorResult {
         let target_id = self.find_label(ctx, &ctx.heap[id].label)?;
         ctx.heap[id].target = Some(target_id);
         let target = &ctx.heap[target_id];
         if self.in_sync != target.in_sync {
             // We can only goto the current scope or outer scopes. Because
             // nested sync statements are not allowed we must be inside a sync
             // statement.
             debug_assert!(!self.in_sync.is_invalid());
             let goto_stmt = &ctx.heap[id];
             let sync_stmt = &ctx.heap[self.in_sync];
             return Err(
                 ParseError::new_error_str_at_span(&ctx.module.source, goto_stmt.span, "goto may not escape the surrounding synchronous block")
                 .with_info_str_at_span(&ctx.module.source, target.label.span, "this is the target of the goto statement")
                 .with_info_str_at_span(&ctx.module.source, sync_stmt.span, "which will jump past this statement")
                 ParseError::new_error_str_at_span(&ctx.module().source, goto_stmt.span, "goto may not escape the surrounding synchronous block")
                 .with_info_str_at_span(&ctx.module().source, target.label.span, "this is the target of the goto statement")
                 .with_info_str_at_span(&ctx.module().source, sync_stmt.span, "which will jump past this statement")
             );
+        }
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         Ok(())
+    }
     fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {
         // Make sure the new statement occurs inside a composite component
         if !self.def_type.is_composite() {
             let new_stmt = &ctx.heap[id];
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, new_stmt.span,
+                &ctx.module().source, new_stmt.span,
                 "instantiating components may only be done in composite components"
             ));
+        }
         // Recurse into call expression (which will check the expression parent
         // to ensure that the "new" statment instantiates a component)
         let call_expr_id = ctx.heap[id].expression;
         assign_and_replace_next_stmt!(self, ctx, id.upcast());
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         self.expr_parent = ExpressionParent::New(id);
         self.visit_call_expr(ctx, call_expr_id)?;
         self.expr_parent = ExpressionParent::None;
         Ok(())
+    }
     fn visit_expr_stmt(&mut self, ctx: &mut Ctx, id: ExpressionStatementId) -> VisitorResult {
         let expr_id = ctx.heap[id].expression;
         assign_and_replace_next_stmt!(self, ctx, id.upcast());
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         self.expr_parent = ExpressionParent::ExpressionStmt(id);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = ExpressionParent::None;
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Expression visitors
     //--------------------------------------------------------------------------
     fn visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let assignment_expr = &mut ctx.heap[id];
         // Although we call assignment an expression to simplify the compiler's
         // code (mainly typechecking), we disallow nested use in expressions
         match self.expr_parent {
             // Look at us: lying through our teeth while providing error messages.
             ExpressionParent::ExpressionStmt(_) => {},
             _ => return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, assignment_expr.full_span,
                 "assignments are statements, and cannot be used in expressions"
             )),
             _ => {
                 let assignment_span = assignment_expr.full_span;
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, assignment_span,
                     "assignments are statements, and cannot be used in expressions"
                 ))
             },
+        }
         let left_expr_id = assignment_expr.left;
         let right_expr_id = assignment_expr.right;
         let old_expr_parent = self.expr_parent;
         assignment_expr.parent = old_expr_parent;
         assignment_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.must_be_assignable = Some(assignment_expr.operator_span);
         self.visit_expr(ctx, left_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.must_be_assignable = None;
         self.visit_expr(ctx, right_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_binding_expr(&mut self, ctx: &mut Ctx, id: BindingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         // Check for valid context of binding expression
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, span, "cannot assign to the result from a binding expression"
+                &ctx.module().source, span, "cannot assign to the result from a binding expression"
             ));
+        }
         if self.in_test_expr.is_invalid() {
             let binding_expr = &ctx.heap[id];
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, binding_expr.full_span,
+                &ctx.module().source, binding_expr.full_span,
                 "binding expressions can only be used inside the testing expression of 'if' and 'while' statements"
             ));
+        }
         if !self.in_binding_expr.is_invalid() {
             let binding_expr = &ctx.heap[id];
             let previous_expr = &ctx.heap[self.in_binding_expr];
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, binding_expr.full_span,
+                &ctx.module().source, binding_expr.full_span,
                 "nested binding expressions are not allowed"
             ).with_info_str_at_span(
                 &ctx.module.source, previous_expr.operator_span,
+                &ctx.module().source, previous_expr.operator_span,
                 "the outer binding expression is found here"
             ));
+        }
         let mut seeking_parent = self.expr_parent;
         loop {
             // Perform upward search to make sure only LogicalAnd is applied to
             // the binding expression
             let valid = match seeking_parent {
                 ExpressionParent::If(_) | ExpressionParent::While(_) => {
                     // Every parent expression (if any) were LogicalAnd.
                     break;
+                }
                 ExpressionParent::Expression(parent_id, _) => {
                     let parent_expr = &ctx.heap[parent_id];
                     match parent_expr {
                         Expression::Binary(parent_expr) => {
                             // Set new parent to continue the search. Otherwise
                             // halt and provide an error using the current
                             // parent.
                             if parent_expr.operation == BinaryOperator::LogicalAnd {
                                 seeking_parent = parent_expr.parent;
                                 true
                             } else {
                                 false
+                            }
                         },
                         _ => false,
+                    }
                 },
                 _ => unreachable!(), // nested under if/while, so always expressions as parents
             };
             if !valid {
                 let binding_expr = &ctx.heap[id];
                 let parent_expr = &ctx.heap[seeking_parent.as_expression()];
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module.source, binding_expr.full_span,
+                    &ctx.module().source, binding_expr.full_span,
                     "only the logical-and operator (&&) may be applied to binding expressions"
                 ).with_info_str_at_span(
                     &ctx.module.source, parent_expr.operation_span(),
+                    &ctx.module().source, parent_expr.operation_span(),
                     "this was the disallowed operation applied to the result from a binding expression"
                 ));
+            }
+        }
         // Perform all of the index/parent assignment magic
         let binding_expr = &mut ctx.heap[id];
         let old_expr_parent = self.expr_parent;
         binding_expr.parent = old_expr_parent;
         binding_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         self.in_binding_expr = id;
         // Perform preliminary check on children: binding expressions only make
         // sense if the left hand side is just a variable expression, or if it
         // is a literal of some sort. The typechecker will take care of the rest
         let bound_to_id = binding_expr.bound_to;
         let bound_from_id = binding_expr.bound_from;
         match &ctx.heap[bound_to_id] {
             // Variables may not be binding variables, and literals may
             // actually not contain binding variables. But in that case we just
             // perform an equality check.
             Expression::Variable(_) => {}
             Expression::Literal(_) => {},
             _ => {
                 let binding_expr = &ctx.heap[id];
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module.source, binding_expr.operator_span,
+                    &ctx.module().source, binding_expr.operator_span,
                     "the left hand side of a binding expression may only be a variable or a literal expression"
                 ));
             },
+        }
         // Visit the children themselves
         self.in_binding_expr_lhs = true;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, bound_to_id)?;
         self.in_binding_expr_lhs = false;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, bound_from_id)?;
         self.expr_parent = old_expr_parent;
         self.in_binding_expr = BindingExpressionId::new_invalid();
         Ok(())
+    }
     fn visit_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let conditional_expr = &mut ctx.heap[id];
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, span, "cannot assign to the result from a conditional expression"
+                &ctx.module().source, span, "cannot assign to the result from a conditional expression"
             ))
+        }
         let test_expr_id = conditional_expr.test;
         let true_expr_id = conditional_expr.true_expression;
         let false_expr_id = conditional_expr.false_expression;
         let old_expr_parent = self.expr_parent;
         conditional_expr.parent = old_expr_parent;
         conditional_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, test_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, true_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 2);
         self.visit_expr(ctx, false_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let binary_expr = &mut ctx.heap[id];
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, span, "cannot assign to the result from a binary expression"
+                &ctx.module().source, span, "cannot assign to the result from a binary expression"
             ))
+        }
         let left_expr_id = binary_expr.left;
         let right_expr_id = binary_expr.right;
         let old_expr_parent = self.expr_parent;
         binary_expr.parent = old_expr_parent;
         binary_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, left_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, right_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> VisitorResult {
         let unary_expr = &mut ctx.heap[id];
         let expr_id = unary_expr.expression;
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, span, "cannot assign to the result from a unary expression"
+                &ctx.module().source, span, "cannot assign to the result from a unary expression"
             ))
+        }
         let old_expr_parent = self.expr_parent;
         unary_expr.parent = old_expr_parent;
         unary_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         self.expr_parent = ExpressionParent::Expression(id.upcast(), 0);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let indexing_expr = &mut ctx.heap[id];
         let subject_expr_id = indexing_expr.subject;
         let index_expr_id = indexing_expr.index;
         let old_expr_parent = self.expr_parent;
         indexing_expr.parent = old_expr_parent;
         indexing_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, subject_expr_id)?;
         let old_assignable = self.must_be_assignable.take();
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, index_expr_id)?;
         self.must_be_assignable = old_assignable;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let slicing_expr = &mut ctx.heap[id];
         if let Some(span) = self.must_be_assignable {
             // TODO: @Slicing
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, span, "assignment to slices should be valid in the final language, but is currently not implemented"
+                &ctx.module().source, span, "assignment to slices should be valid in the final language, but is currently not implemented"
             ));
+        }
         let subject_expr_id = slicing_expr.subject;
         let from_expr_id = slicing_expr.from_index;
         let to_expr_id = slicing_expr.to_index;
         let old_expr_parent = self.expr_parent;
         slicing_expr.parent = old_expr_parent;
         slicing_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, subject_expr_id)?;
         let old_assignable = self.must_be_assignable.take();
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, from_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 2);
         self.visit_expr(ctx, to_expr_id)?;
         self.must_be_assignable = old_assignable;
         self.expr_parent = old_expr_parent;
@@ @@ -747,442 +750,455 @@ impl Visitor for PassValidationLinking { @@
         let select_expr = &mut ctx.heap[id];
         let expr_id = select_expr.subject;
         let old_expr_parent = self.expr_parent;
         select_expr.parent = old_expr_parent;
         select_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         self.expr_parent = ExpressionParent::Expression(id.upcast(), 0);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> VisitorResult {
         let literal_expr = &mut ctx.heap[id];
         let old_expr_parent = self.expr_parent;
         literal_expr.parent = old_expr_parent;
         literal_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, span, "cannot assign to a literal expression"
+                &ctx.module().source, span, "cannot assign to a literal expression"
             ))
+        }
         match &mut literal_expr.value {
             Literal::Null | Literal::True | Literal::False |
             Literal::Character(_) | Literal::String(_) | Literal::Integer(_) => {
                 // Just the parent has to be set, done above
             },
             Literal::Struct(literal) => {
                 let upcast_id = id.upcast();
                 // Retrieve type definition
                 let type_definition = ctx.types.get_base_definition(&literal.definition).unwrap();
                 let struct_definition = type_definition.definition.as_struct();
                 // Make sure all fields are specified, none are specified twice
                 // and all fields exist on the struct definition
                 let mut specified = Vec::new(); // TODO: @performance
                 specified.resize(struct_definition.fields.len(), false);
                 for field in &mut literal.fields {
                     // Find field in the struct definition
                     let field_idx = struct_definition.fields.iter().position(|v| v.identifier == field.identifier);
                     if field_idx.is_none() {
                         let field_span = field.identifier.span;
                         let literal = ctx.heap[id].value.as_struct();
                         let ast_definition = &ctx.heap[literal.definition];
                         return Err(ParseError::new_error_at_span(
                             &ctx.module.source, field_span, format!(
+                            &ctx.module().source, field_span, format!(
                                 "This field does not exist on the struct '{}'",
                                 ast_definition.identifier().value.as_str()
+                            )
                         ));
+                    }
                     field.field_idx = field_idx.unwrap();
                     // Check if specified more than once
                     if specified[field.field_idx] {
                         let field_span = field.identifier.span;
                         return Err(ParseError::new_error_str_at_span(
-                            &ctx.module.source, field.identifier.span,
+                            &ctx.module().source, field_span,
                             "This field is specified more than once"
                         ));
+                    }
                     specified[field.field_idx] = true;
+                }
                 if !specified.iter().all(|v| *v) {
                     // Some fields were not specified
                     let mut not_specified = String::new();
                     let mut num_not_specified = 0;
                     for (def_field_idx, is_specified) in specified.iter().enumerate() {
                         if !is_specified {
                             if !not_specified.is_empty() { not_specified.push_str(", ") }
                             let field_ident = &struct_definition.fields[def_field_idx].identifier;
                             not_specified.push_str(field_ident.value.as_str());
                             num_not_specified += 1;
+                        }
+                    }
                     debug_assert!(num_not_specified > 0);
                     let msg = if num_not_specified == 1 {
                         format!("not all fields are specified, '{}' is missing", not_specified)
                     } else {
                         format!("not all fields are specified, [{}] are missing", not_specified)
                     };
                     let literal_span = literal.parser_type.full_span;
                     return Err(ParseError::new_error_at_span(
-                        &ctx.module.source, literal.parser_type.full_span, msg
+                        &ctx.module().source, literal_span, msg
                     ));
+                }
                 // Need to traverse fields expressions in struct and evaluate
                 // the poly args
                 let mut expr_section = self.expression_buffer.start_section();
                 for field in &literal.fields {
                     expr_section.push(field.value);
+                }
                 for expr_idx in 0..expr_section.len() {
                     let expr_id = expr_section[expr_idx];
                     self.expr_parent = ExpressionParent::Expression(upcast_id, expr_idx as u32);
                     self.visit_expr(ctx, expr_id)?;
+                }
                 expr_section.forget();
             },
             Literal::Enum(literal) => {
                 // Make sure the variant exists
                 let type_definition = ctx.types.get_base_definition(&literal.definition).unwrap();
                 let enum_definition = type_definition.definition.as_enum();
                 let variant_idx = enum_definition.variants.iter().position(|v| {
                     v.identifier == literal.variant
                 });
                 if variant_idx.is_none() {
                     let literal = ctx.heap[id].value.as_enum();
                     let ast_definition = ctx.heap[literal.definition].as_enum();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, literal.parser_type.full_span, format!(
+                        &ctx.module().source, literal.parser_type.full_span, format!(
                             "the variant '{}' does not exist on the enum '{}'",
                             literal.variant.value.as_str(), ast_definition.identifier.value.as_str()
+                        )
                     ));
+                }
                 literal.variant_idx = variant_idx.unwrap();
             },
             Literal::Union(literal) => {
                 // Make sure the variant exists
                 let type_definition = ctx.types.get_base_definition(&literal.definition).unwrap();
                 let union_definition = type_definition.definition.as_union();
                 let variant_idx = union_definition.variants.iter().position(|v| {
                     v.identifier == literal.variant
                 });
                 if variant_idx.is_none() {
                     let literal = ctx.heap[id].value.as_union();
                     let ast_definition = ctx.heap[literal.definition].as_union();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, literal.parser_type.full_span, format!(
+                        &ctx.module().source, literal.parser_type.full_span, format!(
                             "the variant '{}' does not exist on the union '{}'",
                             literal.variant.value.as_str(), ast_definition.identifier.value.as_str()
+                        )
                     ));
+                }
                 literal.variant_idx = variant_idx.unwrap();
                 // Make sure the number of specified values matches the expected
                 // number of embedded values in the union variant.
                 let union_variant = &union_definition.variants[literal.variant_idx];
                 if union_variant.embedded.len() != literal.values.len() {
                     let literal = ctx.heap[id].value.as_union();
                     let ast_definition = ctx.heap[literal.definition].as_union();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, literal.parser_type.full_span, format!(
+                        &ctx.module().source, literal.parser_type.full_span, format!(
                             "The variant '{}' of union '{}' expects {} embedded values, but {} were specified",
                             literal.variant.value.as_str(), ast_definition.identifier.value.as_str(),
                             union_variant.embedded.len(), literal.values.len()
                         ),
                     ))
+                }
                 // Traverse embedded values of union (if any) and evaluate the
                 // polymorphic arguments
                 let upcast_id = id.upcast();
                 let mut expr_section = self.expression_buffer.start_section();
                 for value in &literal.values {
                     expr_section.push(*value);
+                }
                 for expr_idx in 0..expr_section.len() {
                     let expr_id = expr_section[expr_idx];
                     self.expr_parent = ExpressionParent::Expression(upcast_id, expr_idx as u32);
                     self.visit_expr(ctx, expr_id)?;
+                }
                 expr_section.forget();
             },
             Literal::Array(literal) => {
                 // Visit all expressions in the array
                 let upcast_id = id.upcast();
                 let expr_section = self.expression_buffer.start_section_initialized(literal);
                 for expr_idx in 0..expr_section.len() {
                     let expr_id = expr_section[expr_idx];
                     self.expr_parent = ExpressionParent::Expression(upcast_id, expr_idx as u32);
                     self.visit_expr(ctx, expr_id)?;
+                }
                 expr_section.forget();
+            }
+        }
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_cast_expr(&mut self, ctx: &mut Ctx, id: CastExpressionId) -> VisitorResult {
         let cast_expr = &mut ctx.heap[id];
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, span, "cannot assign to the result from a cast expression"
+                &ctx.module().source, span, "cannot assign to the result from a cast expression"
             ))
+        }
         let upcast_id = id.upcast();
         let old_expr_parent = self.expr_parent;
         cast_expr.parent = old_expr_parent;
         cast_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         // Recurse into the thing that we're casting
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         let subject_id = cast_expr.subject;
         self.visit_expr(ctx, subject_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {
         let call_expr = &mut ctx.heap[id];
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, span, "cannot assign to the result from a call expression"
+                &ctx.module().source, span, "cannot assign to the result from a call expression"
             ))
+        }
         // Check whether the method is allowed to be called within the code's
         // context (in sync, definition type, etc.)
         let mut expected_wrapping_new_stmt = false;
         match &mut call_expr.method {
             Method::Get => {
                 if !self.def_type.is_primitive() {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
-                        &ctx.module.source, call_expr.func_span,
+                        &ctx.module().source, call_span,
                         "a call to 'get' may only occur in primitive component definitions"
                     ));
+                }
                 if self.in_sync.is_invalid() {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
-                        &ctx.module.source, call_expr.func_span,
+                        &ctx.module().source, call_span,
                         "a call to 'get' may only occur inside synchronous blocks"
                     ));
+                }
             },
             Method::Put => {
                 if !self.def_type.is_primitive() {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
-                        &ctx.module.source, call_expr.func_span,
+                        &ctx.module().source, call_span,
                         "a call to 'put' may only occur in primitive component definitions"
                     ));
+                }
                 if self.in_sync.is_invalid() {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
-                        &ctx.module.source, call_expr.func_span,
+                        &ctx.module().source, call_span,
                         "a call to 'put' may only occur inside synchronous blocks"
                     ));
+                }
             },
             Method::Fires => {
                 if !self.def_type.is_primitive() {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
-                        &ctx.module.source, call_expr.func_span,
+                        &ctx.module().source, call_span,
                         "a call to 'fires' may only occur in primitive component definitions"
                     ));
+                }
                 if self.in_sync.is_invalid() {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
-                        &ctx.module.source, call_expr.func_span,
+                        &ctx.module().source, call_span,
                         "a call to 'fires' may only occur inside synchronous blocks"
                     ));
+                }
             },
             Method::Create => {},
             Method::Length => {},
             Method::Assert => {
                 if self.def_type.is_function() {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
-                        &ctx.module.source, call_expr.func_span,
+                        &ctx.module().source, call_span,
                         "assert statement may only occur in components"
                     ));
+                }
                 if self.in_sync.is_invalid() {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
-                        &ctx.module.source, call_expr.func_span,
+                        &ctx.module().source, call_span,
                         "assert statements may only occur inside synchronous blocks"
                     ));
+                }
             },
             Method::UserFunction => {},
             Method::UserComponent => {
                 expected_wrapping_new_stmt = true;
             },
+        }
         if expected_wrapping_new_stmt {
             if !self.expr_parent.is_new() {
                 let call_span = call_expr.func_span;
                 return Err(ParseError::new_error_str_at_span(
-                    &ctx.module.source, call_expr.func_span,
+                    &ctx.module().source, call_span,
                     "cannot call a component, it can only be instantiated by using 'new'"
                 ));
+            }
         } else {
             if self.expr_parent.is_new() {
                 let call_span = call_expr.func_span;
                 return Err(ParseError::new_error_str_at_span(
-                    &ctx.module.source, call_expr.func_span,
+                    &ctx.module().source, call_span,
                     "only components can be instantiated, this is a function"
                 ));
+            }
+        }
         // Check the number of arguments
         let call_definition = ctx.types.get_base_definition(&call_expr.definition).unwrap();
         let num_expected_args = match &call_definition.definition {
             DefinedTypeVariant::Function(definition) => definition.arguments.len(),
             DefinedTypeVariant::Component(definition) => definition.arguments.len(),
             v => unreachable!("encountered {} type in call expression", v.type_class()),
         };
         let num_provided_args = call_expr.arguments.len();
         if num_provided_args != num_expected_args {
             let argument_text = if num_expected_args == 1 { "argument" } else { "arguments" };
             let call_span = call_expr.full_span;
             return Err(ParseError::new_error_at_span(
-                &ctx.module.source, call_expr.full_span, format!(
+                &ctx.module().source, call_span, format!(
                     "expected {} {}, but {} were provided",
                     num_expected_args, argument_text, num_provided_args
+                )
             ));
+        }
         // Recurse into all of the arguments and set the expression's parent
         let upcast_id = id.upcast();
         let section = self.expression_buffer.start_section_initialized(&call_expr.arguments);
         let old_expr_parent = self.expr_parent;
         call_expr.parent = old_expr_parent;
         call_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         for arg_expr_idx in 0..section.len() {
             let arg_expr_id = section[arg_expr_idx];
             self.expr_parent = ExpressionParent::Expression(upcast_id, arg_expr_idx as u32);
             self.visit_expr(ctx, arg_expr_id)?;
+        }
         section.forget();
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {
         let var_expr = &ctx.heap[id];
         let (variable_id, is_binding_target) = match self.find_variable(ctx, self.relative_pos_in_block, &var_expr.identifier) {
             Ok(variable_id) => {
                 // Regular variable
                 (variable_id, false)
             },
             Err(()) => {
                 // Couldn't find variable, but if we're in a binding expression,
                 // then this may be the thing we're binding to.
                 if self.in_binding_expr.is_invalid() || !self.in_binding_expr_lhs {
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, var_expr.identifier.span, "unresolved variable"
+                        &ctx.module().source, var_expr.identifier.span, "unresolved variable"
                     ));
+                }
                 // This is a binding variable, but it may only appear in very
                 // specific locations.
                 let is_valid_binding = match self.expr_parent {
                     ExpressionParent::Expression(expr_id, idx) => {
                         match &ctx.heap[expr_id] {
                             Expression::Binding(_binding_expr) => {
                                 // Nested binding is disallowed, and because of
                                 // the check above we know we're directly at the
                                 // LHS of the binding expression
                                 debug_assert_eq!(_binding_expr.this, self.in_binding_expr);
                                 debug_assert_eq!(idx, 0);
                                 true
+                            }
                             Expression::Literal(lit_expr) => {
                                 // Only struct, unions and arrays can have
                                 // subexpressions, so we're always fine
                                 if cfg!(debug_assertions) {
                                     match lit_expr.value {
                                         Literal::Struct(_) | Literal::Union(_) | Literal::Array(_) => {},
                                         _ => unreachable!(),
+                                    }
+                                }
                                 true
                             },
                             _ => false,
+                        }
                     },
                     _ => {
                         false
+                    }
                 };
                 if !is_valid_binding {
                     let binding_expr = &ctx.heap[self.in_binding_expr];
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, var_expr.identifier.span,
+                        &ctx.module().source, var_expr.identifier.span,
                         "illegal location for binding variable: binding variables may only be nested under a binding expression, or a struct, union or array literal"
                     ).with_info_at_span(
                         &ctx.module.source, binding_expr.operator_span, format!(
+                        &ctx.module().source, binding_expr.operator_span, format!(
                             "'{}' was interpreted as a binding variable because the variable is not declared and it is nested under this binding expression",
                             var_expr.identifier.value.as_str()
+                        )
                     ));
+                }
                 // By now we know that this is a valid binding expression. Given
                 // that a binding expression must be nested under an if/while
                 // statement, we now add the variable to the (implicit) block
                 // statement following the if/while statement.
                 let bound_identifier = var_expr.identifier.clone();
                 let bound_variable_id = ctx.heap.alloc_variable(|this| Variable{
                     this,
                     kind: VariableKind::Binding,
                     parser_type: ParserType{
                         elements: vec![ParserTypeElement{
                             element_span: bound_identifier.span,
                             variant: ParserTypeVariant::Inferred
                         }],
                         full_span: bound_identifier.span
                     },
                     identifier: bound_identifier,
                     relative_pos_in_block: 0,
                     unique_id_in_scope: -1,
@@ @@ -1395,123 +1411,123 @@ impl PassValidationLinking { @@
     //--------------------------------------------------------------------------
     // Utilities
     //--------------------------------------------------------------------------
     /// Adds a local variable to the current scope. It will also annotate the
     /// `Local` in the AST with its relative position in the block.
     fn checked_add_local(&mut self, ctx: &mut Ctx, relative_pos: u32, id: VariableId) -> Result<(), ParseError> {
         debug_assert!(self.cur_scope.is_block());
         let local = &ctx.heap[id];
         let mut scope = &self.cur_scope;
         loop {
             // We immediately go to the parent scope. We check the current scope
             // in the call at the end. Likewise for checking the symbol table.
             let block = &ctx.heap[scope.to_block()];
             scope = &block.scope_node.parent;
             if let Scope::Definition(definition_id) = scope {
                 // At outer scope, check parameters of function/component
                 for parameter_id in ctx.heap[*definition_id].parameters() {
                     let parameter = &ctx.heap[*parameter_id];
                     if local.identifier == parameter.identifier {
                         return Err(
                             ParseError::new_error_str_at_span(
                                 &ctx.module.source, local.identifier.span, "Local variable name conflicts with parameter"
+                                &ctx.module().source, local.identifier.span, "Local variable name conflicts with parameter"
                             ).with_info_str_at_span(
                                 &ctx.module.source, parameter.identifier.span, "Parameter definition is found here"
+                                &ctx.module().source, parameter.identifier.span, "Parameter definition is found here"
+                            )
                         );
+                    }
+                }
                 // No collisions
                 break;
+            }
             // If here then the parent scope is a block scope
             let local_relative_pos = ctx.heap[scope.to_block()].relative_pos_in_parent;
             for other_local_id in &block.locals {
                 let other_local = &ctx.heap[*other_local_id];
                 // Position check in case another variable with the same name
                 // is defined in a higher-level scope, but later than the scope
                 // in which the current variable resides.
                 if local.this != *other_local_id &&
                     local_relative_pos >= other_local.relative_pos_in_block &&
                     local.identifier == other_local.identifier {
                     // Collision within this scope
                     return Err(
                         ParseError::new_error_str_at_span(
                             &ctx.module.source, local.identifier.span, "Local variable name conflicts with another variable"
+                            &ctx.module().source, local.identifier.span, "Local variable name conflicts with another variable"
                         ).with_info_str_at_span(
                             &ctx.module.source, other_local.identifier.span, "Previous variable is found here"
+                            &ctx.module().source, other_local.identifier.span, "Previous variable is found here"
+                        )
                     );
+                }
+            }
+        }
         // No collisions in any of the parent scope, attempt to add to scope
         self.checked_at_single_scope_add_local(ctx, self.cur_scope, relative_pos, id)
+    }
     /// Adds a local variable to the specified scope. Will check the specified
     /// scope for variable conflicts and the symbol table for global conflicts.
     /// Will NOT check parent scopes of the specified scope.
     fn checked_at_single_scope_add_local(
         &mut self, ctx: &mut Ctx, scope: Scope, relative_pos: u32, id: VariableId
     ) -> Result<(), ParseError> {
         // Check the symbol table for conflicts
+        {
             let cur_scope = SymbolScope::Definition(self.def_type.definition_id());
             let ident = &ctx.heap[id].identifier;
             if let Some(symbol) = ctx.symbols.get_symbol_by_name(cur_scope, &ident.value.as_bytes()) {
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module.source, ident.span,
+                    &ctx.module().source, ident.span,
                     "local variable declaration conflicts with symbol"
                 ).with_info_str_at_span(
                     &ctx.module.source, symbol.variant.span_of_introduction(&ctx.heap), "the conflicting symbol is introduced here"
+                    &ctx.module().source, symbol.variant.span_of_introduction(&ctx.heap), "the conflicting symbol is introduced here"
                 ));
+            }
+        }
         // Check the specified scope for conflicts
         let local = &ctx.heap[id];
         debug_assert!(scope.is_block());
         let block = &ctx.heap[scope.to_block()];
         for other_local_id in &block.locals {
             let other_local = &ctx.heap[*other_local_id];
             if local.this != other_local.this &&
                 relative_pos >= other_local.relative_pos_in_block &&
                 local.identifier == other_local.identifier {
                 // Collision
                 return Err(
                     ParseError::new_error_str_at_span(
                         &ctx.module.source, local.identifier.span, "Local variable name conflicts with another variable"
+                        &ctx.module().source, local.identifier.span, "Local variable name conflicts with another variable"
                     ).with_info_str_at_span(
                         &ctx.module.source, other_local.identifier.span, "Previous variable is found here"
+                        &ctx.module().source, other_local.identifier.span, "Previous variable is found here"
+                    )
                 );
+            }
+        }
         // No collisions
         let block = &mut ctx.heap[scope.to_block()];
         block.locals.push(id);
         let local = &mut ctx.heap[id];
         local.relative_pos_in_block = relative_pos;
         Ok(())
+    }
     /// Finds a variable in the visitor's scope that must appear before the
     /// specified relative position within that block.
     fn find_variable(&self, ctx: &Ctx, mut relative_pos: u32, identifier: &Identifier) -> Result<VariableId, ()> {
         debug_assert!(self.cur_scope.is_block());
         // No need to use iterator over namespaces if here
         let mut scope = &self.cur_scope;
         loop {
@@ @@ -1551,173 +1567,173 @@ impl PassValidationLinking { @@
+    }
     /// Adds a particular label to the current scope. Will return an error if
     /// there is another label with the same name visible in the current scope.
     fn checked_add_label(&mut self, ctx: &mut Ctx, relative_pos: u32, in_sync: SynchronousStatementId, id: LabeledStatementId) -> Result<(), ParseError> {
         debug_assert!(self.cur_scope.is_block());
         // Make sure label is not defined within the current scope or any of the
         // parent scope.
         let label = &mut ctx.heap[id];
         label.relative_pos_in_block = relative_pos;
         label.in_sync = in_sync;
         let label = &ctx.heap[id];
         let mut scope = &self.cur_scope;
         loop {
             debug_assert!(scope.is_block(), "scope is not a block");
             let block = &ctx.heap[scope.to_block()];
             for other_label_id in &block.labels {
                 let other_label = &ctx.heap[*other_label_id];
                 if other_label.label == label.label {
                     // Collision
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, label.label.span, "label name is used more than once"
+                        &ctx.module().source, label.label.span, "label name is used more than once"
                     ).with_info_str_at_span(
                         &ctx.module.source, other_label.label.span, "the other label is found here"
+                        &ctx.module().source, other_label.label.span, "the other label is found here"
                     ));
+                }
+            }
             scope = &block.scope_node.parent;
             if !scope.is_block() {
                 break;
+            }
+        }
         // No collisions
         let block = &mut ctx.heap[self.cur_scope.to_block()];
         block.labels.push(id);
         Ok(())
+    }
     /// Finds a particular labeled statement by its identifier. Once found it
     /// will make sure that the target label does not skip over any variable
     /// declarations within the scope in which the label was found.
     fn find_label(&self, ctx: &Ctx, identifier: &Identifier) -> Result<LabeledStatementId, ParseError> {
         debug_assert!(self.cur_scope.is_block());
         let mut scope = &self.cur_scope;
         loop {
             debug_assert!(scope.is_block(), "scope is not a block");
             let relative_scope_pos = ctx.heap[scope.to_block()].relative_pos_in_parent;
             let block = &ctx.heap[scope.to_block()];
             for label_id in &block.labels {
                 let label = &ctx.heap[*label_id];
                 if label.label == *identifier {
                     for local_id in &block.locals {
                         // TODO: Better to do this in control flow analysis, it
                         //  is legal to skip over a variable declaration if it
                         //  is not actually being used. I might be missing
                         //  something here when laying out the bytecode...
                         let local = &ctx.heap[*local_id];
                         if local.relative_pos_in_block > relative_scope_pos && local.relative_pos_in_block < label.relative_pos_in_block {
                             return Err(
                                 ParseError::new_error_str_at_span(&ctx.module.source, identifier.span, "this target label skips over a variable declaration")
                                 .with_info_str_at_span(&ctx.module.source, label.label.span, "because it jumps to this label")
                                 .with_info_str_at_span(&ctx.module.source, local.identifier.span, "which skips over this variable")
                                 ParseError::new_error_str_at_span(&ctx.module().source, identifier.span, "this target label skips over a variable declaration")
                                 .with_info_str_at_span(&ctx.module().source, label.label.span, "because it jumps to this label")
                                 .with_info_str_at_span(&ctx.module().source, local.identifier.span, "which skips over this variable")
                             );
+                        }
+                    }
                     return Ok(*label_id);
+                }
+            }
             scope = &block.scope_node.parent;
             if !scope.is_block() {
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module.source, identifier.span, "could not find this label"
+                    &ctx.module().source, identifier.span, "could not find this label"
                 ));
+            }
+        }
+    }
     /// This function will check if the provided while statement ID has a block
     /// statement that is one of our current parents.
     fn has_parent_while_scope(&self, ctx: &Ctx, id: WhileStatementId) -> bool {
         let mut scope = &self.cur_scope;
         let while_stmt = &ctx.heap[id];
         loop {
             debug_assert!(scope.is_block());
             let block = scope.to_block();
             if while_stmt.body == block {
                 return true;
+            }
             let block = &ctx.heap[block];
             scope = &block.scope_node.parent;
             if !scope.is_block() {
                 return false;
+            }
+        }
+    }
     /// This function should be called while dealing with break/continue
     /// statements. It will try to find the targeted while statement, using the
     /// target label if provided. If a valid target is found then the loop's
     /// ID will be returned, otherwise a parsing error is constructed.
     /// The provided input position should be the position of the break/continue
     /// statement.
     fn resolve_break_or_continue_target(&self, ctx: &Ctx, span: InputSpan, label: &Option<Identifier>) -> Result<WhileStatementId, ParseError> {
         let target = match label {
             Some(label) => {
                 let target_id = self.find_label(ctx, label)?;
                 // Make sure break target is a while statement
                 let target = &ctx.heap[target_id];
                 if let Statement::While(target_stmt) = &ctx.heap[target.body] {
                     // Even though we have a target while statement, the break might not be
                     // present underneath this particular labeled while statement
                     if !self.has_parent_while_scope(ctx, target_stmt.this) {
                         return Err(ParseError::new_error_str_at_span(
                             &ctx.module.source, label.span, "break statement is not nested under the target label's while statement"
+                            &ctx.module().source, label.span, "break statement is not nested under the target label's while statement"
                         ).with_info_str_at_span(
                             &ctx.module.source, target.label.span, "the targeted label is found here"
+                            &ctx.module().source, target.label.span, "the targeted label is found here"
                         ));
+                    }
                     target_stmt.this
                 } else {
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, label.span, "incorrect break target label, it must target a while loop"
+                        &ctx.module().source, label.span, "incorrect break target label, it must target a while loop"
                     ).with_info_str_at_span(
                         &ctx.module.source, target.label.span, "The targeted label is found here"
+                        &ctx.module().source, target.label.span, "The targeted label is found here"
                     ));
+                }
             },
             None => {
                 // Use the enclosing while statement, the break must be
                 // nested within that while statement
                 if self.in_while.is_invalid() {
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, span, "Break statement is not nested under a while loop"
+                        &ctx.module().source, span, "Break statement is not nested under a while loop"
                     ));
+                }
                 self.in_while
+            }
         };
         // We have a valid target for the break statement. But we need to
         // make sure we will not break out of a synchronous block
+        {
             let target_while = &ctx.heap[target];
             if target_while.in_sync != self.in_sync {
                 // Break is nested under while statement, so can only escape a
                 // sync block if the sync is nested inside the while statement.
                 debug_assert!(!self.in_sync.is_invalid());
                 let sync_stmt = &ctx.heap[self.in_sync];
                 return Err(
                     ParseError::new_error_str_at_span(&ctx.module.source, span, "break may not escape the surrounding synchronous block")
                         .with_info_str_at_span(&ctx.module.source, target_while.span, "the break escapes out of this loop")
                         .with_info_str_at_span(&ctx.module.source, sync_stmt.span, "And would therefore escape this synchronous block")
                     ParseError::new_error_str_at_span(&ctx.module().source, span, "break may not escape the surrounding synchronous block")
                         .with_info_str_at_span(&ctx.module().source, target_while.span, "the break escapes out of this loop")
                         .with_info_str_at_span(&ctx.module().source, sync_stmt.span, "And would therefore escape this synchronous block")
                 );
+            }
+        }
         Ok(target)
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/type_table.rs

➞

Show inline comments

@@ @@ -46,148 +46,166 @@ use crate::protocol::parser::*; @@
 //------------------------------------------------------------------------------
 // Defined Types
 //------------------------------------------------------------------------------
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum TypeClass {
     Enum,
     Union,
     Struct,
     Function,
     Component
+}
 impl TypeClass {
     pub(crate) fn display_name(&self) -> &'static str {
         match self {
             TypeClass::Enum => "enum",
             TypeClass::Union => "union",
             TypeClass::Struct => "struct",
             TypeClass::Function => "function",
             TypeClass::Component => "component",
+        }
+    }
     pub(crate) fn is_data_type(&self) -> bool {
         match self {
             TypeClass::Enum | TypeClass::Union | TypeClass::Struct => true,
             TypeClass::Function | TypeClass::Component => false,
+        }
+    }
+}
 impl std::fmt::Display for TypeClass {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         write!(f, "{}", self.display_name())
+    }
+}
 /// Struct wrapping around a potentially polymorphic type. If the type does not
 /// have any polymorphic arguments then it will not have any monomorphs and
 /// `is_polymorph` will be set to `false`. A type with polymorphic arguments
 /// only has `is_polymorph` set to `true` if the polymorphic arguments actually
 /// appear in the types associated types (function return argument, struct
 /// field, enum variant, etc.). Otherwise the polymorphic argument is just a
 /// marker and does not influence the bytesize of the type.
 pub struct DefinedType {
     pub(crate) ast_root: RootId,
     pub(crate) ast_definition: DefinitionId,
     pub(crate) definition: DefinedTypeVariant,
     pub(crate) poly_vars: Vec<PolymorphicVariable>,
     pub(crate) is_polymorph: bool,
+}
 impl DefinedType {
     /// Returns the number of monomorphs that are instantiated. Remember that
     /// during the type loop detection, and the memory layout phase we will
     /// pre-allocate monomorphs which are not yet fully laid out in memory.
     pub(crate) fn num_monomorphs(&self) -> usize {
         use DefinedTypeVariant as DTV;
         match &self.definition {
             DTV::Enum(def) => def.monomorphs.len(),
             DTV::Union(def) => def.monomorphs.len(),
             DTV::Struct(def) => def.monomorphs.len(),
             DTV::Function(_) | DTV::Component(_) => unreachable!(),
+        }
+    }
     /// Returns the index at which a monomorph occurs. Will only check the
     /// polymorphic arguments that are in use (none of the, in rust lingo,
     /// phantom types). If the type is not polymorphic and its memory has been
     /// layed out, then this will always return `Some(0)`.
     pub(crate) fn get_monomorph_index(&self, concrete_type: &ConcreteType) -> Option<usize> {
         use DefinedTypeVariant as DTV;
         // Helper to compare two types, while disregarding the polymorphic
         // variables that are not in use.
         let concrete_types_match = |type_a: &ConcreteType, type_b: &ConcreteType| -> bool {
+        let concrete_types_match = |type_a: &ConcreteType, type_b: &ConcreteType, check_if_poly_var_is_used: bool| -> bool {
             let mut a_iter = type_a.embedded_iter(0).enumerate();
             let mut b_iter = type_b.embedded_iter(0);
             while let Some((section_idx, a_section)) = a_iter.next() {
                 let b_section = b_iter.next().unwrap();
                 if !self.poly_vars[section_idx].is_in_use {
+                if check_if_poly_var_is_used && !self.poly_vars[section_idx].is_in_use {
                     continue;
+                }
                 if a_section != b_section {
                     return false;
+                }
+            }
             return true;
         };
         // Check check if type is polymorphic to some degree at all
         if cfg!(debug_assertions) {
             if let ConcreteTypePart::Instance(definition_id, num_poly_args) = concrete_type.parts[0] {
                 assert_eq!(definition_id, self.ast_definition);
                 assert_eq!(num_poly_args as usize, self.poly_vars.len());
             } else {
                 assert!(false, "concrete type {:?} is not a user-defined type", concrete_type);
+            }
+        }
         match &self.definition {
             DTV::Enum(definition) => {
                 // Special case, enum is never a "true polymorph"
                 debug_assert!(!self.is_polymorph);
                 if definition.monomorphs.is_empty() {
                     return None
                 } else {
                     return Some(0)
+                }
             },
             DTV::Union(definition) => {
                 for (monomorph_idx, monomorph) in definition.monomorphs.iter().enumerate() {
                     if concrete_types_match(&monomorph.concrete_type, concrete_type) {
+                    if concrete_types_match(&monomorph.concrete_type, concrete_type, true) {
                         return Some(monomorph_idx);
+                    }
+                }
             },
             DTV::Struct(definition) => {
                 for (monomorph_idx, monomorph) in definition.monomorphs.iter().enumerate() {
                     if concrete_types_match(&monomorph.concrete_type, concrete_type) {
+                    if concrete_types_match(&monomorph.concrete_type, concrete_type, true) {
                         return Some(monomorph_idx);
+                    }
+                }
             },
             DTV::Function(_) | DTV::Component(_) => {
                 unreachable!("called get_monomorph_index on a procedure type");
             DTV::Function(definition) => {
                 for (monomorph_idx, monomorph) in definition.monomorphs.iter().enumerate() {
                     if concrete_types_match(&monomorph.concrete_type, concrete_type, false) {
                         return Some(monomorph_idx)
+                    }
+                }
+            }
             DTV::Component(definition) => {
                 for (monomorph_idx, monomorph) in definition.monomorphs.iter().enumerate() {
                     if concrete_types_match(&monomorph.concrete_type, concrete_type, false) {
                         return Some(monomorph_idx)
+                    }
+                }
+            }
+        }
         // Nothing matched
         return None;
+    }
     /// Retrieves size and alignment of the particular type's monomorph if it
     /// has been layed out in memory.
     pub(crate) fn get_monomorph_size_alignment(&self, idx: usize) -> Option<(usize, usize)> {
         use DefinedTypeVariant as DTV;
         let (size, alignment) = match &self.definition {
             DTV::Enum(def) => {
                 debug_assert!(idx == 0);
                 (def.size, def.alignment)
             },
             DTV::Union(def) => {
                 let monomorph = &def.monomorphs[idx];
                 (monomorph.stack_size, monomorph.stack_alignment)
             },
             DTV::Struct(def) => {
                 let monomorph = &def.monomorphs[idx];
                 (monomorph.size, monomorph.alignment)
             },
@@ @@ -280,49 +298,49 @@ impl DefinedTypeVariant { @@
+        }
+    }
     pub(crate) fn procedure_monomorphs_mut(&mut self) -> &mut Vec<ProcedureMonomorph> {
         use DefinedTypeVariant::*;
         match self {
             Function(v) => &mut v.monomorphs,
             Component(v) => &mut v.monomorphs,
             _ => unreachable!("cannot get procedure monomorphs from {}", self.type_class()),
+        }
+    }
+}
 pub struct PolymorphicVariable {
     identifier: Identifier,
     is_in_use: bool, // a polymorphic argument may be defined, but not used by the type definition
+}
 /// Data associated with a monomorphized procedure type. Has the wrong name,
 /// because it will also be used to store expression data for a non-polymorphic
 /// procedure. (in that case, there will only ever be one)
 pub struct ProcedureMonomorph {
     // Expression data for one particular monomorph
-    pub poly_args: Vec<ConcreteType>,
+    pub concrete_type: ConcreteType,
     pub expr_data: Vec<MonomorphExpression>,
+}
 /// `EnumType` is the classical C/C++ enum type. It has various variants with
 /// an assigned integer value. The integer values may be user-defined,
 /// compiler-defined, or a mix of the two. If a user assigns the same enum
 /// value multiple times, we assume the user is an expert and we consider both
 /// variants to be equal to one another.
 pub struct EnumType {
     pub variants: Vec<EnumVariant>,
     pub monomorphs: Vec<EnumMonomorph>,
     pub minimum_tag_value: i64,
     pub maximum_tag_value: i64,
     pub tag_type: ConcreteType,
     pub size: usize,
     pub alignment: usize,
+}
 // TODO: Also support maximum u64 value
 pub struct EnumVariant {
     pub identifier: Identifier,
     pub value: i64,
+}
@@ @@ -425,261 +443,258 @@ pub struct ComponentType { @@
+}
 pub struct FunctionArgument {
     identifier: Identifier,
     parser_type: ParserType,
+}
 /// Represents the data associated with a single expression after type inference
 /// for a monomorph (or just the normal expression types, if dealing with a
 /// non-polymorphic function/component).
 pub struct MonomorphExpression {
     // The output type of the expression. Note that for a function it is not the
     // function's signature but its return type
     pub(crate) expr_type: ConcreteType,
     // Has multiple meanings: the field index for select expressions, the
     // monomorph index for polymorphic function calls or literals. Negative
     // values are never used, but used to catch programming errors.
     pub(crate) field_or_monomorph_idx: i32,
+}
 //------------------------------------------------------------------------------
 // Type table
 //------------------------------------------------------------------------------
 // Programmer note: keep this struct free of dynamically allocated memory
 #[derive(Clone)]
 struct TypeLoopBreadcrumb {
     definition_id: DefinitionId,
     monomorph_idx: usize,
     next_member: usize,
     next_embedded: usize, // for unions, the index into the variant's embedded types
+}
 #[derive(Clone)]
 struct MemoryBreadcrumb {
     definition_id: DefinitionId,
     monomorph_idx: usize,
     next_member: usize,
     next_embedded: usize,
     first_size_alignment_idx: usize,
+}
 #[derive(Debug, PartialEq, Eq)]
-enum BreadcrumbResult {
+enum TypeLoopResult {
     TypeExists,
-    PushedBreadcrumb,
+    PushBreadcrumb(DefinitionId, ConcreteType),
     TypeLoop(usize), // index into vec of breadcrumbs at which the type matched
+}
 enum MemoryLayoutResult {
     TypeExists(usize, usize), // (size, alignment)
-    PushBreadcrumb(TypeLoopBreadcrumb),
+    PushBreadcrumb(MemoryBreadcrumb),
+}
 // TODO: @Optimize, initial memory-unoptimized implementation
 struct TypeLoopEntry {
     definition_id: DefinitionId,
     monomorph_idx: usize,
     is_union: bool,
+}
 struct TypeLoop {
     members: Vec<TypeLoopEntry>
+}
 pub struct TypeTable {
     /// Lookup from AST DefinitionId to a defined type. Considering possible
     /// polymorphs is done inside the `DefinedType` struct.
     lookup: HashMap<DefinitionId, DefinedType>,
     /// Breadcrumbs left behind while trying to find type loops. Also used to
     /// determine sizes of types when all type loops are detected.
-    breadcrumbs: Vec<TypeLoopBreadcrumb>,
+    type_loop_breadcrumbs: Vec<TypeLoopBreadcrumb>,
     type_loops: Vec<TypeLoop>,
     /// Stores all encountered types during type loop detection. Used afterwards
     /// to iterate over all types in order to compute size/alignment.
     encountered_types: Vec<TypeLoopEntry>,
     /// Breadcrumbs and temporary storage during memory layout computation.
     memory_layout_breadcrumbs: Vec<MemoryBreadcrumb>,
     size_alignment_stack: Vec<(usize, usize)>,
+}
 impl TypeTable {
     /// Construct a new type table without any resolved types.
     pub(crate) fn new() -> Self {
         Self{
             lookup: HashMap::new(),
-            breadcrumbs: Vec::with_capacity(32),
+            type_loop_breadcrumbs: Vec::with_capacity(32),
             type_loops: Vec::with_capacity(8),
             encountered_types: Vec::with_capacity(32),
             memory_layout_breadcrumbs: Vec::with_capacity(32),
             size_alignment_stack: Vec::with_capacity(64),
+        }
+    }
     /// Iterates over all defined types (polymorphic and non-polymorphic) and
     /// add their types in two passes. In the first pass we will just add the
     /// base types (we will not consider monomorphs, and we will not compute
     /// byte sizes). In the second pass we will compute byte sizes of
     /// non-polymorphic types, and potentially the monomorphs that are embedded
     /// in those types.
     pub(crate) fn build_base_types(&mut self, modules: &mut [Module], ctx: &mut PassCtx) -> Result<(), ParseError> {
         // Make sure we're allowed to cast root_id to index into ctx.modules
         debug_assert!(modules.iter().all(|m| m.phase >= ModuleCompilationPhase::DefinitionsParsed));
         debug_assert!(self.lookup.is_empty());
         if cfg!(debug_assertions) {
             for (index, module) in modules.iter().enumerate() {
                 debug_assert_eq!(index, module.root_id.index as usize);
+            }
+        }
         // Use context to guess hashmap size of the base types
         let reserve_size = ctx.heap.definitions.len();
         self.lookup.reserve(reserve_size);
         // Resolve all base types
         for definition_idx in 0..ctx.heap.definitions.len() {
             let definition_id = ctx.heap.definitions.get_id(definition_idx);
             let definition = &ctx.heap[definition_id];
             match definition {
                 Definition::Enum(_) => self.build_base_enum_definition(modules, ctx, definition_id)?,
                 Definition::Union(_) => self.build_base_union_definition(modules, ctx, definition_id)?,
                 Definition::Struct(_) => self.build_base_struct_definition(modules, ctx, definition_id)?,
                 Definition::Function(_) => self.build_base_function_definition(modules, ctx, definition_id)?,
                 Definition::Component(_) => self.build_base_component_definition(modules, ctx, definition_id)?,
+            }
+        }
         debug_assert_eq!(self.lookup.len(), reserve_size, "mismatch in reserved size of type table"); // NOTE: Temp fix for builtin functions
         for module in modules {
+        for module in modules.iter_mut() {
             module.phase = ModuleCompilationPhase::TypesAddedToTable;
+        }
         // Go through all types again, lay out all types that are not
         // polymorphic. This might cause us to lay out types that are monomorphs
         // of polymorphic types.
         let empty_concrete_type = ConcreteType{ parts: Vec::new() };
         for definition_idx in 0..ctx.heap.definitions.len() {
             let definition_id = ctx.heap.definitions.get_id(definition_idx);
             let poly_type = self.lookup.get(&definition_id).unwrap();
             // Here we explicitly want to instantiate types which have no
             // polymorphic arguments (even if it has phantom polymorphic
             // arguments) because otherwise the user will see very weird
             // error messages.
             if poly_type.poly_vars.is_empty() && poly_type.num_monomorphs() == 0 {
+            if poly_type.definition.type_class().is_data_type() && poly_type.poly_vars.is_empty() && poly_type.num_monomorphs() == 0 {
                 self.detect_and_resolve_type_loops_for(
                     modules, ctx,
+                    modules, ctx.heap,
                     ConcreteType{
                         parts: vec![ConcreteTypePart::Instance(definition_id, 0)]
                     },
                 )?;
                 self.lay_out_memory_for_encountered_types(ctx);
+                self.lay_out_memory_for_encountered_types(ctx.arch);
+            }
+        }
         Ok(())
+    }
     /// Retrieves base definition from type table. We must be able to retrieve
     /// it as we resolve all base types upon type table construction (for now).
     /// However, in the future we might do on-demand type resolving, so return
     /// an option anyway
     pub(crate) fn get_base_definition(&self, definition_id: &DefinitionId) -> Option<&DefinedType> {
         self.lookup.get(&definition_id)
+    }
     /// Returns the index into the monomorph type array if the procedure type
     /// already has a (reserved) monomorph.
-    pub(crate) fn get_procedure_monomorph_index(&self, definition_id: &DefinitionId, types: &Vec<ConcreteType>) -> Option<i32> {
     pub(crate) fn get_procedure_monomorph_index(&self, definition_id: &DefinitionId, types: &ConcreteType) -> Option<i32> {
         let def = self.lookup.get(definition_id).unwrap();
         if def.is_polymorph {
             let monos = def.definition.procedure_monomorphs();
             return monos.iter()
                 .position(|v| v.poly_args == *types)
                 .map(|v| v as i32);
         } else {
             // We don't actually care about the types
             let monos = def.definition.procedure_monomorphs();
             if monos.is_empty() {
                 return None
             } else {
                 return Some(0)
+            }
+        }
         let monos = def.definition.procedure_monomorphs();
         return monos.iter()
             .position(|v| v.concrete_type == *types)
             .map(|v| v as i32);
+    }
     /// Returns a mutable reference to a procedure's monomorph expression data.
     /// Used by typechecker to fill in previously reserved type information
     pub(crate) fn get_procedure_expression_data_mut(&mut self, definition_id: &DefinitionId, monomorph_idx: i32) -> &mut ProcedureMonomorph {
         debug_assert!(monomorph_idx >= 0);
         let def = self.lookup.get_mut(definition_id).unwrap();
         let monomorphs = def.definition.procedure_monomorphs_mut();
         return &mut monomorphs[monomorph_idx as usize];
+    }
     pub(crate) fn get_procedure_expression_data(&self, definition_id: &DefinitionId, monomorph_idx: i32) -> &ProcedureMonomorph {
         debug_assert!(monomorph_idx >= 0);
         let def = self.lookup.get(definition_id).unwrap();
         let monomorphs = def.definition.procedure_monomorphs();
         return &monomorphs[monomorph_idx as usize];
+    }
     /// Reserves space for a monomorph of a polymorphic procedure. The index
     /// will point into a (reserved) slot of the array of expression types. The
     /// monomorph may NOT exist yet (because the reservation implies that we're
     /// going to be performing typechecking on it, and we don't want to
     /// check the same monomorph twice)
-    pub(crate) fn reserve_procedure_monomorph_index(&mut self, definition_id: &DefinitionId, types: Option<Vec<ConcreteType>>) -> i32 {
+    pub(crate) fn reserve_procedure_monomorph_index(&mut self, definition_id: &DefinitionId, concrete_type: ConcreteType) -> i32 {
         let def = self.lookup.get_mut(definition_id).unwrap();
         if let Some(types) = types {
             // Expecting a polymorphic procedure
             let monos = def.definition.procedure_monomorphs_mut();
             debug_assert!(def.is_polymorph);
             debug_assert!(def.poly_vars.len() == types.len());
             debug_assert!(monos.iter().find(|v| v.poly_args == types).is_none());
             let mono_idx = monos.len();
             monos.push(ProcedureMonomorph{ poly_args: types, expr_data: Vec::new() });
             return mono_idx as i32;
         } else {
             // Expecting a non-polymorphic procedure
             let monos = def.definition.procedure_monomorphs_mut();
             debug_assert!(!def.is_polymorph);
             debug_assert!(def.poly_vars.is_empty());
             debug_assert!(monos.is_empty());
             monos.push(ProcedureMonomorph{ poly_args: Vec::new(), expr_data: Vec::new() });
         let mono_types = def.definition.procedure_monomorphs_mut();
         debug_assert!(def.is_polymorph == (concrete_type.parts.len() != 1));
         debug_assert!(!mono_types.iter().any(|v| v.concrete_type == concrete_type));
         let mono_idx = mono_types.len();
         mono_types.push(ProcedureMonomorph{
             concrete_type,
             expr_data: Vec::new(),
         });
             return 0;
+        }
         return mono_idx as i32;
+    }
     /// Adds a datatype polymorph to the type table. Will not add the
     /// monomorph if it is already present, or if the type's polymorphic
     /// variables are all unused.
     /// TODO: Fix signature
     pub(crate) fn add_data_monomorph(
-        &mut self, modules: &[Module], ctx: &PassCtx, definition_id: &DefinitionId, concrete_type: ConcreteType
+        &mut self, modules: &[Module], heap: &Heap, arch: &TargetArch, definition_id: DefinitionId, concrete_type: ConcreteType
     ) -> Result<i32, ParseError> {
-        debug_assert_eq!(*definition_id, get_concrete_type_definition(&concrete_type));
         debug_assert_eq!(definition_id, get_concrete_type_definition(&concrete_type));
         // Check if the monomorph already exists
         let poly_type = self.lookup.get_mut(definition_id).unwrap();
+        let poly_type = self.lookup.get_mut(&definition_id).unwrap();
         if let Some(idx) = poly_type.get_monomorph_index(&concrete_type) {
             return Ok(idx as i32);
+        }
         // Doesn't exist, so instantiate a monomorph and determine its memory
         // layout.
-        self.detect_and_resolve_type_loops_for(modules, ctx, concrete_type)?;
+        self.detect_and_resolve_type_loops_for(modules, heap, concrete_type)?;
         debug_assert_eq!(self.encountered_types[0].definition_id, definition_id);
         let mono_idx = self.encountered_types[0].monomorph_idx;
-        self.lay_out_memory_for_encountered_types(ctx);
+        self.lay_out_memory_for_encountered_types(arch);
         return Ok(mono_idx as i32);
+    }
     //--------------------------------------------------------------------------
     // Building base types
     //--------------------------------------------------------------------------
     /// Builds the base type for an enum. Will not compute byte sizes
     fn build_base_enum_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {
         debug_assert!(!self.lookup.contains_key(&definition_id), "base enum already built");
         let definition = ctx.heap[definition_id].as_enum();
         let root_id = definition.defined_in;
         // Determine enum variants
         let mut enum_value = -1;
         let mut variants = Vec::with_capacity(definition.variants.len());
         for variant in &definition.variants {
             if enum_value == i64::MAX {
                 let source = &modules[definition.defined_in.index as usize].source;
                 return Err(ParseError::new_error_str_at_span(
                     source, variant.identifier.span,
                     "this enum variant has an integer value that is too large"
@@ @@ -735,69 +750,68 @@ impl TypeTable { @@
             }),
             poly_vars,
             is_polymorph: false,
         });
         return Ok(());
+    }
     /// Builds the base type for a union. Will compute byte sizes.
     fn build_base_union_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {
         debug_assert!(!self.lookup.contains_key(&definition_id), "base union already built");
         let definition = ctx.heap[definition_id].as_union();
         let root_id = definition.defined_in;
         // Check all variants and their embedded types
         let mut variants = Vec::with_capacity(definition.variants.len());
         let mut tag_counter = 0;
         for variant in &definition.variants {
             for embedded in &variant.value {
                 Self::check_member_parser_type(
                     modules, ctx, root_id, embedded, false
                 )?;
+            }
             let has_embedded = !variant.value.is_empty();
             variants.push(UnionVariant{
                 identifier: variant.identifier.clone(),
                 embedded: variant.value.clone(),
                 tag_value: tag_counter,
             });
             tag_counter += 1;
+        }
         let mut max_tag_value = 0;
         if tag_counter != 0 {
             max_tag_value = tag_counter - 1
+        }
         let (tag_type, tag_size) = Self::variant_tag_type_from_values(0, max_tag_value);
         // Make sure there are no conflicts in identifiers
         Self::check_identifier_collision(
             modules, root_id, &variants, |variant| &variant.identifier, "union variant"
         )?;
         Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars);
+        Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
         // Construct internal representation of union
         let mut poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);
         for variant in &definition.variants {
             for embedded in &variant.value {
                 Self::mark_used_polymorphic_variables(&mut poly_vars, embedded);
+            }
+        }
         let is_polymorph = poly_vars.iter().any(|arg| arg.is_in_use);
         self.lookup.insert(definition_id, DefinedType{
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Union(UnionType{
                 variants,
                 monomorphs: Vec::new(),
                 tag_type,
                 tag_size,
             }),
             poly_vars,
             is_polymorph
         });
@@ @@ -1063,160 +1077,183 @@ impl TypeTable { @@
                 return Err(ParseError::new_error_str_at_span(
                     module_source, poly_arg.span,
                     "This polymorphic argument conflicts with another symbol"
                 ).with_info_str_at_span(
                     module_source, introduction_span,
                     "It conflicts due to this symbol"
                 ));
+            }
+        }
         // All arguments are fine
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Detecting type loops
     //--------------------------------------------------------------------------
     /// Internal function that will detect type loops and check if they're
     /// resolvable. If so then the appropriate union variants will be marked as
     /// "living on heap". If not then a `ParseError` will be returned
     fn detect_and_resolve_type_loops_for(&mut self, modules: &[Module], heap: &Heap, concrete_type: ConcreteType) -> Result<(), ParseError> {
         use DefinedTypeVariant as DTV;
-        debug_assert!(self.breadcrumbs.is_empty());
+        debug_assert!(self.type_loop_breadcrumbs.is_empty());
         debug_assert!(self.type_loops.is_empty());
         debug_assert!(self.encountered_types.is_empty());
         // Push the initial breadcrumb
         let _initial_result = self.push_breadcrumb_for_type_loops(get_concrete_type_definition(&concrete_type), &concrete_type);
         debug_assert_eq!(_initial_result, BreadcrumbResult::PushedBreadcrumb);
         let initial_breadcrumb = self.check_member_for_type_loops(&concrete_type);
         if let TypeLoopResult::PushBreadcrumb(definition_id, concrete_type) = initial_breadcrumb {
             self.handle_new_breadcrumb_for_type_loops(definition_id, concrete_type);
         } else {
             unreachable!();
+        }
         // Enter into the main resolving loop
         while !self.breadcrumbs.is_empty() {
             let breadcrumb_idx = self.breadcrumbs.len() - 1;
             let breadcrumb = self.breadcrumbs.last_mut().unwrap();
         while !self.type_loop_breadcrumbs.is_empty() {
             // Because we might be modifying the breadcrumb array we need to
             let breadcrumb_idx = self.type_loop_breadcrumbs.len() - 1;
             let mut breadcrumb = self.type_loop_breadcrumbs[breadcrumb_idx].clone();
             let poly_type = self.lookup.get(&breadcrumb.definition_id).unwrap();
             let poly_type_definition_id = poly_type.ast_definition;
             // TODO: Misuse of BreadcrumbResult enum?
             let resolve_result = match &poly_type.definition {
                 DTV::Enum(_) => {
-                    BreadcrumbResult::TypeExists
+                    TypeLoopResult::TypeExists
                 },
                 DTV::Union(definition) => {
                     let monomorph = &definition.monomorphs[breadcrumb.monomorph_idx];
                     let num_variants = monomorph.variants.len();
-                    let mut union_result = BreadcrumbResult::TypeExists;
+                    let mut union_result = TypeLoopResult::TypeExists;
                     'member_loop: while breadcrumb.next_member < num_variants {
                         let mono_variant = &monomorph.variants[breadcrumb.next_member];
                         let num_embedded = mono_variant.embedded.len();
                         while breadcrumb.next_embedded < num_embedded {
                             let mono_embedded = &mono_variant.embedded[breadcrumb.next_embedded];
-                            union_result = self.push_breadcrumb_for_type_loops(poly_type.ast_definition, &mono_embedded.concrete_type);
+                            union_result = self.check_member_for_type_loops(&mono_embedded.concrete_type);
-                            if union_result != BreadcrumbResult::TypeExists {
+                            if union_result != TypeLoopResult::TypeExists {
                                 // In type loop or new breadcrumb pushed, so
                                 // break out of the resolving loop
                                 break 'member_loop;
+                            }
                             breadcrumb.next_embedded += 1;
+                        }
                         breadcrumb.next_embedded = 0;
                         breadcrumb.next_member += 1
+                    }
                     union_result
                 },
                 DTV::Struct(definition) => {
                     let monomorph = &definition.monomorphs[breadcrumb.monomorph_idx];
                     let num_fields = monomorph.fields.len();
-                    let mut struct_result = BreadcrumbResult::TypeExists;
+                    let mut struct_result = TypeLoopResult::TypeExists;
                     while breadcrumb.next_member < num_fields {
                         let mono_field = &monomorph.fields[breadcrumb.next_member];
-                        struct_result = self.push_breadcrumb_for_type_loops(poly_type.ast_definition, &mono_field.concrete_type);
+                        struct_result = self.check_member_for_type_loops(&mono_field.concrete_type);
-                        if struct_result != BreadcrumbResult::TypeExists {
+                        if struct_result != TypeLoopResult::TypeExists {
                             // Type loop or breadcrumb pushed, so break out of
                             // the resolving loop
                             break;
+                        }
                         breadcrumb.next_member += 1;
+                    }
                     struct_result
                 },
                 DTV::Function(_) | DTV::Component(_) => unreachable!(),
             };
             // Handle the result of attempting to resolve the current breadcrumb
             match resolve_result {
-                BreadcrumbResult::TypeExists => {
+                TypeLoopResult::TypeExists => {
                     // We finished parsing the type
-                    self.breadcrumbs.pop();
+                    self.type_loop_breadcrumbs.pop();
                 },
                 BreadcrumbResult::PushedBreadcrumb => {
                     // We recurse into the member type, since the breadcrumb is
                     // already pushed we don't take any action here.
                 TypeLoopResult::PushBreadcrumb(definition_id, concrete_type) => {
                     // We recurse into the member type.
                     self.type_loop_breadcrumbs[breadcrumb_idx] = breadcrumb;
                     self.handle_new_breadcrumb_for_type_loops(definition_id, concrete_type);
                 },
                 BreadcrumbResult::TypeLoop(first_idx) => {
                 TypeLoopResult::TypeLoop(first_idx) => {
                     // Because we will be modifying breadcrumbs within the
                     // type-loop handling code, put back the modified breadcrumb
                     self.type_loop_breadcrumbs[breadcrumb_idx] = breadcrumb;
                     // We're in a type loop. Add the type loop
                     let mut loop_members = Vec::with_capacity(self.breadcrumbs.len() - first_idx);
                     for breadcrumb_idx in first_idx..self.breadcrumbs.len() {
                         let breadcrumb = &mut self.breadcrumbs[breadcrumb_idx];
                     let mut loop_members = Vec::with_capacity(self.type_loop_breadcrumbs.len() - first_idx);
                     let mut contains_union = false;
                     for breadcrumb_idx in first_idx..self.type_loop_breadcrumbs.len() {
                         let breadcrumb = &mut self.type_loop_breadcrumbs[breadcrumb_idx];
                         let mut is_union = false;
                         let entry = self.lookup.get_mut(&breadcrumb.definition_id).unwrap();
                         match &mut entry.definition {
                             DTV::Union(definition) => {
                                 // Mark the currently processed variant as requiring heap
                                 // allocation, then advance the *embedded* type. The loop above
                                 // will then take care of advancing it to the next *member*.
                                 let monomorph = &mut definition.monomorphs[breadcrumb.monomorph_idx];
                                 let variant = &mut monomorph.variants[breadcrumb.next_member];
                                 variant.lives_on_heap = true;
                                 breadcrumb.next_embedded += 1;
                                 is_union = true;
                                 contains_union = true;
                             },
                             _ => {}, // else: we don't care for now
+                        }
                         loop_members.push(TypeLoopEntry{
                             definition_id: breadcrumb.definition_id,
                             monomorph_idx: breadcrumb.monomorph_idx,
                             is_union
                         });
+                    }
                     self.type_loops.push(TypeLoop{ members: loop_members });
                     let new_type_loop = TypeLoop{ members: loop_members };
                     if !contains_union {
                         // No way to (potentially) break the union. So return a
                         // type loop error. This is because otherwise our
                         // breadcrumb resolver ends up in an infinite loop.
                         return Err(construct_type_loop_error(
                             self, &new_type_loop, modules, heap
                         ));
+                    }
                     self.type_loops.push(new_type_loop);
+                }
+            }
+        }
         // All breadcrumbs have been cleared. So now `type_loops` contains all
         // of the encountered type loops, and `encountered_types` contains a
         // list of all unique monomorphs we encountered.
         // The next step is to figure out if all of the type loops can be
         // broken. A type loop can be broken if at least one union exists in the
         // loop and that union ended up having variants that are not part of
         // a type loop.
         fn type_loop_source_span_and_message<'a>(
             modules: &'a [Module], heap: &Heap, defined_type: &DefinedType, monomorph_idx: usize, index_in_loop: usize
         ) -> (&'a InputSource, InputSpan, String) {
             // Note: because we will discover the type loop the *first* time we
             // instantiate a monomorph with the provided polymorphic arguments
             // (not all arguments are actually used in the type). We don't have
             // to care about a second instantiation where certain unused
             // polymorphic arguments are different.
             let monomorph_type = match &defined_type.definition {
                 DTV::Union(definition) => &definition.monomorphs[monomorph_idx].concrete_type,
                 DTV::Struct(definition) => &definition.monomorphs[monomorph_idx].concrete_type,
                 DTV::Enum(_) | DTV::Function(_) | DTV::Component(_) =>
@@ @@ -1226,199 +1263,228 @@ impl TypeTable { @@
             let type_name = monomorph_type.display_name(&heap);
             let message = if index_in_loop == 0 {
                 format!(
                     "encountered an infinitely large type for '{}' (which can be fixed by \
                     introducing a union type that has a variant whose embedded types are \
                     not part of a type loop, or do not have embedded types)",
                     type_name
+                )
             } else if index_in_loop == 1 {
                 format!("because it depends on the type '{}'", type_name)
             } else {
                 format!("which depends on the type '{}'", type_name)
             };
             let ast_definition = &heap[defined_type.ast_definition];
             let ast_root_id = ast_definition.defined_in();
             return (
                 &modules[ast_root_id.index as usize].source,
                 ast_definition.identifier().span,
                 message
             );
+        }
         fn construct_type_loop_error(table: &TypeTable, type_loop: &TypeLoop, modules: &[Module], heap: &Heap) -> ParseError {
             let first_entry = &type_loop.members[0];
             let first_type = table.lookup.get(&first_entry.definition_id).unwrap();
             let (first_module, first_span, first_message) = type_loop_source_span_and_message(
                 modules, heap, first_type, first_entry.monomorph_idx, 0
             );
             let mut parse_error = ParseError::new_error_at_span(first_module, first_span, first_message);
             for member_idx in 1..type_loop.members.len() {
                 let entry = &type_loop.members[member_idx];
                 let entry_type = table.lookup.get(&first_entry.definition_id).unwrap();
                 let (module, span, message) = type_loop_source_span_and_message(
                     modules, heap, entry_type, entry.monomorph_idx, member_idx
                 );
                 parse_error = parse_error.with_info_at_span(module, span, message);
+            }
             parse_error
+        }
         for type_loop in &self.type_loops {
             let mut can_be_broken = false;
             debug_assert!(!type_loop.members.is_empty());
             for entry in &type_loop.members {
                 if entry.is_union {
                     let base_type = self.lookup.get(&entry.definition_id).unwrap();
                     let monomorph = &base_type.definition.as_union().monomorphs[entry.monomorph_idx];
                     debug_assert!(!monomorph.variants.is_empty()); // otherwise it couldn't be part of the type loop
                     let has_stack_variant = monomorph.variants.iter().any(|variant| !variant.lives_on_heap);
                     if has_stack_variant {
                         can_be_broken = true;
+                    }
+                }
+            }
             if !can_be_broken {
                 // Construct a type loop error
                 let first_entry = &type_loop.members[0];
                 let first_type = self.lookup.get(&first_entry.definition_id).unwrap();
                 let (first_module, first_span, first_message) = type_loop_source_span_and_message(
                     modules, heap, first_type, first_entry.monomorph_idx, 0
                 );
                 let mut parse_error = ParseError::new_error_at_span(first_module, first_span, first_message);
                 for member_idx in 1..type_loop.members.len() {
                     let entry = &type_loop.members[member_idx];
                     let entry_type = self.lookup.get(&first_entry.definition_id).unwrap();
                     let (module, span, message) = type_loop_source_span_and_message(
                         modules, heap, entry_type, entry.monomorph_idx, member_idx
                     );
                     parse_error = parse_error.with_info_at_span(module, span, message);
+                }
                 return Err(parse_error);
                 return Err(construct_type_loop_error(self, type_loop, modules, heap));
+            }
+        }
         // If here, then all type loops have been resolved and we can lay out
         // all of the members
         self.type_loops.clear();
         return Ok(());
+    }
     // TODO: Pass in definition_type by value?
     fn push_breadcrumb_for_type_loops(&mut self, definition_id: DefinitionId, definition_type: &ConcreteType) -> BreadcrumbResult {
         use DefinedTypeVariant as DTV;
     /// Checks if the specified type needs to be resolved (i.e. we need to push
     /// a breadcrumb), is already resolved (i.e. we can continue with the next
     /// member of the currently considered type) or is in the process of being
     /// resolved (i.e. we're in a type loop). Because of borrowing rules we
     /// don't do any modifications of internal types here. Hence: if we
     /// return `PushBreadcrumb` then call `handle_new_breadcrumb_for_type_loops`
     /// to take care of storing the appropriate types.
     fn check_member_for_type_loops(&self, definition_type: &ConcreteType) -> TypeLoopResult {
         use ConcreteTypePart as CTP;
         // We're only interested in user-defined types, so exit if it is a
         // builtin of some sort.
         debug_assert!(!definition_type.parts.is_empty());
         let definition_id = match &definition_type.parts[0] {
             CTP::Instance(definition_id, _) |
             CTP::Function(definition_id, _) |
             CTP::Component(definition_id, _) => {
                 *definition_id
             },
             _ => {
                 return TypeLoopResult::TypeExists
             },
         };
-        let mut base_type = self.lookup.get_mut(&definition_id).unwrap();
+        let base_type = self.lookup.get(&definition_id).unwrap();
         if let Some(mono_idx) = base_type.get_monomorph_index(&definition_type) {
             // Monomorph is already known. Check if it is present in the
             // breadcrumbs. If so, then we are in a type loop
-            for (breadcrumb_idx, breadcrumb) in self.breadcrumbs.iter().enumerate() {
+            for (breadcrumb_idx, breadcrumb) in self.type_loop_breadcrumbs.iter().enumerate() {
                 if breadcrumb.definition_id == definition_id && breadcrumb.monomorph_idx == mono_idx {
-                    return BreadcrumbResult::TypeLoop(breadcrumb_idx);
+                    return TypeLoopResult::TypeLoop(breadcrumb_idx);
+                }
+            }
-            return BreadcrumbResult::TypeExists;
+            return TypeLoopResult::TypeExists;
+        }
         // Type is not yet known, so we need to insert it into the lookup and
         // push a new breadcrumb.
         return TypeLoopResult::PushBreadcrumb(definition_id, definition_type.clone());
+    }
     /// Handles the `PushBreadcrumb` result for a `check_member_for_type_loops`
     /// call.
     fn handle_new_breadcrumb_for_type_loops(&mut self, definition_id: DefinitionId, definition_type: ConcreteType) {
         use DefinedTypeVariant as DTV;
         let base_type = self.lookup.get_mut(&definition_id).unwrap();
         let mut is_union = false;
         let monomorph_idx = match &mut base_type.definition {
             DTV::Enum(definition) => {
                 debug_assert!(definition.monomorphs.is_empty());
                 definition.monomorphs.push(EnumMonomorph{
-                    concrete_type: definition_type.clone(),
                     concrete_type: definition_type,
                 });
             },
             DTV::Union(definition) => {
                 // Create all the variants with their concrete types
                 let mut mono_variants = Vec::with_capacity(definition.variants.len());
                 for poly_variant in &definition.variants {
                     let mut mono_embedded = Vec::with_capacity(poly_variant.embedded.len());
                     for poly_embedded in &poly_variant.embedded {
                         let mono_concrete = Self::construct_concrete_type(poly_embedded, definition_type);
+                        let mono_concrete = Self::construct_concrete_type(poly_embedded, &definition_type);
                         mono_embedded.push(UnionMonomorphEmbedded{
                             concrete_type: mono_concrete,
                             size: 0,
                             alignment: 0,
                             offset: 0
                         });
+                    }
                     mono_variants.push(UnionMonomorphVariant{
                         lives_on_heap: false,
                         embedded: mono_embedded,
                     })
+                }
                 let mono_idx = definition.monomorphs.len();
                 definition.monomorphs.push(UnionMonomorph{
-                    concrete_type: definition_type.clone(),
                     concrete_type: definition_type,
                     variants: mono_variants,
                     stack_size: 0,
                     stack_alignment: 0,
                     heap_size: 0,
                     heap_alignment: 0
                 });
                 is_union = true;
                 mono_idx
             },
             DTV::Struct(definition) => {
                 let mut mono_fields = Vec::with_capacity(definition.fields.len());
                 for poly_field in &definition.fields {
                     let mono_concrete = Self::construct_concrete_type(&poly_field.parser_type, definition_type);
+                    let mono_concrete = Self::construct_concrete_type(&poly_field.parser_type, &definition_type);
                     mono_fields.push(StructMonomorphField{
                         concrete_type: mono_concrete,
                         size: 0,
                         alignment: 0,
                         offset: 0
                     })
+                }
                 let mono_idx = definition.monomorphs.len();
                 definition.monomorphs.push(StructMonomorph{
-                    concrete_type: definition_type.clone(),
                     concrete_type: definition_type,
                     fields: mono_fields,
                     size: 0,
                     alignment: 0
                 });
                 mono_idx
             },
             DTV::Function(_) | DTV::Component(_) => {
                 unreachable!("pushing type resolving breadcrumb for procedure type")
             },
         };
-        self.breadcrumbs.push(TypeLoopBreadcrumb{
+        self.encountered_types.push(TypeLoopEntry{
             definition_id,
             monomorph_idx,
             next_member: 0,
             next_embedded: 0
             is_union,
         });
         // With the breadcrumb constructed we know this is a new type, so we
         // also need to add an entry in the list of all encountered types
         self.encountered_types.push(TypeLoopEntry{
         self.type_loop_breadcrumbs.push(TypeLoopBreadcrumb{
             definition_id,
             monomorph_idx,
             is_union,
             next_member: 0,
             next_embedded: 0,
         });
         return BreadcrumbResult::PushedBreadcrumb;
+    }
     /// Constructs a concrete type out of a parser type for a struct field or
     /// union embedded type. It will do this by looking up the polymorphic
     /// variables in the supplied concrete type. The assumption is that the
     /// polymorphic variable's indices correspond to the subtrees in the
     /// concrete type.
     fn construct_concrete_type(member_type: &ParserType, container_type: &ConcreteType) -> ConcreteType {
         use ParserTypeVariant as PTV;
         use ConcreteTypePart as CTP;
         // TODO: Combine with code in pass_typing.rs
         fn parser_to_concrete_part(part: &ParserTypeVariant) -> Option<ConcreteTypePart> {
             match part {
                 PTV::Void      => Some(CTP::Void),
                 PTV::Message   => Some(CTP::Message),
                 PTV::Bool      => Some(CTP::Bool),
                 PTV::UInt8     => Some(CTP::UInt8),
                 PTV::UInt16    => Some(CTP::UInt16),
                 PTV::UInt32    => Some(CTP::UInt32),
                 PTV::UInt64    => Some(CTP::UInt64),
                 PTV::SInt8     => Some(CTP::SInt8),
                 PTV::SInt16    => Some(CTP::SInt16),
                 PTV::SInt32    => Some(CTP::SInt32),
@@ @@ -1446,296 +1512,341 @@ impl TypeTable { @@
             if let PTV::PolymorphicArgument(_container_definition_id, poly_arg_idx) = member_part.variant {
                 debug_assert_eq!(_container_definition_id, get_concrete_type_definition(container_type));
                 let mut container_iter = container_type.embedded_iter(0);
                 for _ in 0..poly_arg_idx {
                     container_iter.next();
+                }
                 let poly_section = container_iter.next().unwrap();
                 parts.extend(poly_section);
                 continue;
+            }
             unreachable!("unexpected type part {:?} from {:?}", member_part, member_type);
+        }
         return ConcreteType{ parts };
+    }
     //--------------------------------------------------------------------------
     // Determining memory layout for types
     //--------------------------------------------------------------------------
-    fn lay_out_memory_for_encountered_types(&mut self, ctx: &PassCtx) {
+    fn lay_out_memory_for_encountered_types(&mut self, arch: &TargetArch) {
         use DefinedTypeVariant as DTV;
         // Just finished type loop detection, so we're left with the encountered
         // types only
         debug_assert!(self.breadcrumbs.is_empty());
         debug_assert!(self.type_loops.is_empty());
         debug_assert!(!self.encountered_types.is_empty());
         debug_assert!(self.memory_layout_breadcrumbs.is_empty());
         debug_assert!(self.size_alignment_stack.is_empty());
         // Push the first entry (the type we originally started with when we
         // were detecting type loops)
         let first_entry = &self.encountered_types[0];
-        self.breadcrumbs.push(TypeLoopBreadcrumb{
+        self.memory_layout_breadcrumbs.push(MemoryBreadcrumb{
             definition_id: first_entry.definition_id,
             monomorph_idx: first_entry.monomorph_idx,
             next_member: 0,
             next_embedded: 0,
             first_size_alignment_idx: 0,
         });
         // Enter the main resolving loop
         'breadcrumb_loop: while !self.breadcrumbs.is_empty() {
             let breadcrumb_idx = self.breadcrumbs.len() - 1;
             let breadcrumb = &mut self.breadcrumbs[breadcrumb_idx];
         'breadcrumb_loop: while !self.memory_layout_breadcrumbs.is_empty() {
             let cur_breadcrumb_idx = self.memory_layout_breadcrumbs.len() - 1;
             let mut breadcrumb = self.memory_layout_breadcrumbs[cur_breadcrumb_idx].clone();
             let poly_type = self.lookup.get_mut(&breadcrumb.definition_id).unwrap();
             match &mut poly_type.definition {
             let poly_type = self.lookup.get(&breadcrumb.definition_id).unwrap();
             match &poly_type.definition {
                 DTV::Enum(definition) => {
                     // Size should already be computed
                     debug_assert!(definition.size != 0 && definition.alignment != 0);
                 },
                 DTV::Union(definition) => {
                     // Retrieve size/alignment of each embedded type. We do not
                     // compute the offsets or total type sizes yet.
-                    let mono_type = &mut definition.monomorphs[breadcrumb.monomorph_idx];
                     let mono_type = &definition.monomorphs[breadcrumb.monomorph_idx];
                     let num_variants = mono_type.variants.len();
                     while breadcrumb.next_member < num_variants {
-                        let mono_variant = &mut mono_type.variants[breadcrumb.next_member];
                         let mono_variant = &mono_type.variants[breadcrumb.next_member];
                         if mono_variant.lives_on_heap {
                             // To prevent type loops we made this a heap-
                             // allocated variant. This implies we cannot
                             // compute sizes of members at this point.
                         } else {
                             let num_embedded = mono_variant.embedded.len();
                             while breadcrumb.next_embedded < num_embedded {
                                 let mono_embedded = &mut mono_variant.embedded[breadcrumb.next_embedded];
                                 match self.get_memory_layout_or_breadcrumb(ctx, &mono_embedded.concrete_type) {
                                 let mono_embedded = &mono_variant.embedded[breadcrumb.next_embedded];
                                 match self.get_memory_layout_or_breadcrumb(arch, &mono_embedded.concrete_type) {
                                     MemoryLayoutResult::TypeExists(size, alignment) => {
                                         mono_embedded.size = size;
                                         mono_embedded.alignment = alignment;
                                         self.size_alignment_stack.push((size, alignment));
                                     },
                                     MemoryLayoutResult::PushBreadcrumb(new_breadcrumb) => {
                                         self.breadcrumbs.push(new_breadcrumb);
                                         self.memory_layout_breadcrumbs[cur_breadcrumb_idx] = breadcrumb;
                                         self.memory_layout_breadcrumbs.push(new_breadcrumb);
                                         continue 'breadcrumb_loop;
+                                    }
+                                }
                                 breadcrumb.next_embedded += 1;
+                            }
+                        }
                         breadcrumb.next_member += 1;
                         breadcrumb.next_embedded = 0;
+                    }
                     // If here then we can at least compute the stack size of
                     // the type, we'll have to come back at the very end to
                     // fill in the heap size/alignment/offset of each heap-
                     // allocated variant.
                     let mut max_size = definition.tag_size;
                     let mut max_alignment = definition.tag_size;
                     let poly_type = self.lookup.get_mut(&breadcrumb.definition_id).unwrap();
                     let definition = poly_type.definition.as_union_mut();
                     let mono_type = &mut definition.monomorphs[breadcrumb.monomorph_idx];
                     let mut size_alignment_idx = breadcrumb.first_size_alignment_idx;
                     for variant in &mut mono_type.variants {
                         // We're doing stack computations, so always start with
                         // the tag size/alignment.
                         let mut variant_offset = definition.tag_size;
                         let mut variant_alignment = definition.tag_size;
                         if variant.lives_on_heap {
                             // Variant lives on heap, so just a pointer
-                            let (ptr_size, ptr_align) = ctx.arch.pointer_size_alignment;
                             let (ptr_size, ptr_align) = arch.pointer_size_alignment;
                             align_offset_to(&mut variant_offset, ptr_align);
                             variant_offset += ptr_size;
                             variant_alignment = variant_alignment.max(ptr_align);
                         } else {
                             // Variant lives on stack, so walk all embedded
                             // types.
                             for embedded in &mut variant.embedded {
                                 align_offset_to(&mut variant_offset, embedded.alignment);
                                 let (size, alignment) = self.size_alignment_stack[size_alignment_idx];
                                 embedded.size = size;
                                 embedded.alignment = alignment;
                                 size_alignment_idx += 1;
                                 align_offset_to(&mut variant_offset, alignment);
                                 embedded.offset = variant_offset;
                                 variant_offset += embedded.size;
                                 variant_alignment = variant_alignment.max(embedded.alignment);
                                 variant_offset += size;
                                 variant_alignment = variant_alignment.max(alignment);
+                            }
                         };
                         max_size = max_size.max(variant_offset);
                         max_alignment = max_alignment.max(variant_alignment);
+                    }
                     mono_type.stack_size = max_size;
                     mono_type.stack_alignment = max_alignment;
                     self.size_alignment_stack.truncate(breadcrumb.first_size_alignment_idx);
                 },
                 DTV::Struct(definition) => {
                     // Retrieve size and alignment of each struct member. We'll
                     // compute the offsets once all of those are known
-                    let mono_type = &mut definition.monomorphs[breadcrumb.monomorph_idx];
                     let mono_type = &definition.monomorphs[breadcrumb.monomorph_idx];
                     let num_fields = mono_type.fields.len();
                     while breadcrumb.next_member < num_fields {
-                        let mono_field = &mut mono_type.fields[breadcrumb.next_member];
                         let mono_field = &mono_type.fields[breadcrumb.next_member];
-                        match self.get_memory_layout_or_breadcrumb(ctx, &mono_field.concrete_type) {
+                        match self.get_memory_layout_or_breadcrumb(arch, &mono_field.concrete_type) {
                             MemoryLayoutResult::TypeExists(size, alignment) => {
                                 mono_field.size = size;
                                 mono_field.alignment = alignment;
                                 self.size_alignment_stack.push((size, alignment))
                             },
                             MemoryLayoutResult::PushBreadcrumb(new_breadcrumb) => {
                                 self.breadcrumbs.push(new_breadcrumb);
                                 self.memory_layout_breadcrumbs[cur_breadcrumb_idx] = breadcrumb;
                                 self.memory_layout_breadcrumbs.push(new_breadcrumb);
                                 continue 'breadcrumb_loop;
                             },
+                        }
                         breadcrumb.next_member += 1;
+                    }
                     // Compute offsets and size of total type
                     let mut cur_offset = 0;
                     let mut max_alignment = 1;
                     let poly_type = self.lookup.get_mut(&breadcrumb.definition_id).unwrap();
                     let definition = poly_type.definition.as_struct_mut();
                     let mono_type = &mut definition.monomorphs[breadcrumb.monomorph_idx];
                     let mut size_alignment_idx = breadcrumb.first_size_alignment_idx;
                     for field in &mut mono_type.fields {
                         align_offset_to(&mut cur_offset, field.alignment);
                         let (size, alignment) = self.size_alignment_stack[size_alignment_idx];
                         field.size = size;
                         field.alignment = alignment;
                         size_alignment_idx += 1;
                         align_offset_to(&mut cur_offset, alignment);
                         field.offset = cur_offset;
                         cur_offset += field.size;
                         max_alignment = max_alignment.max(field.alignment);
                         cur_offset += size;
                         max_alignment = max_alignment.max(alignment);
+                    }
                     mono_type.size = cur_offset;
                     mono_type.alignment = max_alignment;
                     self.size_alignment_stack.truncate(breadcrumb.first_size_alignment_idx);
                 },
                 DTV::Function(_) | DTV::Component(_) => {
                     unreachable!();
+                }
+            }
             // If here, then we completely layed out the current type. So move
             // to the next breadcrumb
-            self.breadcrumbs.pop();
+            self.memory_layout_breadcrumbs.pop();
+        }
         debug_assert!(self.size_alignment_stack.is_empty());
         // If here then all types have been layed out. What remains is to
         // compute the sizes/alignment/offsets of the heap variants of the
         // unions we have encountered.
         for entry in &self.encountered_types {
             if !entry.is_union {
                 continue;
+            }
             // First pass, use buffer to store size/alignment to prevent
             // borrowing issues.
             let poly_type = self.lookup.get(&entry.definition_id).unwrap();
             let definition = poly_type.definition.as_union();
             let mono_type = &definition.monomorphs[entry.monomorph_idx];
             for variant in &mono_type.variants {
                 if !variant.lives_on_heap {
                     continue;
+                }
                 debug_assert!(!variant.embedded.is_empty());
                 for embedded in &variant.embedded {
                     match self.get_memory_layout_or_breadcrumb(arch, &embedded.concrete_type) {
                         MemoryLayoutResult::TypeExists(size, alignment) => {
                             self.size_alignment_stack.push((size, alignment));
                         },
                         _ => unreachable!(),
+                    }
+                }
+            }
             // Second pass, apply the size/alignment values in our buffer
             let poly_type = self.lookup.get_mut(&entry.definition_id).unwrap();
             match &mut poly_type.definition {
                 DTV::Union(definition) => {
                     let mono_type = &mut definition.monomorphs[entry.monomorph_idx];
                     let mut max_size = 0;
                     let mut max_alignment = 1;
             let definition = poly_type.definition.as_union_mut();
             let mono_type = &mut definition.monomorphs[entry.monomorph_idx];
                     for variant in &mut mono_type.variants {
                         if !variant.lives_on_heap {
                             continue;
+                        }
             let mut max_size = 0;
             let mut max_alignment = 1;
             let mut size_alignment_idx = 0;
                         let mut variant_offset = 0;
                         let mut variant_alignment = 1;
                         debug_assert!(!variant.embedded.is_empty());
             for variant in &mut mono_type.variants {
                 if !variant.lives_on_heap {
                     continue;
+                }
                         for embedded in &mut variant.embedded {
                             match self.get_memory_layout_or_breadcrumb(ctx, &embedded.concrete_type) {
                                 MemoryLayoutResult::TypeExists(size, alignment) => {
                                     embedded.size = size;
                                     embedded.alignment = alignment;
                 let mut variant_offset = 0;
                 let mut variant_alignment = 1;
                                     align_offset_to(&mut variant_offset, alignment);
                                     embedded.alignment = variant_offset;
                 for embedded in &mut variant.embedded {
                     let (size, alignment) = self.size_alignment_stack[size_alignment_idx];
                     embedded.size = size;
                     embedded.alignment = alignment;
                     size_alignment_idx += 1;
                                     variant_offset += size;
                                     variant_alignment = variant_alignment.max(alignment);
                                 },
                                 _ => unreachable!(),
+                            }
+                        }
                     align_offset_to(&mut variant_offset, alignment);
                     embedded.alignment = variant_offset;
                         // Update heap size/alignment
                         max_size = max_size.max(variant_offset);
                         max_alignment = max_alignment.max(variant_alignment);
+                    }
                     variant_offset += size;
                     variant_alignment = variant_alignment.max(alignment);
+                }
                     if max_size != 0 {
                         // At least one entry lives on the heap
                         mono_type.heap_size = max_size;
                         mono_type.heap_alignment = max_alignment;
+                    }
                 },
                 _ => unreachable!(),
                 max_size = max_size.max(variant_offset);
                 max_alignment = max_alignment.max(variant_alignment);
+            }
             if max_size != 0 {
                 // At least one entry lives on the heap
                 mono_type.heap_size = max_size;
                 mono_type.heap_alignment = max_alignment;
+            }
+        }
         // And now, we're actually, properly, done
         self.encountered_types.clear();
+    }
-    fn get_memory_layout_or_breadcrumb(&self, ctx: &PassCtx, concrete_type: &ConcreteType) -> MemoryLayoutResult {
+    fn get_memory_layout_or_breadcrumb(&self, arch: &TargetArch, concrete_type: &ConcreteType) -> MemoryLayoutResult {
         use ConcreteTypePart as CTP;
         // Before we do any fancy shenanigans, we need to check if the concrete
         // type actually requires laying out memory.
         debug_assert!(!concrete_type.parts.is_empty());
         let (builtin_size, builtin_alignment) = match concrete_type.parts[0] {
             CTP::Void   => (0, 1),
-            CTP::Message => ctx.arch.array_size_alignment,
             CTP::Message => arch.array_size_alignment,
             CTP::Bool   => (1, 1),
             CTP::UInt8  => (1, 1),
             CTP::UInt16 => (2, 2),
             CTP::UInt32 => (4, 4),
             CTP::UInt64 => (8, 8),
             CTP::SInt8  => (1, 1),
             CTP::SInt16 => (2, 2),
             CTP::SInt32 => (4, 4),
             CTP::SInt64 => (8, 8),
             CTP::Character => (4, 4),
             CTP::String => ctx.arch.string_size_alignment,
             CTP::Array => ctx.arch.array_size_alignment,
             CTP::Slice => ctx.arch.array_size_alignment,
             CTP::Input => ctx.arch.port_size_alignment,
             CTP::Output => ctx.arch.port_size_alignment,
             CTP::String => arch.string_size_alignment,
             CTP::Array => arch.array_size_alignment,
             CTP::Slice => arch.array_size_alignment,
             CTP::Input => arch.port_size_alignment,
             CTP::Output => arch.port_size_alignment,
             CTP::Instance(definition_id, _) => {
                 // Special case where we explicitly return to simplify the
                 // return case for the builtins.
                 let entry = self.lookup.get(&definition_id).unwrap();
                 let monomorph_idx = entry.get_monomorph_index(concrete_type).unwrap();
                 if let Some((size, alignment)) = entry.get_monomorph_size_alignment(monomorph_idx) {
                     // Type has been layed out in memory
                     return MemoryLayoutResult::TypeExists(size, alignment);
                 } else {
-                    return MemoryLayoutResult::PushBreadcrumb(TypeLoopBreadcrumb {
+                    return MemoryLayoutResult::PushBreadcrumb(MemoryBreadcrumb{
                         definition_id,
                         monomorph_idx,
                         next_member: 0,
                         next_embedded: 0,
                         first_size_alignment_idx: self.size_alignment_stack.len(),
                     });
+                }
             },
             CTP::Function(_, _) | CTP::Component(_, _) => {
                 todo!("storage for 'function pointers'");
+            }
         };
         return MemoryLayoutResult::TypeExists(builtin_size, builtin_alignment);
+    }
     /// Returns tag concrete type (always a builtin integer type), the size of
     /// that type in bytes (and implicitly, its alignment)
     fn variant_tag_type_from_values(min_val: i64, max_val: i64) -> (ConcreteType, usize) {
         debug_assert!(min_val <= max_val);
         let (part, size) = if min_val >= 0 {
             // Can be an unsigned integer
             if max_val <= (u8::MAX as i64) {
                 (ConcreteTypePart::UInt8, 1)
             } else if max_val <= (u16::MAX as i64) {
                 (ConcreteTypePart::UInt16, 2)
             } else if max_val <= (u32::MAX as i64) {
                 (ConcreteTypePart::UInt32, 4)

src/protocol/parser/visitor.rs

➞

Show inline comments

 use crate::protocol::ast::*;
 use crate::protocol::input_source::ParseError;
 use crate::protocol::parser::{type_table::*, Module};
 use crate::protocol::symbol_table::{SymbolTable};
 type Unit = ();
 pub(crate) type VisitorResult = Result<Unit, ParseError>;
 /// Globally configured vector capacity for statement buffers in visitor
 /// implementations
 pub(crate) const STMT_BUFFER_INIT_CAPACITY: usize = 256;
 /// Globally configured vector capacity for expression buffers in visitor
 /// implementations
 pub(crate) const EXPR_BUFFER_INIT_CAPACITY: usize = 256;
 /// General context structure that is used while traversing the AST.
 /// TODO: Revise, visitor abstraction is starting to get in the way of programming
 pub(crate) struct Ctx<'p> {
     pub heap: &'p mut Heap,
     pub module: &'p mut Module,
     pub modules: &'p mut [Module],
     pub module_idx: usize, // currently considered module
     pub symbols: &'p mut SymbolTable,
     pub types: &'p mut TypeTable,
     pub arch: &'p crate::protocol::TargetArch,
+}
 impl<'p> Ctx<'p> {
     /// Returns module `modules[module_idx]`
     pub(crate) fn module(&self) -> &Module {
         &self.modules[self.module_idx]
+    }
     pub(crate) fn module_mut(&mut self) -> &mut Module {
         &mut self.modules[self.module_idx]
+    }
+}
 /// Visitor is a generic trait that will fully walk the AST. The default
 /// implementation of the visitors is to not recurse. The exception is the
 /// top-level `visit_definition`, `visit_stmt` and `visit_expr` methods, which
 /// call the appropriate visitor function.
 pub(crate) trait Visitor {
     // Entry point
     fn visit_module(&mut self, ctx: &mut Ctx) -> VisitorResult {
         let mut def_index = 0;
         let module_root_id = ctx.modules[ctx.module_idx].root_id;
         loop {
             let definition_id = {
-                let root = &ctx.heap[ctx.module.root_id];
+                let root = &ctx.heap[module_root_id];
                 if def_index >= root.definitions.len() {
                     return Ok(())
+                }
                 root.definitions[def_index]
             };
             self.visit_definition(ctx, definition_id)?;
             def_index += 1;
+        }
+    }
     // Definitions
     // --- enum matching
     fn visit_definition(&mut self, ctx: &mut Ctx, id: DefinitionId) -> VisitorResult {
         match &ctx.heap[id] {
             Definition::Enum(def) => {
                 let def = def.this;
                 self.visit_enum_definition(ctx, def)
             },
             Definition::Union(def) => {
                 let def = def.this;
                 self.visit_union_definition(ctx, def)
+            }

src/protocol/tests/parser_monomorphs.rs

➞

Show inline comments

 /// parser_monomorphs.rs
 ///
 /// Simple tests to make sure that all of the appropriate monomorphs are
 /// instantiated
 use super::*;
 #[test]
 fn test_struct_monomorphs() {
     Tester::new_single_source_expect_ok(
         "no polymorph",
         "struct Integer{ s32 field }"
     ).for_struct("Integer", |s| { s
         .assert_num_monomorphs(0);
         .assert_num_monomorphs(1)
         .assert_has_monomorph("Integer");
     });
     Tester::new_single_source_expect_ok(
         "single polymorph",
+        "
         struct Number<T>{ T number }
         func instantiator() -> s32 {
             auto a = Number<s8>{ number: 0 };
             auto b = Number<s8>{ number: 1 };
             auto c = Number<s32>{ number: 2 };
             auto d = Number<s64>{ number: 3 };
             auto e = Number<Number<s16>>{ number: Number{ number: 4 }};
             return 0;
+        }
+        "
     ).for_struct("Number", |s| { s
         .assert_has_monomorph("s8")
         .assert_has_monomorph("s16")
         .assert_has_monomorph("s32")
         .assert_has_monomorph("s64")
         .assert_has_monomorph("Number<s8>")
         .assert_has_monomorph("Number<s16>")
         .assert_has_monomorph("Number<s32>")
         .assert_has_monomorph("Number<s64>")
         .assert_has_monomorph("Number<Number<s16>>")
         .assert_num_monomorphs(5);
     }).for_function("instantiator", |f| { f
         .for_variable("a", |v| {v.assert_concrete_type("Number<s8>");} )
         .for_variable("e", |v| {v.assert_concrete_type("Number<Number<s16>>");} );
     });
+}
 #[test]
 fn test_enum_monomorphs() {
     Tester::new_single_source_expect_ok(
         "no polymorph",
+        "
         enum Answer{ Yes, No }
         func do_it() -> s32 { auto a = Answer::Yes; return 0; }
+        "
     ).for_enum("Answer", |e| { e
         .assert_num_monomorphs(0);
         .assert_num_monomorphs(1)
         .assert_has_monomorph("Answer");
     });
     // Note for reader: because the enum doesn't actually use the polymorphic
-    // variable, we expect to have 0 polymorphs: the type only has to be laid
+    // variable, we expect to have 1 monomorph: the type only has to be laid
     // out once.
     Tester::new_single_source_expect_ok(
         "single polymorph",
+        "
         enum Answer<T> { Yes, No }
         func instantiator() -> s32 {
             auto a = Answer<s8>::Yes;
             auto b = Answer<s8>::No;
             auto c = Answer<s32>::Yes;
             auto d = Answer<Answer<Answer<s64>>>::No;
             return 0;
+        }
+        "
     ).for_enum("Answer", |e| { e
         .assert_num_monomorphs(0);
         .assert_num_monomorphs(1)
         .assert_has_monomorph("Answer<s8>");
     });
+}
 #[test]
 fn test_union_monomorphs() {
     Tester::new_single_source_expect_ok(
         "no polymorph",
+        "
         union Trinary { Undefined, Value(bool) }
         func do_it() -> s32 { auto a = Trinary::Value(true); return 0; }
+        "
     ).for_union("Trinary", |e| { e
         .assert_num_monomorphs(0);
         .assert_num_monomorphs(1)
         .assert_has_monomorph("Trinary");
     });
     // TODO: Does this do what we want? Or do we expect the embedded monomorph
     //  Result<s8,s32> to be instantiated as well? I don't think so.
     Tester::new_single_source_expect_ok(
         "polymorphs",
+        "
         union Result<T, E>{ Ok(T), Err(E) }
         func instantiator() -> s32 {
             s16 a_s16 = 5;
             auto a = Result<s8, bool>::Ok(0);
             auto b = Result<bool, s8>::Ok(true);
             auto c = Result<Result<s8, s32>, Result<s16, s64>>::Err(Result::Ok(5));
             auto d = Result<Result<s8, s32>, auto>::Err(Result<auto, s64>::Ok(a_s16));
             return 0;
+        }
+        "
     ).for_union("Result", |e| { e
         .assert_num_monomorphs(4)
         .assert_has_monomorph("s8;bool")
         .assert_has_monomorph("bool;s8")
         .assert_has_monomorph("Result<s8,s32>;Result<s16,s64>")
         .assert_has_monomorph("s16;s64");
         .assert_num_monomorphs(5)
         .assert_has_monomorph("Result<s8,bool>")
         .assert_has_monomorph("Result<bool,s8>")
         .assert_has_monomorph("Result<Result<s8,s32>,Result<s16,s64>>")
         .assert_has_monomorph("Result<s8,s32>")
         .assert_has_monomorph("Result<s16,s64>");
     }).for_function("instantiator", |f| { f
         .for_variable("d", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("Result<Result<s8,s32>,Result<s16,s64>>");
         });
     });
+}
@@ \ No newline at end of file @@

src/protocol/tests/parser_types.rs

➞

Show inline comments

 /// parser_types.rs
 ///
 /// Tests for (infinite) type construction
 use super::*;
 #[test]
 fn test_invalid_struct_type_loops() {
     Tester::new_single_source_expect_err(
         "self-referential struct",
         "struct Foo { Foo foo }"
     ).error(|e| { e
         .assert_occurs_at(0, "Foo {")
-        .assert_msg_has(0, "cyclic type");
+        .assert_msg_has(0, "infinitely large type");
     });
+}
 #[test]
 fn test_invalid_union_type_loops() {
     Tester::new_single_source_expect_err(
         "self-referential union",
         "union Foo { One(Foo) }"
     ).error(|e| { e
         .assert_occurs_at(0, "Foo {")
-        .assert_msg_has(0, "cyclic type");
+        .assert_msg_has(0, "infinitely large type");
     });
     Tester::new_single_source_expect_err(
         "two-cycle union",
+        "
         union UOne { Two(UTwo) }
         union UTwo { One(UOne) }
+        "
     ).error(|e| { e
         .assert_occurs_at(0, "UOne")
         .assert_msg_has(0, "cyclic type");
         .assert_msg_has(0, "infinitely large type");
     });
+}
 #[test]
 fn test_valid_loops() {
     // Linked-list like thing
     Tester::new_single_source_expect_ok(
         "linked list",
+        "
         struct Entry { u32 number, Link next }
         union Link { Next(Entry), None }
+        "
     ).for_struct("Entry", |s| {
         s.assert_size_alignment("Entry", 24, 8); // [4 'number', 4 'pad', x 'union tag', 8-x 'padding', 8 pointer]
     }).for_union("Link", |u| {
         u.assert_size_alignment("Link", 16, 8, 24, 8);
     });
     // Tree-like thing, version 1
     Tester::new_single_source_expect_ok(
         "tree, optional children",
+        "
         union Option<T> { Some(T), None }
         struct Node {
             u32 value,
             Option<Node> left,
             Option<Node> right,
+        }
+        "
     ).for_struct("Node", |s| {
         s.assert_size_alignment("Node", 40, 8);
     }).for_union("Option", |u| {
         u.assert_size_alignment("Option<Node>", 16, 8, 40, 8);
     });
     // Tree-like thing, version 2
     Tester::new_single_source_expect_ok(
         "tree, with left/right link",
+        "
         union Option<T> { Some(T), None }
         struct Link { Node left, Node right }
         struct Node { u32 value, Option<Link> link }
+        "
     ).for_struct("Node", |s| {
         s.assert_size_alignment("Node", 24, 8);
     }).for_struct("Link", |s| {
         s.assert_size_alignment("Link", 48, 8);
     }).for_union("Option", |u| {
         u.assert_size_alignment("Option<Link>", 16, 8, 48, 8);
     });
+}
@@ \ No newline at end of file @@

src/protocol/tests/utils.rs

➞

Show inline comments

 use crate::collections::StringPool;
 use crate::protocol::{
     Module,
     ast::*,
     input_source::*,
     parser::{
         Parser,
-        type_table::{TypeTable, DefinedTypeVariant},
+        type_table::*,
         symbol_table::SymbolTable,
         token_parsing::*,
     },
     eval::*,
 };
 // Carries information about the test into utility structures for builder-like
 // assertions
 #[derive(Clone, Copy)]
 struct TestCtx<'a> {
     test_name: &'a str,
     heap: &'a Heap,
     modules: &'a Vec<Module>,
     types: &'a TypeTable,
     symbols: &'a SymbolTable,
+}
 //------------------------------------------------------------------------------
 // Interface for parsing and compiling
 //------------------------------------------------------------------------------
 pub(crate) struct Tester {
     test_name: String,
     sources: Vec<String>
@@ @@ -128,101 +128,107 @@ pub(crate) struct AstOkTester { @@
     symbols: SymbolTable,
     types: TypeTable,
     pool: StringPool, // This is stored because if we drop it on the floor, we lose all our `StringRef<'static>`s
+}
 impl AstOkTester {
     fn new(test_name: String, parser: Parser) -> Self {
         Self {
             test_name,
             modules: parser.modules.into_iter().map(|module| Module{
                 source: module.source,
                 root_id: module.root_id,
                 name: module.name.map(|(_, name)| name)
             }).collect(),
             heap: parser.heap,
             symbols: parser.symbol_table,
             types: parser.type_table,
             pool: parser.string_pool,
+        }
+    }
     pub(crate) fn for_struct<F: Fn(StructTester)>(self, name: &str, f: F) -> Self {
         let mut found = false;
         for definition in self.heap.definitions.iter() {
             if let Definition::Struct(definition) = definition {
                 if definition.identifier.value.as_str() != name {
             if let Definition::Struct(ast_definition) = definition {
                 if ast_definition.identifier.value.as_str() != name {
                     continue;
+                }
                 // Found struct with the same name
                 let tester = StructTester::new(self.ctx(), definition);
                 let definition_id = ast_definition.this.upcast();
                 let type_entry = self.types.get_base_definition(&definition_id).unwrap();
                 let type_definition = type_entry.definition.as_struct();
                 let tester = StructTester::new(self.ctx(), ast_definition, type_definition);
                 f(tester);
                 found = true;
                 break
+            }
+        }
         assert!(
             found, "[{}] Failed to find definition for struct '{}'",
             self.test_name, name
         );
         self
+    }
     pub(crate) fn for_enum<F: Fn(EnumTester)>(self, name: &str, f: F) -> Self {
         let mut found = false;
         for definition in self.heap.definitions.iter() {
             if let Definition::Enum(definition) = definition {
                 if definition.identifier.value.as_str() != name {
                     continue;
+                }
                 // Found enum with the same name
                 let tester = EnumTester::new(self.ctx(), definition);
                 f(tester);
                 found = true;
                 break;
+            }
+        }
         assert!(
             found, "[{}] Failed to find definition for enum '{}'",
             self.test_name, name
         );
         self
+    }
     pub(crate) fn for_union<F: Fn(UnionTester)>(self, name: &str, f: F) -> Self {
         let mut found = false;
         for definition in self.heap.definitions.iter() {
             if let Definition::Union(definition) = definition {
                 if definition.identifier.value.as_str() != name {
                     continue;
+                }
                 // Found union with the same name
                 let tester = UnionTester::new(self.ctx(), definition);
                 let definition_id = definition.this.upcast();
                 let base_type = self.types.get_base_definition(&definition_id).unwrap();
                 let tester = UnionTester::new(self.ctx(), definition, &base_type.definition.as_union());
                 f(tester);
                 found = true;
                 break;
+            }
+        }
         assert!(
             found, "[{}] Failed to find definition for union '{}'",
             self.test_name, name
         );
         self
+    }
     pub(crate) fn for_function<F: FnOnce(FunctionTester)>(self, name: &str, f: F) -> Self {
         let mut found = false;
         for definition in self.heap.definitions.iter() {
             if let Definition::Function(definition) = definition {
                 if definition.identifier.value.as_str() != name {
                     continue;
+                }
                 // Found function
                 let tester = FunctionTester::new(self.ctx(), definition);
                 f(tester);
@@ @@ -236,108 +242,121 @@ impl AstOkTester { @@
         assert!(
             false, "[{}] failed to find definition for function '{}'",
             self.test_name, name
         );
         unreachable!();
+    }
     fn ctx(&self) -> TestCtx {
         TestCtx{
             test_name: &self.test_name,
             modules: &self.modules,
             heap: &self.heap,
             types: &self.types,
             symbols: &self.symbols,
+        }
+    }
+}
 //------------------------------------------------------------------------------
 // Utilities for successful compilation
 //------------------------------------------------------------------------------
 pub(crate) struct StructTester<'a> {
     ctx: TestCtx<'a>,
     def: &'a StructDefinition,
     ast_def: &'a StructDefinition,
     type_def: &'a StructType,
+}
 impl<'a> StructTester<'a> {
     fn new(ctx: TestCtx<'a>, def: &'a StructDefinition) -> Self {
         Self{ ctx, def }
     fn new(ctx: TestCtx<'a>, ast_def: &'a StructDefinition, type_def: &'a StructType) -> Self {
         Self{ ctx, ast_def, type_def }
+    }
     pub(crate) fn assert_num_fields(self, num: usize) -> Self {
         assert_eq!(
-            num, self.def.fields.len(),
+            num, self.ast_def.fields.len(),
             "[{}] Expected {} struct fields, but found {} for {}",
-            self.ctx.test_name, num, self.def.fields.len(), self.assert_postfix()
+            self.ctx.test_name, num, self.ast_def.fields.len(), self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_num_monomorphs(self, num: usize) -> Self {
-        let (is_equal, num_encountered) = has_equal_num_monomorphs(self.ctx, num, self.def.this.upcast());
+        let (is_equal, num_encountered) = has_equal_num_monomorphs(self.ctx, num, self.ast_def.this.upcast());
         assert!(
             is_equal, "[{}] Expected {} monomorphs, but got {} for {}",
             self.ctx.test_name, num, num_encountered, self.assert_postfix()
         );
         self
+    }
     /// Asserts that a monomorph exist, separate polymorphic variable types by
     /// a semicolon.
     pub(crate) fn assert_has_monomorph(self, serialized_monomorph: &str) -> Self {
-        let (has_monomorph, serialized) = has_monomorph(self.ctx, self.def.this.upcast(), serialized_monomorph);
+        let (has_monomorph, serialized) = has_monomorph(self.ctx, self.ast_def.this.upcast(), serialized_monomorph);
         assert!(
             has_monomorph, "[{}] Expected to find monomorph {}, but got {} for {}",
+            has_monomorph.is_some(), "[{}] Expected to find monomorph {}, but got {} for {}",
             self.ctx.test_name, serialized_monomorph, &serialized, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_size_alignment(mut self, monomorph: &str, size: usize, alignment: usize) -> Self {
         self = self.assert_has_monomorph(monomorph);
         let (mono_idx, _) = has_monomorph(self.ctx, self.ast_def.this.upcast(), monomorph);
         let mono_idx = mono_idx.unwrap();
         let mono = &self.type_def.monomorphs[mono_idx];
         assert!(
             mono.size == size && mono.alignment == alignment,
             "[{}] Expected (size,alignment) of ({}, {}), but got ({}, {}) for {}",
             self.ctx.test_name, size, alignment, mono.size, mono.alignment, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn for_field<F: Fn(StructFieldTester)>(self, name: &str, f: F) -> Self {
         // Find field with specified name
-        for field in &self.def.fields {
+        for field in &self.ast_def.fields {
             if field.field.value.as_str() == name {
                 let tester = StructFieldTester::new(self.ctx, field);
                 f(tester);
                 return self;
+            }
+        }
         assert!(
             false, "[{}] Could not find struct field '{}' for {}",
             self.ctx.test_name, name, self.assert_postfix()
         );
         unreachable!();
+    }
     fn assert_postfix(&self) -> String {
         let mut v = String::new();
         v.push_str("Struct{ name: ");
-        v.push_str(self.def.identifier.value.as_str());
+        v.push_str(self.ast_def.identifier.value.as_str());
         v.push_str(", fields: [");
-        for (field_idx, field) in self.def.fields.iter().enumerate() {
+        for (field_idx, field) in self.ast_def.fields.iter().enumerate() {
             if field_idx != 0 { v.push_str(", "); }
             v.push_str(field.field.value.as_str());
+        }
         v.push_str("] }");
+        v
+    }
+}
 pub(crate) struct StructFieldTester<'a> {
     ctx: TestCtx<'a>,
     def: &'a StructFieldDefinition,
+}
 impl<'a> StructFieldTester<'a> {
     fn new(ctx: TestCtx<'a>, def: &'a StructFieldDefinition) -> Self {
         Self{ ctx, def }
+    }
     pub(crate) fn assert_parser_type(self, expected: &str) -> Self {
         let mut serialized_type = String::new();
         serialize_parser_type(&mut serialized_type, &self.ctx.heap, &self.def.parser_type);
         assert_eq!(
             expected, &serialized_type,
             "[{}] Expected type '{}', but got '{}' for {}",
@@ @@ -363,111 +382,132 @@ impl<'a> EnumTester<'a> { @@
         Self{ ctx, def }
+    }
     pub(crate) fn assert_num_variants(self, num: usize) -> Self {
         assert_eq!(
             num, self.def.variants.len(),
             "[{}] Expected {} enum variants, but found {} for {}",
             self.ctx.test_name, num, self.def.variants.len(), self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_num_monomorphs(self, num: usize) -> Self {
         let (is_equal, num_encountered) = has_equal_num_monomorphs(self.ctx, num, self.def.this.upcast());
         assert!(
             is_equal, "[{}] Expected {} monomorphs, but got {} for {}",
             self.ctx.test_name, num, num_encountered, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_has_monomorph(self, serialized_monomorph: &str) -> Self {
         let (has_monomorph, serialized) = has_monomorph(self.ctx, self.def.this.upcast(), serialized_monomorph);
         assert!(
             has_monomorph, "[{}] Expected to find monomorph {}, but got {} for {}",
+            has_monomorph.is_some(), "[{}] Expected to find monomorph {}, but got {} for {}",
             self.ctx.test_name, serialized_monomorph, serialized, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_postfix(&self) -> String {
         let mut v = String::new();
         v.push_str("Enum{ name: ");
         v.push_str(self.def.identifier.value.as_str());
         v.push_str(", variants: [");
         for (variant_idx, variant) in self.def.variants.iter().enumerate() {
             if variant_idx != 0 { v.push_str(", "); }
             v.push_str(variant.identifier.value.as_str());
+        }
         v.push_str("] }");
+        v
+    }
+}
 pub(crate) struct UnionTester<'a> {
     ctx: TestCtx<'a>,
     def: &'a UnionDefinition,
     ast_def: &'a UnionDefinition,
     type_def: &'a UnionType,
+}
 impl<'a> UnionTester<'a> {
     fn new(ctx: TestCtx<'a>, def: &'a UnionDefinition) -> Self {
         Self{ ctx, def }
     fn new(ctx: TestCtx<'a>, ast_def: &'a UnionDefinition, type_def: &'a UnionType) -> Self {
         Self{ ctx, ast_def, type_def }
+    }
     pub(crate) fn assert_num_variants(self, num: usize) -> Self {
         assert_eq!(
-            num, self.def.variants.len(),
+            num, self.ast_def.variants.len(),
             "[{}] Expected {} union variants, but found {} for {}",
-            self.ctx.test_name, num, self.def.variants.len(), self.assert_postfix()
+            self.ctx.test_name, num, self.ast_def.variants.len(), self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_num_monomorphs(self, num: usize) -> Self {
-        let (is_equal, num_encountered) = has_equal_num_monomorphs(self.ctx, num, self.def.this.upcast());
+        let (is_equal, num_encountered) = has_equal_num_monomorphs(self.ctx, num, self.ast_def.this.upcast());
         assert!(
             is_equal, "[{}] Expected {} monomorphs, but got {} for {}",
             self.ctx.test_name, num, num_encountered, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_has_monomorph(self, serialized_monomorph: &str) -> Self {
-        let (has_monomorph, serialized) = has_monomorph(self.ctx, self.def.this.upcast(), serialized_monomorph);
+        let (has_monomorph, serialized) = has_monomorph(self.ctx, self.ast_def.this.upcast(), serialized_monomorph);
         assert!(
             has_monomorph, "[{}] Expected to find monomorph {}, but got {} for {}",
+            has_monomorph.is_some(), "[{}] Expected to find monomorph {}, but got {} for {}",
             self.ctx.test_name, serialized_monomorph, serialized, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_size_alignment(
         mut self, serialized_monomorph: &str,
         stack_size: usize, stack_alignment: usize, heap_size: usize, heap_alignment: usize
     ) -> Self {
         self = self.assert_has_monomorph(serialized_monomorph);
         let (mono_idx, _) = has_monomorph(self.ctx, self.ast_def.this.upcast(), serialized_monomorph);
         let mono_idx = mono_idx.unwrap();
         let mono = &self.type_def.monomorphs[mono_idx];
         assert!(
             stack_size == mono.stack_size && stack_alignment == mono.stack_alignment &&
                 heap_size == mono.heap_size && heap_alignment == mono.heap_alignment,
             "[{}] Expected (stack | heap) (size, alignment) of ({}, {} | {}, {}), but got ({}, {} | {}, {}) for {}",
             self.ctx.test_name,
             stack_size, stack_alignment, heap_size, heap_alignment,
             mono.stack_size, mono.stack_alignment, mono.heap_size, mono.heap_alignment,
             self.assert_postfix()
         );
         self
+    }
     fn assert_postfix(&self) -> String {
         let mut v = String::new();
         v.push_str("Union{ name: ");
-        v.push_str(self.def.identifier.value.as_str());
+        v.push_str(self.ast_def.identifier.value.as_str());
         v.push_str(", variants: [");
-        for (variant_idx, variant) in self.def.variants.iter().enumerate() {
+        for (variant_idx, variant) in self.ast_def.variants.iter().enumerate() {
             if variant_idx != 0 { v.push_str(", "); }
             v.push_str(variant.identifier.value.as_str());
+        }
         v.push_str("] }");
+        v
+    }
+}
 pub(crate) struct FunctionTester<'a> {
     ctx: TestCtx<'a>,
     def: &'a FunctionDefinition,
+}
 impl<'a> FunctionTester<'a> {
     fn new(ctx: TestCtx<'a>, def: &'a FunctionDefinition) -> Self {
         Self{ ctx, def }
+    }
     pub(crate) fn for_variable<F: Fn(VariableTester)>(self, name: &str, f: F) -> Self {
         // Seek through the blocks in order to find the variable
         let wrapping_block_id = seek_stmt(
             self.ctx.heap, self.def.body.upcast(),
             &|stmt| {
                 if let Statement::Block(block) = stmt {
@@ @@ -847,98 +887,93 @@ impl<'a> ErrorTester<'a> { @@
         v.push(']');
+        v
+    }
+}
 //------------------------------------------------------------------------------
 // Generic utilities
 //------------------------------------------------------------------------------
 fn has_equal_num_monomorphs(ctx: TestCtx, num: usize, definition_id: DefinitionId) -> (bool, usize) {
     use DefinedTypeVariant::*;
     let type_def = ctx.types.get_base_definition(&definition_id).unwrap();
     let num_on_type = match &type_def.definition {
         Struct(v) => v.monomorphs.len(),
         Enum(v) => v.monomorphs.len(),
         Union(v) => v.monomorphs.len(),
         Function(v) => v.monomorphs.len(),
         Component(v) => v.monomorphs.len(),
     };
     (num_on_type == num, num_on_type)
+}
-fn has_monomorph(ctx: TestCtx, definition_id: DefinitionId, serialized_monomorph: &str) -> (bool, String) {
+fn has_monomorph(ctx: TestCtx, definition_id: DefinitionId, serialized_monomorph: &str) -> (Option<usize>, String) {
     use DefinedTypeVariant::*;
     let type_def = ctx.types.get_base_definition(&definition_id).unwrap();
     // Note: full_buffer is just for error reporting
     let mut full_buffer = String::new();
     let mut has_match = false;
     let serialize_monomorph = |monomorph: &Vec<ConcreteType>| -> String {
         let mut buffer = String::new();
         for (element_idx, element) in monomorph.iter().enumerate() {
             if element_idx != 0 {
                 buffer.push(';');
+            }
             serialize_concrete_type(&mut buffer, ctx.heap, definition_id, element);
+        }
         buffer
     };
     let mut has_match = None;
     full_buffer.push('[');
-    let mut append_to_full_buffer = |buffer: String| {
+    let mut append_to_full_buffer = |concrete_type: &ConcreteType, mono_idx: usize| {
         if full_buffer.len() != 1 {
             full_buffer.push_str(", ");
+        }
         full_buffer.push('"');
         full_buffer.push_str(&buffer);
         let first_idx = full_buffer.len();
         serialize_concrete_type(&mut full_buffer, ctx.heap, definition_id, concrete_type);
         if &full_buffer[first_idx..] == serialized_monomorph {
             has_match = Some(mono_idx);
+        }
         full_buffer.push('"');
     };
     match &type_def.definition {
         Enum(_) | Union(_) | Struct(_) => {
             let monomorphs = type_def.definition.data_monomorphs();
             for monomorph in monomorphs.iter() {
                 let buffer = serialize_monomorph(&monomorph.poly_args);
                 if buffer == serialized_monomorph {
                     has_match = true;
+                }
                 append_to_full_buffer(buffer);
         Enum(definition) => {
             for (mono_idx, mono) in definition.monomorphs.iter().enumerate() {
                 append_to_full_buffer(&mono.concrete_type, mono_idx);
+            }
         },
         Union(definition) => {
             for (mono_idx, mono) in definition.monomorphs.iter().enumerate() {
                 append_to_full_buffer(&mono.concrete_type, mono_idx);
+            }
         },
         Struct(definition) => {
             for (mono_idx, mono) in definition.monomorphs.iter().enumerate() {
                 append_to_full_buffer(&mono.concrete_type, mono_idx);
+            }
         },
         Function(_) | Component(_) => {
             let monomorphs = type_def.definition.procedure_monomorphs();
             for monomorph in monomorphs.iter() {
                 let buffer = serialize_monomorph(&monomorph.poly_args);
                 if buffer == serialized_monomorph {
                     has_match = true;
+                }
                 append_to_full_buffer(buffer);
             for (mono_idx, mono) in monomorphs.iter().enumerate() {
                 append_to_full_buffer(&mono.concrete_type, mono_idx);
+            }
+        }
+    }
     full_buffer.push(']');
     (has_match, full_buffer)
+}
 fn serialize_parser_type(buffer: &mut String, heap: &Heap, parser_type: &ParserType) {
     use ParserTypeVariant as PTV;
     fn serialize_variant(buffer: &mut String, heap: &Heap, parser_type: &ParserType, mut idx: usize) -> usize {
         match &parser_type.elements[idx].variant {
             PTV::Void => buffer.push_str("void"),
             PTV::InputOrOutput => {
                 buffer.push_str("portlike<");
                 idx = serialize_variant(buffer, heap, parser_type, idx + 1);
                 buffer.push('>');
             },
             PTV::ArrayLike => {
                 idx = serialize_variant(buffer, heap, parser_type, idx + 1);
                 buffer.push_str("[???]");
             },
             CTP::SInt32 => write_bytes(buffer, KW_TYPE_SINT32),
             CTP::SInt64 => write_bytes(buffer, KW_TYPE_SINT64),
             CTP::Character => write_bytes(buffer, KW_TYPE_CHAR),
             CTP::String => write_bytes(buffer, KW_TYPE_STRING),
             CTP::Array => {
                 idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);
                 buffer.push_str("[]");
             },
             CTP::Slice => {
                 idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);
                 buffer.push_str("[..]");
             },
             CTP::Input => {
                 write_bytes(buffer, KW_TYPE_IN_PORT);
                 buffer.push('<');
                 idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);
                 buffer.push('>');
             },
             CTP::Output => {
                 write_bytes(buffer, KW_TYPE_OUT_PORT);
                 buffer.push('<');
                 idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);
                 buffer.push('>');
             },
             CTP::Instance(definition_id, num_sub) => {
             CTP::Instance(definition_id, num_sub) |
             CTP::Function(definition_id, num_sub) |
             CTP::Component(definition_id, num_sub) => {
                 let definition_name = heap[*definition_id].identifier();
                 buffer.push_str(definition_name.value.as_str());
                 if *num_sub != 0 {
                     buffer.push('<');
                     for sub_idx in 0..*num_sub {
                         if sub_idx != 0 { buffer.push(','); }
                         idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);
+                    }
                     buffer.push('>');
+                }
+            }
+            },
+        }
         idx
+    }
     serialize_recursive(buffer, heap, poly_vars, concrete, 0);
+}
 fn seek_def_in_modules<'a>(heap: &Heap, modules: &'a [Module], def_id: DefinitionId) -> Option<&'a Module> {
     for module in modules {
         let root = &heap.protocol_descriptions[module.root_id];
         for definition in &root.definitions {
             if *definition == def_id {
                 return Some(module)
+            }
+        }
+    }
     None
+}
 fn seek_stmt<F: Fn(&Statement) -> bool>(heap: &Heap, start: StatementId, f: &F) -> Option<StatementId> {
     let stmt = &heap[start];
     if f(stmt) { return Some(start); }

0 comments (0 inline, 0 general)