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

Changeset - 0385b9bf770e

Parent rev.

Child rev.

[Not reviewed]

0 2 0

MH - 4 years ago 2021-12-14 22:57:29
contact@maxhenger.nl

Remove unused DefinitionId, and reduce util struct size, in TypeTable breadcrumbs

2 files changed with 147 insertions and 158 deletions:

src/protocol/parser/type_table.rs

147

152

src/protocol/tests/utils.rs

0 comments (0 inline, 0 general)

src/protocol/parser/type_table.rs

➞

Show inline comments

@@ @@ -248,626 +248,624 @@ pub struct MonomorphExpression { @@
+}
 //------------------------------------------------------------------------------
 // Type monomorph storage
 //------------------------------------------------------------------------------
 /// Generic monomorph has a specific concrete type, a size and an alignment.
 /// Extra data is in the `MonomorphVariant` per kind of type.
 pub(crate) struct TypeMonomorph {
     pub concrete_type: ConcreteType,
     pub size: usize,
     pub alignment: usize,
     pub variant: MonomorphVariant,
+}
 pub(crate) enum MonomorphVariant {
     Enum, // no extra data
     Struct(StructMonomorph),
     Union(UnionMonomorph),
     Procedure(ProcedureMonomorph), // functions, components
     Tuple(TupleMonomorph),
+}
 impl MonomorphVariant {
     fn as_struct(&self) -> &StructMonomorph {
         match self {
             MonomorphVariant::Struct(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_struct_mut(&mut self) -> &mut StructMonomorph {
         match self {
             MonomorphVariant::Struct(v) => v,
             _ => unreachable!(),
+        }
+    }
     pub(crate) fn as_union(&self) -> &UnionMonomorph {
         match self {
             MonomorphVariant::Union(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_union_mut(&mut self) -> &mut UnionMonomorph {
         match self {
             MonomorphVariant::Union(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_tuple(&self) -> &TupleMonomorph {
         match self {
             MonomorphVariant::Tuple(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_tuple_mut(&mut self) -> &mut TupleMonomorph {
         match self {
             MonomorphVariant::Tuple(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_procedure(&self) -> &ProcedureMonomorph {
         match self {
             MonomorphVariant::Procedure(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_procedure_mut(&mut self) -> &mut ProcedureMonomorph {
         match self {
             MonomorphVariant::Procedure(v) => v,
             _ => unreachable!(),
+        }
+    }
+}
 /// Struct monomorph
 pub struct StructMonomorph {
     pub fields: Vec<StructMonomorphField>,
+}
 pub struct StructMonomorphField {
     pub concrete_type: ConcreteType,
     pub size: usize,
     pub alignment: usize,
     pub offset: usize,
+}
 /// Union monomorph
 pub struct UnionMonomorph {
     pub variants: Vec<UnionMonomorphVariant>,
     pub tag_size: usize, // copied from `UnionType` upon monomorph construction.
     // note that the stack size is in the `TypeMonomorph` struct. This size and
     // alignment will include the size of the union tag.
     //
     // heap_size contains the allocated size of the union in the case it
     // is used to break a type loop. If it is 0, then it doesn't require
     // allocation and lives entirely on the stack.
     pub heap_size: usize,
     pub heap_alignment: usize,
+}
 pub struct UnionMonomorphVariant {
     pub lives_on_heap: bool,
     pub embedded: Vec<UnionMonomorphEmbedded>,
+}
 pub struct UnionMonomorphEmbedded {
     pub concrete_type: ConcreteType,
     // Note that the meaning of the offset (and alignment) depend on whether or
     // not the variant lives on the stack/heap. If it lives on the stack then
     // they refer to the offset from the start of the union value (so the first
     // embedded type lives at a non-zero offset, because the union tag sits in
     // the front). If it lives on the heap then it refers to the offset from the
     // allocated memory region (so the first embedded type lives at a 0 offset).
     pub size: usize,
     pub alignment: usize,
     pub offset: usize,
+}
 /// Procedure (functions and components of all possible types) monomorph. Also
 /// stores the expression type data from the typechecking/inferencing pass.
 pub struct ProcedureMonomorph {
     // Expression data for one particular monomorph
     pub arg_types: Vec<ConcreteType>,
     pub expr_data: Vec<MonomorphExpression>,
+}
 /// Tuple monomorph. Again a kind of exception because one cannot define a named
 /// tuple type containing explicit polymorphic variables. But again: we need to
 /// store size/offset/alignment information, so we do it here.
 pub struct TupleMonomorph {
     pub members: Vec<TupleMonomorphMember>
+}
 pub struct TupleMonomorphMember {
     pub concrete_type: ConcreteType,
     pub size: usize,
     pub alignment: usize,
     pub offset: usize,
+}
 /// Key used to perform lookups in the monomorph table. It computes a hash of
 /// the type while not taking the unused polymorphic variables of the base type
 /// into account (e.g. `struct Foo<A,B>{ A field }`, here `B` is an unused
 /// polymorphic variable).
 struct MonomorphKey {
     parts: Vec<ConcreteTypePart>,
     in_use: Vec<bool>,
+    in_use: Vec<bool>, // TODO: @Performance, limit num args and use two `u64` as bitflags or something
+}
 use std::hash::*;
 impl Hash for MonomorphKey {
     fn hash<H: Hasher>(&self, state: &mut H) {
         // if `in_use` is empty, then we may assume the type is not polymorphic
         // (or all types are in use)
         if self.in_use.is_empty() {
             self.parts.hash(state);
         } else {
             // type is polymorphic
             self.parts[0].hash(state);
             // note: hash is computed in a unique way, because practically
             // speaking `in_use` is fixed per base type. So we cannot have the
             // same base type (hence: a type with the same DefinitionId) with
             // different different polymorphic variables in use.
             let mut in_use_index = 0;
             for section in ConcreteTypeIter::new(self.parts.as_slice(), 0) {
                 if self.in_use[in_use_index] {
                     section.hash(state);
+                }
                 in_use_index += 1;
+            }
+        }
+    }
+}
 impl PartialEq for MonomorphKey {
     fn eq(&self, other: &Self) -> bool {
         if self.in_use.is_empty() {
             let temp_result = self.parts == other.parts;
             return temp_result;
         } else {
             // Outer type does not match
             if self.parts[0] != other.parts[0] {
                 return false;
+            }
             debug_assert_eq!(self.parts[0].num_embedded() as usize, self.in_use.len());
             let mut iter_self = ConcreteTypeIter::new(self.parts.as_slice(), 0);
             let mut iter_other = ConcreteTypeIter::new(other.parts.as_slice(), 0);
             let mut index = 0;
             while let Some(section_self) = iter_self.next() {
                 let section_other = iter_other.next().unwrap();
                 let in_use = self.in_use[index];
                 index += 1;
                 if !in_use {
                     continue;
+                }
                 if section_self != section_other {
                     return false;
+                }
+            }
             return true;
+        }
+    }
+}
 impl Eq for MonomorphKey {}
 use std::cell::UnsafeCell;
 /// Lookup table for monomorphs. Wrapped in a special struct because we don't
 /// want to allocate for each lookup (what we really want is a HashMap that
 /// exposes it CompareFn and HashFn, but whatevs).
 pub(crate) struct MonomorphTable {
     lookup: HashMap<MonomorphKey, i32>, // indexes into `monomorphs`
     pub(crate) monomorphs: Vec<TypeMonomorph>,
     // We use an UnsafeCell because this is only used internally per call to
     // `get_monomorph_index` calls. This is safe because `&TypeMonomorph`s
     // retrieved for this class remain valid when the key is mutated and the
     // type table is not multithreaded.
     //
     // I added this because we don't want to allocate for each lookup, hence we
     // need a reusable `key` internal to this class. This in turn makes
     // `get_monomorph_index` a mutable call. Now the code that calls this
     // function (even though we're not mutating the table!) needs a lot of extra
     // boilerplate. I opted for the `UnsafeCell` instead of the boilerplate.
     key: UnsafeCell<MonomorphKey>,
+}
 impl MonomorphTable {
     fn new() -> Self {
         return Self {
             lookup: HashMap::with_capacity(256),
             monomorphs: Vec::with_capacity(256),
             key: UnsafeCell::new(MonomorphKey{
                 parts: Vec::with_capacity(32),
                 in_use: Vec::with_capacity(32),
             }),
+        }
+    }
     fn insert_with_zero_size_and_alignment(&mut self, concrete_type: ConcreteType, in_use: &[PolymorphicVariable], variant: MonomorphVariant) -> i32 {
         let key = MonomorphKey{
             parts: Vec::from(concrete_type.parts.as_slice()),
             in_use: in_use.iter().map(|v| v.is_in_use).collect(),
         };
         let index = self.monomorphs.len();
         let _result = self.lookup.insert(key, index as i32);
         debug_assert!(_result.is_none()); // did not exist yet
         self.monomorphs.push(TypeMonomorph{
             concrete_type,
             size: 0,
             alignment: 0,
             variant,
         });
         return index as i32;
+    }
     fn get_monomorph_index(&self, parts: &[ConcreteTypePart], in_use: &[PolymorphicVariable]) -> Option<i32> {
         let key = unsafe {
             // Clear-and-extend to, at some point, prevent future allocations
             let key = &mut *self.key.get();
             key.parts.clear();
             key.parts.extend_from_slice(parts);
             key.in_use.clear();
             key.in_use.extend(in_use.iter().map(|v| v.is_in_use));
             &*key
         };
         match self.lookup.get(key) {
             Some(index) => return Some(*index),
             None => return None,
+        }
+    }
     #[inline]
     fn get(&self, index: i32) -> &TypeMonomorph {
         debug_assert!(index >= 0);
         return &self.monomorphs[index as usize];
+    }
     #[inline]
     fn get_mut(&mut self, index: i32) -> &mut TypeMonomorph {
         debug_assert!(index >= 0);
         return &mut self.monomorphs[index as usize];
+    }
     fn get_monomorph_size_alignment(&self, index: i32) -> Option<(usize, usize)> {
         let monomorph = self.get(index);
         if monomorph.size == 0 && monomorph.alignment == 0 {
             // If both are zero, then we wish to mean: we haven't actually
             // computed the size and alignment yet. So:
             return None;
         } else {
             return Some((monomorph.size, monomorph.alignment));
+        }
+    }
+}
 //------------------------------------------------------------------------------
 // Type table
 //------------------------------------------------------------------------------
 // Programmer note: keep this struct free of dynamically allocated memory
 #[derive(Clone)]
 struct TypeLoopBreadcrumb {
     definition_id: DefinitionId, // TODO: Check if it can be removed?
     monomorph_idx: i32,
     next_member: u32,
     next_embedded: u32, // for unions, the index into the variant's embedded types
+}
 #[derive(Clone)]
 struct MemoryBreadcrumb {
     definition_id: DefinitionId,
     monomorph_idx: i32,
     next_member: usize,
     next_embedded: usize,
     first_size_alignment_idx: usize,
     next_member: u32,
     next_embedded: u32,
     first_size_alignment_idx: u32,
+}
 #[derive(Debug, PartialEq, Eq)]
 enum TypeLoopResult {
     TypeExists,
     PushBreadcrumb(DefinitionId, ConcreteType),
     TypeLoop(usize), // index into vec of breadcrumbs at which the type matched
+}
 enum MemoryLayoutResult {
     TypeExists(usize, usize), // (size, alignment)
     PushBreadcrumb(MemoryBreadcrumb),
+}
 // TODO: @Optimize, initial memory-unoptimized implementation
 struct TypeLoopEntry {
     definition_id: DefinitionId,
     monomorph_idx: i32,
     is_union: bool,
+}
 struct TypeLoop {
     members: Vec<TypeLoopEntry>
+}
 pub struct TypeTable {
     /// Lookup from AST DefinitionId to a defined type. Also lookups for
     /// concrete type to monomorphs
     pub(crate) type_lookup: HashMap<DefinitionId, DefinedType>,
     pub(crate) mono_lookup: MonomorphTable,
     /// Breadcrumbs left behind while trying to find type loops. Also used to
     /// determine sizes of types when all type loops are detected.
     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{
             type_lookup: HashMap::with_capacity(128),
             mono_lookup: MonomorphTable::new(),
             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.type_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.type_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.type_lookup.len(), reserve_size, "mismatch in reserved size of type table"); // NOTE: Temp fix for builtin functions
         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.
         for definition_idx in 0..ctx.heap.definitions.len() {
             let definition_id = ctx.heap.definitions.get_id(definition_idx);
             let poly_type = self.type_lookup.get(&definition_id).unwrap();
             if !poly_type.definition.type_class().is_data_type() || !poly_type.poly_vars.is_empty() {
                 continue;
+            }
             // If here then the type is a data type without polymorphic
             // variables, but we might have instantiated it already, so:
             let concrete_parts = [ConcreteTypePart::Instance(definition_id, 0)];
             let mono_index = self.mono_lookup.get_monomorph_index(&concrete_parts, &[]);
             if mono_index.is_none() {
                 self.detect_and_resolve_type_loops_for(
                     modules, ctx.heap,
                     ConcreteType{
                         parts: vec![ConcreteTypePart::Instance(definition_id, 0)]
                     },
                 )?;
                 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
     #[inline]
     pub(crate) fn get_base_definition(&self, definition_id: &DefinitionId) -> Option<&DefinedType> {
         self.type_lookup.get(&definition_id)
+    }
     /// Returns the index into the monomorph type array if the procedure type
     /// already has a (reserved) monomorph.
     /// FIXME: This really shouldn't be called from within the runtime. See UnsafeCell in MonomorphTable
     #[inline]
     pub(crate) fn get_procedure_monomorph_index(&self, definition_id: &DefinitionId, type_parts: &[ConcreteTypePart]) -> Option<i32> {
         let base_type = self.type_lookup.get(definition_id).unwrap();
         return self.mono_lookup.get_monomorph_index(type_parts, &base_type.poly_vars);
+    }
     #[inline]
     pub(crate) fn get_monomorph(&self, monomorph_index: i32) -> &TypeMonomorph {
         return self.mono_lookup.get(monomorph_index);
+    }
     /// Returns a mutable reference to a procedure's monomorph expression data.
     /// Used by typechecker to fill in previously reserved type information
     #[inline]
     pub(crate) fn get_procedure_monomorph_mut(&mut self, monomorph_index: i32) -> &mut ProcedureMonomorph {
         debug_assert!(monomorph_index >= 0);
         let monomorph = self.mono_lookup.get_mut(monomorph_index);
         return monomorph.variant.as_procedure_mut();
+    }
     #[inline]
     pub(crate) fn get_procedure_monomorph(&self, monomorph_index: i32) -> &ProcedureMonomorph {
         debug_assert!(monomorph_index >= 0);
         let monomorph = self.mono_lookup.get(monomorph_index);
         return monomorph.variant.as_procedure();
+    }
     /// 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, concrete_type: ConcreteType) -> i32 {
         let base_type = self.type_lookup.get_mut(definition_id).unwrap();
         let mono_index = self.mono_lookup.insert_with_zero_size_and_alignment(
             concrete_type, &base_type.poly_vars, MonomorphVariant::Procedure(ProcedureMonomorph{
                 arg_types: Vec::new(),
                 expr_data: Vec::new(),
             })
         );
         return mono_index;
+    }
     /// 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], heap: &Heap, arch: &TargetArch, definition_id: DefinitionId, concrete_type: ConcreteType
     ) -> Result<i32, ParseError> {
         debug_assert_eq!(definition_id, get_concrete_type_definition(&concrete_type));
         // Check if the monomorph already exists
         let poly_type = self.type_lookup.get_mut(&definition_id).unwrap();
         if let Some(idx) = self.mono_lookup.get_monomorph_index(&concrete_type.parts, &poly_type.poly_vars) {
             return Ok(idx);
+        }
         // Doesn't exist, so instantiate a monomorph and determine its memory
         // layout.
         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(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.type_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"
                 ));
+            }
             enum_value += 1;
             if let EnumVariantValue::Integer(explicit_value) = variant.value {
                 enum_value = explicit_value;
+            }
             variants.push(EnumVariant{
                 identifier: variant.identifier.clone(),
                 value: enum_value,
             });
+        }
         // Determine tag size
         let mut min_enum_value = 0;
         let mut max_enum_value = 0;
         if !variants.is_empty() {
             min_enum_value = variants[0].value;
             max_enum_value = variants[0].value;
             for variant in variants.iter().skip(1) {
                 min_enum_value = min_enum_value.min(variant.value);
                 max_enum_value = max_enum_value.max(variant.value);
+            }
+        }
         let (tag_type, size_and_alignment) = Self::variant_tag_type_from_values(min_enum_value, max_enum_value);
         // Enum names and polymorphic args do not conflict
         Self::check_identifier_collision(
             modules, root_id, &variants, |variant| &variant.identifier, "enum variant"
         )?;
         // Polymorphic arguments cannot appear as embedded types, because
         // they can only consist of integer variants.
         Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
         let poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);
         self.type_lookup.insert(definition_id, DefinedType {
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Enum(EnumType{
                 variants,
                 minimum_tag_value: min_enum_value,
                 maximum_tag_value: max_enum_value,
                 tag_type,
                 size: size_and_alignment,
                 alignment: size_and_alignment
             }),
             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.type_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
                 )?;
@@ @@ -950,1209 +948,1206 @@ impl TypeTable { @@
         let is_polymorph = poly_vars.iter().any(|arg| arg.is_in_use);
         self.type_lookup.insert(definition_id, DefinedType{
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Struct(StructType{ fields }),
             poly_vars,
             is_polymorph
         });
         return Ok(())
+    }
     /// Builds base function type.
     fn build_base_function_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {
         debug_assert!(!self.type_lookup.contains_key(&definition_id), "base function already built");
         let definition = ctx.heap[definition_id].as_function();
         let root_id = definition.defined_in;
         // Check and construct return types and argument types.
         debug_assert_eq!(definition.return_types.len(), 1, "not one return type");
         for return_type in &definition.return_types {
             Self::check_member_parser_type(
                 modules, ctx, root_id, return_type, definition.builtin
             )?;
+        }
         let mut arguments = Vec::with_capacity(definition.parameters.len());
         for parameter_id in &definition.parameters {
             let parameter = &ctx.heap[*parameter_id];
             Self::check_member_parser_type(
                 modules, ctx, root_id, &parameter.parser_type, definition.builtin
             )?;
             arguments.push(FunctionArgument{
                 identifier: parameter.identifier.clone(),
                 parser_type: parameter.parser_type.clone(),
             });
+        }
         // Check conflict of identifiers
         Self::check_identifier_collision(
             modules, root_id, &arguments, |arg| &arg.identifier, "function argument"
         )?;
         Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
         // Construct internal representation of function type
         let mut poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);
         for return_type in &definition.return_types {
             Self::mark_used_polymorphic_variables(&mut poly_vars, return_type);
+        }
         for argument in &arguments {
             Self::mark_used_polymorphic_variables(&mut poly_vars, &argument.parser_type);
+        }
         let is_polymorph = poly_vars.iter().any(|arg| arg.is_in_use);
         self.type_lookup.insert(definition_id, DefinedType{
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Function(FunctionType{ return_types: definition.return_types.clone(), arguments }),
             poly_vars,
             is_polymorph
         });
         return Ok(());
+    }
     /// Builds base component type.
     fn build_base_component_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {
         debug_assert!(!self.type_lookup.contains_key(&definition_id), "base component already built");
         let definition = &ctx.heap[definition_id].as_component();
         let root_id = definition.defined_in;
         // Check the argument types
         let mut arguments = Vec::with_capacity(definition.parameters.len());
         for parameter_id in &definition.parameters {
             let parameter = &ctx.heap[*parameter_id];
             Self::check_member_parser_type(
                 modules, ctx, root_id, &parameter.parser_type, false
             )?;
             arguments.push(FunctionArgument{
                 identifier: parameter.identifier.clone(),
                 parser_type: parameter.parser_type.clone(),
             });
+        }
         // Check conflict of identifiers
         Self::check_identifier_collision(
             modules, root_id, &arguments, |arg| &arg.identifier, "connector argument"
         )?;
         Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
         // Construct internal representation of component
-        // FIXME: Marking used polymorphic variables on procedures requires
+        // TODO: Marking used polymorphic variables on procedures requires
         //  making sure that each is used in the body. For now, mark them all
         //  as required.
         let mut poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);
         // for argument in &arguments {
         //     Self::mark_used_polymorphic_variables(&mut poly_vars, &argument.parser_type);
         // }
         for poly_var in &mut poly_vars {
             poly_var.is_in_use = true;
+        }
         let is_polymorph = poly_vars.iter().any(|arg| arg.is_in_use);
         self.type_lookup.insert(definition_id, DefinedType{
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Component(ComponentType{ variant: definition.variant, arguments }),
             poly_vars,
             is_polymorph
         });
         Ok(())
+    }
     /// Will check if the member type (field of a struct, embedded type in a
     /// union variant) is valid.
     fn check_member_parser_type(
         modules: &[Module], ctx: &PassCtx, base_definition_root_id: RootId,
         member_parser_type: &ParserType, allow_special_compiler_types: bool
     ) -> Result<(), ParseError> {
         use ParserTypeVariant as PTV;
         for element in &member_parser_type.elements {
             match element.variant {
                 // Special cases
                 PTV::Void | PTV::InputOrOutput | PTV::ArrayLike | PTV::IntegerLike => {
                     if !allow_special_compiler_types {
                         unreachable!("compiler-only ParserTypeVariant in member type");
+                    }
                 },
                 // Builtin types, always valid
                 PTV::Message | PTV::Bool |
                 PTV::UInt8 | PTV::UInt16 | PTV::UInt32 | PTV::UInt64 |
                 PTV::SInt8 | PTV::SInt16 | PTV::SInt32 | PTV::SInt64 |
                 PTV::Character | PTV::String |
                 PTV::Array | PTV::Input | PTV::Output | PTV::Tuple(_) |
                 // Likewise, polymorphic variables are always valid
                 PTV::PolymorphicArgument(_, _) => {},
                 // Types that are not constructable, or types that are not
                 // allowed (and checked earlier)
                 PTV::IntegerLiteral | PTV::Inferred => {
                     unreachable!("illegal ParserTypeVariant within type definition");
                 },
                 // Finally, user-defined types
                 PTV::Definition(definition_id, _) => {
                     let definition = &ctx.heap[definition_id];
                     if !(definition.is_struct() || definition.is_enum() || definition.is_union()) {
                         let source = &modules[base_definition_root_id.index as usize].source;
                         return Err(ParseError::new_error_str_at_span(
                             source, element.element_span, "expected a datatype (a struct, enum or union)"
                         ));
+                    }
                     // Otherwise, we're fine
+                }
+            }
+        }
         // If here, then all elements check out
         return Ok(());
+    }
     /// Go through a list of identifiers and ensure that all identifiers have
     /// unique names
     fn check_identifier_collision<T: Sized, F: Fn(&T) -> &Identifier>(
         modules: &[Module], root_id: RootId, items: &[T], getter: F, item_name: &'static str
     ) -> Result<(), ParseError> {
         for (item_idx, item) in items.iter().enumerate() {
             let item_ident = getter(item);
             for other_item in &items[0..item_idx] {
                 let other_item_ident = getter(other_item);
                 if item_ident == other_item_ident {
                     let module_source = &modules[root_id.index as usize].source;
                     return Err(ParseError::new_error_at_span(
                         module_source, item_ident.span, format!("This {} is defined more than once", item_name)
                     ).with_info_at_span(
                         module_source, other_item_ident.span, format!("The other {} is defined here", item_name)
                     ));
+                }
+            }
+        }
         Ok(())
+    }
     /// Go through a list of polymorphic arguments and make sure that the
     /// arguments all have unique names, and the arguments do not conflict with
     /// any symbols defined at the module scope.
     fn check_poly_args_collision(
         modules: &[Module], ctx: &PassCtx, root_id: RootId, poly_args: &[Identifier]
     ) -> Result<(), ParseError> {
         // Make sure polymorphic arguments are unique and none of the
         // identifiers conflict with any imported scopes
         for (arg_idx, poly_arg) in poly_args.iter().enumerate() {
             for other_poly_arg in &poly_args[..arg_idx] {
                 if poly_arg == other_poly_arg {
                     let module_source = &modules[root_id.index as usize].source;
                     return Err(ParseError::new_error_str_at_span(
                         module_source, poly_arg.span,
                         "This polymorphic argument is defined more than once"
                     ).with_info_str_at_span(
                         module_source, other_poly_arg.span,
                         "It conflicts with this polymorphic argument"
                     ));
+                }
+            }
             // Check if identifier conflicts with a symbol defined or imported
             // in the current module
             if let Some(symbol) = ctx.symbols.get_symbol_by_name(SymbolScope::Module(root_id), poly_arg.value.as_bytes()) {
                 // We have a conflict
                 let module_source = &modules[root_id.index as usize].source;
                 let introduction_span = symbol.variant.span_of_introduction(ctx.heap);
                 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> {
         // Programmer notes: what happens here is the we call
         // `check_member_for_type_loops` for a particular type's member, and
         // then take action using the return value:
         // 1. It might already be resolved: in this case it implies we don't
         //  have type loops, or they have been resolved.
         // 2. A new type is encountered. If so then it is added to the type loop
         //  breadcrumbs.
         // 3. A type loop is detected (implying the type is already resolved, or
         //  already exists in the type loop breadcrumbs).
         //
         // Using the breadcrumbs we incrementally check every member type of a
         // particular considered type (e.g. a struct field, tuple member), and
         // do the same as above. Note that when a breadcrumb is added we reserve
         // space in the monomorph storage, initialized to zero-values (i.e.
         // wrong values). The breadcrumbs keep track of how far and along we are
         // with resolving the member types.
         //
         // At the end we may have some type loops. If they're unresolvable then
         // we throw an error). If there are no type loops or they are all
         // resolvable then we end up with a list of `encountered_types`. These
         // are then used by `lay_out_memory_for_encountered_types`.
         use DefinedTypeVariant as DTV;
         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_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.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();
             // TODO: Also don't need DefinitionId here. So then only need mono_index, so then just
             //  do a switch on the monomorph, not on the base type.
             let resolve_result = if breadcrumb.definition_id.is_invalid() {
                 // We're dealing with a tuple
                 let monomorph = self.mono_lookup.get(breadcrumb.monomorph_idx).variant.as_tuple();
                 let num_members = monomorph.members.len() as u32;
                 let mut tuple_result = TypeLoopResult::TypeExists;
                 while breadcrumb.next_member < num_members {
                     let tuple_member = &monomorph.members[breadcrumb.next_member as usize];
                     tuple_result = self.check_member_for_type_loops(&tuple_member.concrete_type);
                     if tuple_result != TypeLoopResult::TypeExists {
                         break;
+                    }
                     breadcrumb.next_member += 1;
+                }
                 tuple_result
             } else {
                 let poly_type = self.type_lookup.get(&breadcrumb.definition_id).unwrap();
                 match &poly_type.definition {
                     DTV::Enum(_) => {
             let monomorph = self.mono_lookup.get(breadcrumb.monomorph_idx);
             let resolve_result = match &monomorph.variant {
                 MonomorphVariant::Enum => {
                     TypeLoopResult::TypeExists
                 },
                     DTV::Union(definition) => {
                         let monomorph = self.mono_lookup.get(breadcrumb.monomorph_idx).variant.as_union();
                 MonomorphVariant::Union(monomorph) => {
                     let num_variants = monomorph.variants.len() as u32;
                     let mut union_result = TypeLoopResult::TypeExists;
                     'member_loop: while breadcrumb.next_member < num_variants {
                         let mono_variant = &monomorph.variants[breadcrumb.next_member as usize];
                         let num_embedded = mono_variant.embedded.len() as u32;
                         while breadcrumb.next_embedded < num_embedded {
                             let mono_embedded = &mono_variant.embedded[breadcrumb.next_embedded as usize];
                             union_result = self.check_member_for_type_loops(&mono_embedded.concrete_type);
                             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 = self.mono_lookup.get(breadcrumb.monomorph_idx).variant.as_struct();
                 MonomorphVariant::Struct(monomorph) => {
                     let num_fields = monomorph.fields.len() as u32;
                     let mut struct_result = TypeLoopResult::TypeExists;
                     while breadcrumb.next_member < num_fields {
                         let mono_field = &monomorph.fields[breadcrumb.next_member as usize];
                         struct_result = self.check_member_for_type_loops(&mono_field.concrete_type);
                         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!(),
                 MonomorphVariant::Procedure(_) => unreachable!(),
                 MonomorphVariant::Tuple(monomorph) => {
                     let num_members = monomorph.members.len() as u32;
                     let mut tuple_result = TypeLoopResult::TypeExists;
                     while breadcrumb.next_member < num_members {
                         let tuple_member = &monomorph.members[breadcrumb.next_member as usize];
                         tuple_result = self.check_member_for_type_loops(&tuple_member.concrete_type);
                         if tuple_result != TypeLoopResult::TypeExists {
                             break;
+                        }
                         breadcrumb.next_member += 1;
+                    }
                     tuple_result
+                }
             };
             // Handle the result of attempting to resolve the current breadcrumb
             match resolve_result {
                 TypeLoopResult::TypeExists => {
                     // We finished parsing the type
                     self.type_loop_breadcrumbs.pop();
                 },
                 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);
                 },
                 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.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.type_lookup.get_mut(&breadcrumb.definition_id).unwrap();
+                        let monomorph = self.mono_lookup.get_mut(breadcrumb.monomorph_idx);
                         // TODO: Match on monomorph directly here
                         match &mut entry.definition {
                             DTV::Union(definition) => {
                         match &mut monomorph.variant {
                             MonomorphVariant::Union(monomorph) => {
                                 // 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 = self.mono_lookup.get_mut(breadcrumb.monomorph_idx).variant.as_union_mut();
                                 let variant = &mut monomorph.variants[breadcrumb.next_member as usize];
                                 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
                         });
+                    }
                     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, mono_lookup: &MonomorphTable,
-            defined_type: &DefinedType, monomorph_idx: i32, index_in_loop: usize
+            definition_id: DefinitionId, monomorph_idx: i32, 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.
             // TODO: Also remove match on defined_type, replace with mono lookup
             let monomorph_type = match &defined_type.definition {
                 DTV::Union(definition) => &mono_lookup.get(monomorph_idx).concrete_type,
                 DTV::Struct(definition) => &mono_lookup.get(monomorph_idx).concrete_type,
                 DTV::Enum(_) | DTV::Function(_) | DTV::Component(_) =>
                     unreachable!(), // impossible to have an enum/procedure in a type loop
             };
             let monomorph_type = &mono_lookup.get(monomorph_idx).concrete_type;
             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_definition = &heap[definition_id];
             let ast_root_id = ast_definition.defined_in();
             return (
                 &modules[ast_root_id.index as usize].source,
                 ast_definition.identifier().span,
                 message
             );
+        }
         fn retrieve_definition_id_if_possible(parts: &[ConcreteTypePart]) -> DefinitionId {
             match &parts[0] {
                 ConcreteTypePart::Instance(v, _) |
                 ConcreteTypePart::Function(v, _) |
                 ConcreteTypePart::Component(v, _) => *v,
                 _ => DefinitionId::new_invalid(),
+            }
+        }
         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.type_lookup.get(&first_entry.definition_id).unwrap();
             // Seek first entry to produce parse error. Then continue builder
             // pattern. This is the error case so efficiency can go home.
             let mut parse_error = None;
             let mut next_member_index = 0;
             while next_member_index < type_loop.members.len() {
                 let first_entry = &type_loop.members[next_member_index];
                 next_member_index += 1;
                 let first_definition_id = retrieve_definition_id_if_possible(&table.mono_lookup.get(first_entry.monomorph_idx).concrete_type.parts);
                 if first_definition_id.is_invalid() {
                     continue;
+                }
                 let (first_module, first_span, first_message) = type_loop_source_span_and_message(
-                modules, heap, &table.mono_lookup, first_type, first_entry.monomorph_idx, 0
+                    modules, heap, &table.mono_lookup, first_definition_id, first_entry.monomorph_idx, 0
                 );
             let mut parse_error = ParseError::new_error_at_span(first_module, first_span, first_message);
                 parse_error = Some(ParseError::new_error_at_span(first_module, first_span, first_message));
                 break;
+            }
             let mut parse_error = parse_error.unwrap(); // Loop above cannot have failed, because we must have a type loop, type loops cannot contain only unnamed types
             let mut error_counter = 1;
-            for member_idx in 1..type_loop.members.len() {
+            for member_idx in next_member_index..type_loop.members.len() {
                 let entry = &type_loop.members[member_idx];
                 if entry.definition_id.is_invalid() {
                     // Don't display the tuples
                     continue;
                 let definition_id = retrieve_definition_id_if_possible(&table.mono_lookup.get(entry.monomorph_idx).concrete_type.parts);
                 if definition_id.is_invalid() {
                     continue; // dont display tuples
+                }
                 let entry_type = table.type_lookup.get(&first_entry.definition_id).unwrap();
                 let (module, span, message) = type_loop_source_span_and_message(
-                    modules, heap, &table.mono_lookup, entry_type, entry.monomorph_idx, error_counter
+                    modules, heap, &table.mono_lookup, definition_id, entry.monomorph_idx, error_counter
                 );
                 parse_error = parse_error.with_info_at_span(module, span, message);
                 error_counter += 1;
+            }
             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 monomorph = &self.mono_lookup.get(entry.monomorph_idx).variant.as_union();
                     let monomorph = self.mono_lookup.get(entry.monomorph_idx).variant.as_union();
                     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;
                         break;
+                    }
+                }
+            }
             if !can_be_broken {
                 // Construct a type loop 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(());
+    }
     /// 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;
         // Depending on the type, lookup if the type has already been visited
         // (i.e. either already has its memory layed out, or is part of a type
         // loop because we've already visited the type)
         debug_assert!(!definition_type.parts.is_empty());
         let (definition_id, monomorph_index) = match &definition_type.parts[0] {
             CTP::Tuple(_) => {
                 let monomorph_index = self.mono_lookup.get_monomorph_index(&definition_type.parts, &[]);
                 (DefinitionId::new_invalid(), monomorph_index)
             },
             CTP::Instance(definition_id, _) |
             CTP::Function(definition_id, _) |
             CTP::Component(definition_id, _) => {
                 let base_type = self.type_lookup.get(definition_id).unwrap();
                 let monomorph_index = self.mono_lookup.get_monomorph_index(&definition_type.parts, &base_type.poly_vars);
                 (*definition_id, monomorph_index)
             },
             _ => {
                 return TypeLoopResult::TypeExists
             },
         };
         if let Some(monomorph_index) = monomorph_index {
             for (breadcrumb_idx, breadcrumb) in self.type_loop_breadcrumbs.iter().enumerate() {
                 if breadcrumb.monomorph_idx == monomorph_index {
                     return TypeLoopResult::TypeLoop(breadcrumb_idx);
+                }
+            }
             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;
         use ConcreteTypePart as CTP;
         let mut is_union = false;
         let monomorph_index = match &definition_type.parts[0] {
             CTP::Tuple(num_embedded) => {
                 debug_assert!(definition_id.is_invalid()); // because tuples do not have an associated `DefinitionId`
                 let mut members = Vec::with_capacity(*num_embedded as usize);
                 for section in ConcreteTypeIter::new(&definition_type.parts, 0) {
                     members.push(TupleMonomorphMember{
                         concrete_type: ConcreteType{ parts: Vec::from(section) },
                         size: 0,
                         alignment: 0,
                         offset: 0
                     });
+                }
-                let monomorph_index = self.mono_lookup.insert_with_zero_size_and_alignment(
+                let mono_index = self.mono_lookup.insert_with_zero_size_and_alignment(
                     definition_type, &[],
                     MonomorphVariant::Tuple(TupleMonomorph{
                         members,
                     })
                 );
-                monomorph_index
+                mono_index
             },
             CTP::Instance(_check_definition_id, _) => {
                 debug_assert_eq!(definition_id, *_check_definition_id); // because this is how `definition_id` was determined
                 let base_type = self.type_lookup.get_mut(&definition_id).unwrap();
                 let monomorph_index = match &mut base_type.definition {
                     DTV::Enum(definition) => {
                         // TODO: Is this correct?
                         // The enum is a bit exceptional in that when we insert
                         // it we we will immediately set its size/alignment:
                         // there is nothing to compute here.
                         debug_assert!(definition.size != 0 && definition.alignment != 0);
                         let mono_index = self.mono_lookup.insert_with_zero_size_and_alignment(
                             definition_type, &base_type.poly_vars, MonomorphVariant::Enum
                         );
                         let mono_type = self.mono_lookup.get_mut(mono_index);
                         mono_type.size = definition.size;
                         mono_type.alignment = definition.alignment;
                         mono_index
                     },
                     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);
                                 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_index = self.mono_lookup.insert_with_zero_size_and_alignment(
                             definition_type, &base_type.poly_vars,
                             MonomorphVariant::Union(UnionMonomorph{
                                 variants: mono_variants,
                                 tag_size: definition.tag_size,
                                 heap_size: 0,
                                 heap_alignment: 0
                             })
                         );
                         is_union = true;
                         mono_index
                     },
                     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);
                             mono_fields.push(StructMonomorphField{
                                 concrete_type: mono_concrete,
                                 size: 0,
                                 alignment: 0,
                                 offset: 0
                             })
+                        }
                         let mono_index = self.mono_lookup.insert_with_zero_size_and_alignment(
                             definition_type, &base_type.poly_vars,
                             MonomorphVariant::Struct(StructMonomorph{ fields: mono_fields })
                         );
                         mono_index
                     },
                     DTV::Function(_) | DTV::Component(_) => {
                         unreachable!("pushing type resolving breadcrumb for procedure type")
                     },
                 };
                 monomorph_index
             },
             _ => unreachable!(),
         };
         self.encountered_types.push(TypeLoopEntry{
             definition_id,
             monomorph_idx: monomorph_index,
             is_union,
         });
         self.type_loop_breadcrumbs.push(TypeLoopBreadcrumb{
             definition_id,
             monomorph_idx: monomorph_index,
             next_member: 0,
             next_embedded: 0,
         });
+    }
     /// 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),
                 PTV::SInt64    => Some(CTP::SInt64),
                 PTV::Character => Some(CTP::Character),
                 PTV::String    => Some(CTP::String),
                 PTV::Array     => Some(CTP::Array),
                 PTV::Input     => Some(CTP::Input),
                 PTV::Output    => Some(CTP::Output),
                 PTV::Tuple(num) => Some(CTP::Tuple(*num)),
                 PTV::Definition(definition_id, num) => Some(CTP::Instance(*definition_id, *num)),
                 _              => None
+            }
+        }
         let mut parts = Vec::with_capacity(member_type.elements.len()); // usually a correct estimation, might not be
         for member_part in &member_type.elements {
             // Check if we have a regular builtin type
             if let Some(part) = parser_to_concrete_part(&member_part.variant) {
                 parts.push(part);
                 continue;
+            }
             // Not builtin, but if all code is working correctly, we only care
             // about the polymorphic argument at this point.
             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
     //--------------------------------------------------------------------------
     /// Should be called after type loops are detected (and resolved
     /// successfully). As a result of this call we expect the
     /// `encountered_types` array to be filled. We'll calculate size/alignment/
     /// offset values for those types in this routine.
     fn lay_out_memory_for_encountered_types(&mut self, arch: &TargetArch) {
         // Programmers note: this works like a little stack machine. We have
         // memory layout breadcrumbs which, like the type loop breadcrumbs, keep
         // track of the currently considered member type. This breadcrumb also
         // stores an index into the `size_alignment_stack`, which will be used
         // to store intermediate size/alignment pairs until all members are
         // resolved. Note that this `size_alignment_stack` is NOT an
         // optimization, we're working around borrowing rules here.
         use DefinedTypeVariant as DTV;
         // Just finished type loop detection, so we're left with the encountered
         // types only
         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.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.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();
             // TODO: Same as above, replace lookup of base definition, should not
             //  be needed.
             if breadcrumb.definition_id.is_invalid() {
                 // Handle tuple
                 let mono_tuple = self.mono_lookup.get(breadcrumb.monomorph_idx).variant.as_tuple();
                 let num_members = mono_tuple.members.len();
                 while breadcrumb.next_member < num_members {
                     let mono_member = &mono_tuple.members[breadcrumb.next_member];
                     match self.get_memory_layout_or_breadcrumb(arch, &mono_member.concrete_type.parts) {
                         MemoryLayoutResult::TypeExists(size, alignment) => {
                             self.size_alignment_stack.push((size, alignment));
                         },
                         MemoryLayoutResult::PushBreadcrumb(new_breadcrumb) => {
                             self.memory_layout_breadcrumbs[cur_breadcrumb_idx] = breadcrumb;
                             self.memory_layout_breadcrumbs.push(new_breadcrumb);
                             continue 'breadcrumb_loop;
                         },
+                    }
                     breadcrumb.next_member += 1;
+                }
                 // If here then we can compute the memory layout of the tuple.
                 let mut cur_offset = 0;
                 let mut max_alignment = 1;
                 let mono_info = self.mono_lookup.get_mut(breadcrumb.monomorph_idx);
                 let mono_tuple = mono_info.variant.as_tuple_mut();
                 let mut size_alignment_index = breadcrumb.first_size_alignment_idx;
                 for member_index in 0..num_members {
                     let (member_size, member_alignment) = self.size_alignment_stack[size_alignment_index];
                     align_offset_to(&mut cur_offset, member_alignment);
                     size_alignment_index += 1;
                     let member = &mut mono_tuple.members[member_index];
                     member.size = member_size;
                     member.alignment = member_alignment;
                     member.offset = cur_offset;
                     cur_offset += member_size;
                     max_alignment = max_alignment.max(member_alignment);
+                }
                 mono_info.size = cur_offset;
                 mono_info.alignment = max_alignment;
                 self.size_alignment_stack.truncate(breadcrumb.first_size_alignment_idx);
             } else {
                 let poly_type = self.type_lookup.get(&breadcrumb.definition_id).unwrap();
                 match &poly_type.definition {
                     DTV::Enum(definition) => {
             let mono_type = self.mono_lookup.get(breadcrumb.monomorph_idx);
             match &mono_type.variant {
                 MonomorphVariant::Enum => {
                     // Size should already be computed
                         debug_assert!(definition.size != 0 && definition.alignment != 0);
                         let mono_type = self.mono_lookup.get_mut(breadcrumb.monomorph_idx);
                         mono_type.size = definition.size;
                         mono_type.alignment = definition.alignment;
                     if cfg!(debug_assertions) {
                         let mono_type = self.mono_lookup.get(breadcrumb.monomorph_idx);
                         debug_assert!(mono_type.size != 0 && mono_type.alignment != 0);
+                    }
                 },
-                    DTV::Union(definition) => {
+                MonomorphVariant::Union(mono_type) => {
                     // Retrieve size/alignment of each embedded type. We do not
                     // compute the offsets or total type sizes yet.
                         let mono_type = self.mono_lookup.get(breadcrumb.monomorph_idx).variant.as_union();
                         let num_variants = mono_type.variants.len();
                     let num_variants = mono_type.variants.len() as u32;
                     while breadcrumb.next_member < num_variants {
-                            let mono_variant = &mono_type.variants[breadcrumb.next_member];
+                        let mono_variant = &mono_type.variants[breadcrumb.next_member as usize];
                         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();
+                            let num_embedded = mono_variant.embedded.len() as u32;
                             while breadcrumb.next_embedded < num_embedded {
-                                    let mono_embedded = &mono_variant.embedded[breadcrumb.next_embedded];
+                                let mono_embedded = &mono_variant.embedded[breadcrumb.next_embedded as usize];
                                 match self.get_memory_layout_or_breadcrumb(arch, &mono_embedded.concrete_type.parts) {
                                     MemoryLayoutResult::TypeExists(size, alignment) => {
                                         self.size_alignment_stack.push((size, alignment));
                                     },
                                     MemoryLayoutResult::PushBreadcrumb(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 mut max_size = mono_type.tag_size;
                     let mut max_alignment = mono_type.tag_size;
                         let poly_type = self.type_lookup.get_mut(&breadcrumb.definition_id).unwrap();
                         let definition = poly_type.definition.as_union_mut();
                     let mono_info = self.mono_lookup.get_mut(breadcrumb.monomorph_idx);
                     let mono_type = mono_info.variant.as_union_mut();
-                        let mut size_alignment_idx = breadcrumb.first_size_alignment_idx;
+                    let mut size_alignment_idx = breadcrumb.first_size_alignment_idx as usize;
                     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;
                         let mut variant_offset = mono_type.tag_size;
                         let mut variant_alignment = mono_type.tag_size;
                         if variant.lives_on_heap {
                             // Variant lives on heap, so just a pointer
                             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 {
                                 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 += size;
                                 variant_alignment = variant_alignment.max(alignment);
+                            }
                         };
                         max_size = max_size.max(variant_offset);
                         max_alignment = max_alignment.max(variant_alignment);
+                    }
                     mono_info.size = max_size;
                     mono_info.alignment = max_alignment;
-                        self.size_alignment_stack.truncate(breadcrumb.first_size_alignment_idx);
+                    self.size_alignment_stack.truncate(breadcrumb.first_size_alignment_idx as usize);
                 },
-                    DTV::Struct(definition) => {
+                MonomorphVariant::Struct(mono_type) => {
                     // Retrieve size and alignment of each struct member. We'll
                     // compute the offsets once all of those are known
                         let mono_type = self.mono_lookup.get(breadcrumb.monomorph_idx).variant.as_struct();
                         let num_fields = mono_type.fields.len();
                     let num_fields = mono_type.fields.len() as u32;
                     while breadcrumb.next_member < num_fields {
-                            let mono_field = &mono_type.fields[breadcrumb.next_member];
+                        let mono_field = &mono_type.fields[breadcrumb.next_member as usize];
                         match self.get_memory_layout_or_breadcrumb(arch, &mono_field.concrete_type.parts) {
                             MemoryLayoutResult::TypeExists(size, alignment) => {
                                 self.size_alignment_stack.push((size, alignment))
                             },
                             MemoryLayoutResult::PushBreadcrumb(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 mono_info = self.mono_lookup.get_mut(breadcrumb.monomorph_idx);
                     let mono_type = mono_info.variant.as_struct_mut();
-                        let mut size_alignment_idx = breadcrumb.first_size_alignment_idx;
+                    let mut size_alignment_idx = breadcrumb.first_size_alignment_idx as usize;
                     for field in &mut mono_type.fields {
                         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 += size;
                         max_alignment = max_alignment.max(alignment);
+                    }
                     mono_info.size = cur_offset;
                     mono_info.alignment = max_alignment;
-                        self.size_alignment_stack.truncate(breadcrumb.first_size_alignment_idx);
+                    self.size_alignment_stack.truncate(breadcrumb.first_size_alignment_idx as usize);
                 },
-                    DTV::Function(_) | DTV::Component(_) => {
+                MonomorphVariant::Procedure(_) => {
                     unreachable!();
                 },
                 MonomorphVariant::Tuple(mono_type) => {
                     let num_members = mono_type.members.len() as u32;
                     while breadcrumb.next_member < num_members {
                         let mono_member = &mono_type.members[breadcrumb.next_member as usize];
                         match self.get_memory_layout_or_breadcrumb(arch, &mono_member.concrete_type.parts) {
                             MemoryLayoutResult::TypeExists(size, alignment) => {
                                 self.size_alignment_stack.push((size, alignment));
                             },
                             MemoryLayoutResult::PushBreadcrumb(new_breadcrumb) => {
                                 self.memory_layout_breadcrumbs[cur_breadcrumb_idx] = breadcrumb;
                                 self.memory_layout_breadcrumbs.push(new_breadcrumb);
                                 continue 'breadcrumb_loop;
                             },
+                        }
                         breadcrumb.next_member += 1;
+                    }
                     // If here then we can compute the memory layout of the tuple.
                     let mut cur_offset = 0;
                     let mut max_alignment = 1;
                     let mono_info = self.mono_lookup.get_mut(breadcrumb.monomorph_idx);
                     let mono_type = mono_info.variant.as_tuple_mut();
                     let mut size_alignment_index = breadcrumb.first_size_alignment_idx as usize;
                     for member_index in 0..num_members {
                         let (member_size, member_alignment) = self.size_alignment_stack[size_alignment_index];
                         align_offset_to(&mut cur_offset, member_alignment);
                         size_alignment_index += 1;
                         let member = &mut mono_type.members[member_index as usize];
                         member.size = member_size;
                         member.alignment = member_alignment;
                         member.offset = cur_offset;
                         cur_offset += member_size;
                         max_alignment = max_alignment.max(member_alignment);
+                    }
                     mono_info.size = cur_offset;
                     mono_info.alignment = max_alignment;
                     self.size_alignment_stack.truncate(breadcrumb.first_size_alignment_idx as usize);
                 },
+            }
             // If here, then we completely layed out the current type. So move
             // to the next breadcrumb
             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 mono_type = self.mono_lookup.get(entry.monomorph_idx).variant.as_union();
             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.parts) {
                         MemoryLayoutResult::TypeExists(size, alignment) => {
                             self.size_alignment_stack.push((size, alignment));
                         },
                         _ => unreachable!(),
+                    }
+                }
+            }
             // Second pass, apply the size/alignment values in our buffer
             let mono_type = self.mono_lookup.get_mut(entry.monomorph_idx).variant.as_union_mut();
             let mut max_size = 0;
             let mut max_alignment = 1;
             let mut size_alignment_idx = 0;
             for variant in &mut mono_type.variants {
                 if !variant.lives_on_heap {
                     continue;
+                }
                 let mut variant_offset = 0;
                 let mut variant_alignment = 1;
                 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;
                     align_offset_to(&mut variant_offset, alignment);
                     embedded.alignment = variant_offset;
                     variant_offset += size;
                     variant_alignment = variant_alignment.max(alignment);
+                }
                 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();
+    }
     /// Attempts to compute size/alignment for the provided type. Note that this
     /// is called *after* type loops have been succesfully resolved. Hence we
     /// may assume that all monomorph entries exist, but we may not assume that
     /// those entries already have their size/alignment computed.
     fn get_memory_layout_or_breadcrumb(&self, arch: &TargetArch, parts: &[ConcreteTypePart]) -> MemoryLayoutResult {
         use ConcreteTypePart as CTP;
         debug_assert!(!parts.is_empty());
         let (builtin_size, builtin_alignment) = match parts[0] {
             CTP::Void   => (0, 1),
             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 => 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::Tuple(_) => {
                 let mono_index = self.mono_lookup.get_monomorph_index(parts, &[]).unwrap();
                 if let Some((size, alignment)) = self.mono_lookup.get_monomorph_size_alignment(mono_index) {
                     return MemoryLayoutResult::TypeExists(size, alignment);
                 } else {
                     return MemoryLayoutResult::PushBreadcrumb(MemoryBreadcrumb{
                         definition_id: DefinitionId::new_invalid(),
                         monomorph_idx: mono_index,
                         next_member: 0,
                         next_embedded: 0,
                         first_size_alignment_idx: self.size_alignment_stack.len(),
+                        first_size_alignment_idx: self.size_alignment_stack.len() as u32,
                     })
+                }
             },
             CTP::Instance(definition_id, _) => {
                 // Retrieve entry and the specific monomorph index by applying
                 // the full concrete type.
                 let entry = self.type_lookup.get(&definition_id).unwrap();
                 let mono_index = self.mono_lookup.get_monomorph_index(parts, &entry.poly_vars).unwrap();
                 if let Some((size, alignment)) = self.mono_lookup.get_monomorph_size_alignment(mono_index) {
                     return MemoryLayoutResult::TypeExists(size, alignment);
                 } else {
                     return MemoryLayoutResult::PushBreadcrumb(MemoryBreadcrumb{
                         definition_id,
                         monomorph_idx: mono_index,
                         next_member: 0,
                         next_embedded: 0,
                         first_size_alignment_idx: self.size_alignment_stack.len(),
+                        first_size_alignment_idx: self.size_alignment_stack.len() as u32,
                     });
+                }
             },
             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)
             } else {
                 (ConcreteTypePart::UInt64, 8)
+            }
         } else {
             // Must be a signed integer
             if min_val >= (i8::MIN as i64) && max_val <= (i8::MAX as i64) {
                 (ConcreteTypePart::SInt8, 1)
             } else if min_val >= (i16::MIN as i64) && max_val <= (i16::MAX as i64) {
                 (ConcreteTypePart::SInt16, 2)
             } else if min_val >= (i32::MIN as i64) && max_val <= (i32::MAX as i64) {
                 (ConcreteTypePart::SInt32, 4)
             } else {
                 (ConcreteTypePart::SInt64, 8)
+            }
         };
         return (ConcreteType{ parts: vec![part] }, size);
+    }
     //--------------------------------------------------------------------------
     // Small utilities
     //--------------------------------------------------------------------------
     fn create_polymorphic_variables(variables: &[Identifier]) -> Vec<PolymorphicVariable> {
         let mut result = Vec::with_capacity(variables.len());
         for variable in variables.iter() {
             result.push(PolymorphicVariable{ identifier: variable.clone(), is_in_use: false });
+        }
         result
+    }
     fn mark_used_polymorphic_variables(poly_vars: &mut Vec<PolymorphicVariable>, parser_type: &ParserType) {
         for element in &parser_type.elements {
             if let ParserTypeVariant::PolymorphicArgument(_, idx) = &element.variant {
                 poly_vars[*idx as usize].is_in_use = true;
+            }
+        }
+    }
+}
 #[inline]
 fn align_offset_to(offset: &mut usize, alignment: usize) {
     debug_assert!(alignment > 0);
     let alignment_min_1 = alignment - 1;
     *offset += alignment_min_1;
     *offset &= !(alignment_min_1);
+}
 #[inline]
 fn get_concrete_type_definition(concrete: &ConcreteType) -> DefinitionId {
     if let ConcreteTypePart::Instance(definition_id, _) = concrete.parts[0] {
         return definition_id;
     } else {
         debug_assert!(false, "passed {:?} to the type table", concrete);
         return DefinitionId::new_invalid()
+    }
+}
@@ \ No newline at end of file @@

src/protocol/tests/utils.rs

➞

Show inline comments

@@ @@ -831,219 +831,213 @@ pub(crate) struct AstErrTester { @@
     test_name: String,
     error: ParseError,
+}
 impl AstErrTester {
     fn new(test_name: String, error: ParseError) -> Self {
         Self{ test_name, error }
+    }
     pub(crate) fn error<F: Fn(ErrorTester)>(&self, f: F) {
         // Maybe multiple errors will be supported in the future
         let tester = ErrorTester{ test_name: &self.test_name, error: &self.error };
         f(tester)
+    }
+}
 //------------------------------------------------------------------------------
 // Utilities for failed compilation
 //------------------------------------------------------------------------------
 pub(crate) struct ErrorTester<'a> {
     test_name: &'a str,
     error: &'a ParseError,
+}
 impl<'a> ErrorTester<'a> {
     pub(crate) fn assert_num(self, num: usize) -> Self {
         assert_eq!(
             num, self.error.statements.len(),
             "[{}] expected error to consist of '{}' parts, but encountered '{}' for {}",
             self.test_name, num, self.error.statements.len(), self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_ctx_has(self, idx: usize, msg: &str) -> Self {
         assert!(
             self.error.statements[idx].context.contains(msg),
             "[{}] expected error statement {}'s context to contain '{}' for {}",
             self.test_name, idx, msg, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_msg_has(self, idx: usize, msg: &str) -> Self {
         assert!(
             self.error.statements[idx].message.contains(msg),
             "[{}] expected error statement {}'s message to contain '{}' for {}",
             self.test_name, idx, msg, self.assert_postfix()
         );
         self
+    }
     /// Seeks the index of the pattern in the context message, then checks if
     /// the input position corresponds to that index.
     pub (crate) fn assert_occurs_at(self, idx: usize, pattern: &str) -> Self {
         let pos = self.error.statements[idx].context.find(pattern);
         assert!(
             pos.is_some(),
             "[{}] incorrect occurs_at: '{}' could not be found in the context for {}",
             self.test_name, pattern, self.assert_postfix()
         );
         let pos = pos.unwrap();
         let col = self.error.statements[idx].start_column as usize;
         assert_eq!(
             pos + 1, col,
             "[{}] Expected error to occur at column {}, but found it at {} for {}",
             self.test_name, pos + 1, col, self.assert_postfix()
         );
         self
+    }
     fn assert_postfix(&self) -> String {
         let mut v = String::new();
         v.push_str("error: [");
         for (idx, stmt) in self.error.statements.iter().enumerate() {
             if idx != 0 {
                 v.push_str(", ");
+            }
             v.push_str(&format!("{{ context: {}, message: {} }}", &stmt.context, stmt.message));
+        }
         v.push(']');
+        v
+    }
+}
 //------------------------------------------------------------------------------
 // Generic utilities
 //------------------------------------------------------------------------------
 fn has_equal_num_monomorphs(ctx: TestCtx, num: usize, definition_id: DefinitionId) -> (bool, usize) {
     use DefinedTypeVariant::*;
     // Again: inefficient, but its testing code
     let type_def = ctx.types.get_base_definition(&definition_id).unwrap();
     let mut num_on_type = 0;
     for mono in &ctx.types.mono_lookup.monomorphs {
         match &mono.concrete_type.parts[0] {
             ConcreteTypePart::Instance(def_id, _) |
             ConcreteTypePart::Function(def_id, _) |
             ConcreteTypePart::Component(def_id, _) => {
                 if *def_id == definition_id {
                     num_on_type += 1;
+                }
             },
             _ => {},
         };
+    }
     (num_on_type == num, num_on_type)
+}
 fn has_monomorph(ctx: TestCtx, definition_id: DefinitionId, serialized_monomorph: &str) -> (Option<i32>, 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 = None;
     full_buffer.push('[');
     let mut append_to_full_buffer = |concrete_type: &ConcreteType, mono_idx: usize| {
         if full_buffer.len() != 1 {
             full_buffer.push_str(", ");
+        }
         full_buffer.push('"');
         let first_idx = full_buffer.len();
         full_buffer.push_str(concrete_type.display_name(ctx.heap).as_str());
         if &full_buffer[first_idx..] == serialized_monomorph {
             has_match = Some(mono_idx as i32);
+        }
         full_buffer.push('"');
     };
     // Bit wasteful, but this is (temporary?) testing code:
     for (mono_idx, mono) in ctx.types.mono_lookup.monomorphs.iter().enumerate() {
         let got_definition_id = match &mono.concrete_type.parts[0] {
             ConcreteTypePart::Instance(v, _) |
             ConcreteTypePart::Function(v, _) |
             ConcreteTypePart::Component(v, _) => *v,
             _ => DefinitionId::new_invalid(),
         };
         if got_definition_id == definition_id {
             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("[???]");
             },
             PTV::IntegerLike => buffer.push_str("integerlike"),
             PTV::Message => buffer.push_str(KW_TYPE_MESSAGE_STR),
             PTV::Bool => buffer.push_str(KW_TYPE_BOOL_STR),
             PTV::UInt8 => buffer.push_str(KW_TYPE_UINT8_STR),
             PTV::UInt16 => buffer.push_str(KW_TYPE_UINT16_STR),
             PTV::UInt32 => buffer.push_str(KW_TYPE_UINT32_STR),
             PTV::UInt64 => buffer.push_str(KW_TYPE_UINT64_STR),
             PTV::SInt8 => buffer.push_str(KW_TYPE_SINT8_STR),
             PTV::SInt16 => buffer.push_str(KW_TYPE_SINT16_STR),
             PTV::SInt32 => buffer.push_str(KW_TYPE_SINT32_STR),
             PTV::SInt64 => buffer.push_str(KW_TYPE_SINT64_STR),
             PTV::Character => buffer.push_str(KW_TYPE_CHAR_STR),
             PTV::String => buffer.push_str(KW_TYPE_STRING_STR),
             PTV::IntegerLiteral => buffer.push_str("int_literal"),
             PTV::Inferred => buffer.push_str(KW_TYPE_INFERRED_STR),
             PTV::Array => {
                 idx = serialize_variant(buffer, heap, parser_type, idx + 1);
                 buffer.push_str("[]");
             },
             PTV::Input => {
                 buffer.push_str(KW_TYPE_IN_PORT_STR);
                 buffer.push('<');
                 idx = serialize_variant(buffer, heap, parser_type, idx + 1);
                 buffer.push('>');
             },
             PTV::Output => {
                 buffer.push_str(KW_TYPE_OUT_PORT_STR);
                 buffer.push('<');
                 idx = serialize_variant(buffer, heap, parser_type, idx + 1);
                 buffer.push('>');
             },
             PTV::Tuple(num_embedded) => {
                 buffer.push('(');
                 for embedded_idx in 0..*num_embedded {
                     if embedded_idx != 0 {
                         buffer.push(',');
+                    }
                     idx = serialize_variant(buffer, heap, parser_type, idx + 1);
+                }
                 buffer.push(')');
             },
             PTV::PolymorphicArgument(definition_id, poly_idx) => {
                 let definition = &heap[*definition_id];

0 comments (0 inline, 0 general)