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

Changeset - e3aeb7338f21

Parent rev.

Child rev.

[Not reviewed]

0 4 0

mh - 4 years ago 2021-07-22 10:08:33
contact@maxhenger.nl

initial memory layout code, pending compiler errors

4 files changed with 332 insertions and 137 deletions:

src/protocol/ast.rs

src/protocol/ast_printer.rs

src/protocol/parser/pass_definitions.rs

src/protocol/parser/type_table.rs

324

124

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -519,174 +519,173 @@ pub struct ConcreteType { @@
     pub(crate) parts: Vec<ConcreteTypePart>
+}
 impl Default for ConcreteType {
     fn default() -> Self {
         Self{ parts: Vec::new() }
+    }
+}
 impl ConcreteType {
     /// Returns an iterator over the subtrees that are type arguments (e.g. an
     /// array element's type, or a polymorphic type's arguments) to the
     /// provided parent type (specified by its index in the `parts` array).
     pub(crate) fn embedded_iter<'a>(&'a self, parent_part_idx: usize) -> ConcreteTypeIter<'a> {
         let num_embedded = self.parts[parent_part_idx].num_embedded();
         return ConcreteTypeIter{
             concrete: self,
             idx_embedded: 0,
             num_embedded,
             part_idx: parent_part_idx + 1,
+        }
+    }
     /// Given the starting position of a type tree, determine the exclusive
     /// ending index.
     pub(crate) fn subtree_end_idx(&self, start_idx: usize) -> usize {
         let mut depth = 1;
         let num_parts = self.parts.len();
         debug_assert!(start_idx < num_parts);
         for part_idx in start_idx..self.parts.len() {
             let depth_change = self.parts[part_idx].num_embedded() as i32 - 1;
             depth += depth_change;
             debug_assert!(depth >= 0);
             if depth == 0 {
                 return part_idx + 1;
+            }
+        }
         debug_assert!(false, "incorrectly constructed ConcreteType instance");
         return 0;
+    }
     /// Construct a human-readable name for the type. Because this performs
     /// a string allocation don't use it for anything else then displaying the
     /// type to the user.
     pub(crate) fn display_name(&self, heap: &Heap) -> String {
         let mut name = String::with_capacity(128);
         fn display_part(parts: &[ConcreteTypePart], heap: &Heap, mut idx: usize, target: &mut String) -> usize {
             use ConcreteTypePart as CTP;
             use crate::protocol::parser::token_parsing::*;
             let cur_idx = idx;
             idx += 1; // increment by 1, because it always happens
             match parts[cur_idx] {
                 CTP::Void => { target.push_str("void"); },
                 CTP::Message => { target.push_str(KW_TYPE_MESSAGE_STR); },
                 CTP::Bool => { target.push_str(KW_TYPE_BOOL_STR); },
                 CTP::UInt8 => { target.push_str(KW_TYPE_UINT8_STR); },
                 CTP::UInt16 => { target.push_str(KW_TYPE_UINT16_STR); },
                 CTP::UInt32 => { target.push_str(KW_TYPE_UINT32_STR); },
                 CTP::UInt64 => { target.push_str(KW_TYPE_UINT64_STR); },
                 CTP::SInt8 => { target.push_str(KW_TYPE_SINT8_STR); },
                 CTP::SInt16 => { target.push_str(KW_TYPE_SINT16_STR); },
                 CTP::SInt32 => { target.push_str(KW_TYPE_SINT32_STR); },
                 CTP::SInt64 => { target.push_str(KW_TYPE_SINT64_STR); },
                 CTP::Character => { target.push_str(KW_TYPE_CHAR_STR); },
                 CTP::String => { target.push_str(KW_TYPE_STRING_STR); },
                 CTP::Array | CTP::Slice => {
                     idx = display_part(parts, heap, idx, target);
                     target.push_str("[]");
                 },
                 CTP::Input => {
                     target.push_str(KW_TYPE_IN_PORT_STR);
                     target.push('<');
                     idx = display_part(parts, heap, idx, target);
                     target.push('>');
                 },
                 CTP::Output => {
                     target.push_str(KW_TYPE_OUT_PORT_STR);
                     target.push('<');
                     idx = display_part(parts, heap, idx, target);
                     target.push('>');
                 },
                 CTP::Instance(definition_id, num_poly_args) => {
                     let definition = &heap[definition_id];
                     target.push_str(definition.identifier().value.as_str());
                     if num_poly_args != 0 {
                         target.push('<');
                         for poly_arg_idx in 0..num_poly_args {
                             if poly_arg_idx != 0 {
                                 target.push(',');
                                 idx = display_part(parts, heap, idx, target);
+                            }
+                        }
                         target.push('>');
+                    }
+                }
+            }
             idx
+        }
         let _final_idx = display_part(&self.parts, heap, 0, &mut target);
         let mut name = String::with_capacity(128);
         let _final_idx = display_part(&self.parts, heap, 0, &mut name);
         debug_assert_eq!(_final_idx, self.parts.len());
         return name;
+    }
+}
 #[derive(Debug)]
 pub struct ConcreteTypeIter<'a> {
     concrete: &'a ConcreteType,
     idx_embedded: u32,
     num_embedded: u32,
     part_idx: usize,
+}
 impl<'a> Iterator for ConcreteTypeIter<'a> {
     type Item = &'a [ConcreteTypePart];
-    fn next(&'a mut self) -> Option<Self::Item> {
     fn next(&mut self) -> Option<Self::Item> {
         if self.idx_embedded == self.num_embedded {
             return None;
+        }
         // Retrieve the subtree of interest
         let start_idx = self.part_idx;
         let end_idx = self.concrete.subtree_end_idx(start_idx);
         self.idx_embedded += 1;
         self.part_idx = end_idx;
         return Some(&self.concrete.parts[start_idx..end_idx]);
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum Scope {
     Definition(DefinitionId),
     Regular(BlockStatementId),
     Synchronous((SynchronousStatementId, BlockStatementId)),
+}
 impl Scope {
     pub fn is_block(&self) -> bool {
         match &self {
             Scope::Definition(_) => false,
             Scope::Regular(_) => true,
             Scope::Synchronous(_) => true,
+        }
+    }
     pub fn to_block(&self) -> BlockStatementId {
         match &self {
             Scope::Regular(id) => *id,
             Scope::Synchronous((_, id)) => *id,
             _ => panic!("unable to get BlockStatement from Scope")
+        }
+    }
+}
 /// `ScopeNode` is a helper that links scopes in two directions. It doesn't
 /// actually contain any information associated with the scope, this may be
 /// found on the AST elements that `Scope` points to.
 #[derive(Debug, Clone)]
 pub struct ScopeNode {
     pub parent: Scope,
     pub nested: Vec<Scope>,
+}

src/protocol/ast_printer.rs

➞

Show inline comments

@@ @@ -285,110 +285,107 @@ impl ASTWriter { @@
                     self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("Fields");
                 for field in &def.fields {
                     self.kv(indent3).with_s_key("Field");
                     self.kv(indent4).with_s_key("Name")
                         .with_identifier_val(&field.field);
                     self.kv(indent4).with_s_key("Type")
                         .with_custom_val(|s| write_parser_type(s, heap, &field.parser_type));
+                }
             },
             Definition::Enum(def) => {
                 self.kv(indent).with_id(PREFIX_ENUM_ID, def.this.0.index)
                     .with_s_key("DefinitionEnum");
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 for poly_var_id in &def.poly_vars {
                     self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("Variants");
                 for variant in &def.variants {
                     self.kv(indent3).with_s_key("Variant");
                     self.kv(indent4).with_s_key("Name")
                         .with_identifier_val(&variant.identifier);
                     let variant_value = self.kv(indent4).with_s_key("Value");
                     match &variant.value {
                         EnumVariantValue::None => variant_value.with_s_val("None"),
                         EnumVariantValue::Integer(value) => variant_value.with_disp_val(value),
                     };
+                }
             },
             Definition::Union(def) => {
                 self.kv(indent).with_id(PREFIX_UNION_ID, def.this.0.index)
                     .with_s_key("DefinitionUnion");
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 for poly_var_id in &def.poly_vars {
                     self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("Variants");
                 for variant in &def.variants {
                     self.kv(indent3).with_s_key("Variant");
                     self.kv(indent4).with_s_key("Name")
                         .with_identifier_val(&variant.identifier);
                     match &variant.value {
                         UnionVariantValue::None => {
                     if variant.value.is_empty() {
                         self.kv(indent4).with_s_key("Value").with_s_val("None");
+                        }
                         UnionVariantValue::Embedded(embedded) => {
                     } else {
                         self.kv(indent4).with_s_key("Values");
-                            for embedded in embedded {
+                        for embedded in &variant.value {
                             self.kv(indent4+1).with_s_key("Value")
                                 .with_custom_val(|v| write_parser_type(v, heap, embedded));
+                        }
+                    }
+                }
+            }
+            }
             Definition::Function(def) => {
                 self.kv(indent).with_id(PREFIX_FUNCTION_ID, def.this.0.index)
                     .with_s_key("DefinitionFunction");
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 for poly_var_id in &def.poly_vars {
                     self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("ReturnParserTypes");
                 for return_type in &def.return_types {
                     self.kv(indent3).with_s_key("ReturnParserType")
                         .with_custom_val(|s| write_parser_type(s, heap, return_type));
+                }
                 self.kv(indent2).with_s_key("Parameters");
                 for variable_id in &def.parameters {
                     self.write_variable(heap, *variable_id, indent3);
+                }
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, def.body.upcast(), indent3);
             },
             Definition::Component(def) => {
                 self.kv(indent).with_id(PREFIX_COMPONENT_ID,def.this.0.index)
                     .with_s_key("DefinitionComponent");
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 self.kv(indent2).with_s_key("Variant").with_debug_val(&def.variant);
                 self.kv(indent2).with_s_key("PolymorphicVariables");
                 for poly_var_id in &def.poly_vars {
                     self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("Parameters");
                 for variable_id in &def.parameters {
                     self.write_variable(heap, *variable_id, indent3)
+                }
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, def.body.upcast(), indent3);
+            }
+        }
+    }
     fn write_stmt(&mut self, heap: &Heap, stmt_id: StatementId, indent: usize) {
         let stmt = &heap[stmt_id];

src/protocol/parser/pass_definitions.rs

➞

Show inline comments

@@ @@ -177,100 +177,99 @@ impl PassDefinitions { @@
                 Ok(EnumVariantDefinition{ identifier, value })
             },
             &mut enum_section, "an enum variant", "a list of enum variants", None
         )?;
         // Transfer to definition
         let enum_def = ctx.heap[definition_id].as_enum_mut();
         enum_def.variants = enum_section.into_vec();
         Ok(())
+    }
     fn visit_union_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         consume_exact_ident(&module.source, iter, KW_UNION)?;
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated DefinitionId
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         // Parse union definition
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         let mut variants_section = self.union_variants.start_section();
         consume_comma_separated(
             TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
                 let identifier = consume_ident_interned(source, iter, ctx)?;
                 let mut close_pos = identifier.span.end;
                 let mut types_section = self.parser_types.start_section();
                 let has_embedded = maybe_consume_comma_separated(
                     TokenKind::OpenParen, TokenKind::CloseParen, source, iter, ctx,
                     |source, iter, ctx| {
                         let poly_vars = ctx.heap[definition_id].poly_vars();
                         consume_parser_type(
                             source, iter, &ctx.symbols, &ctx.heap, poly_vars,
                             module_scope, definition_id, false, 0
+                        )
                     },
                     &mut types_section, "an embedded type", Some(&mut close_pos)
                 )?;
                 let value = if has_embedded {
-                    UnionVariantValue::Embedded(types_section.into_vec())
                     types_section.into_vec()
                 } else {
                     types_section.forget();
                     UnionVariantValue::None
                     types_section.forget()
                 };
                 Ok(UnionVariantDefinition{
                     span: InputSpan::from_positions(identifier.span.begin, close_pos),
                     identifier,
                     value
                 })
             },
             &mut variants_section, "a union variant", "a list of union variants", None
         )?;
         // Transfer to AST
         let union_def = ctx.heap[definition_id].as_union_mut();
         union_def.variants = variants_section.into_vec();
         Ok(())
+    }
     fn visit_function_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         // Retrieve function name
         consume_exact_ident(&module.source, iter, KW_FUNCTION)?;
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated DefinitionId
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         // Parse function's argument list
         let mut parameter_section = self.variables.start_section();
         consume_parameter_list(
             &module.source, iter, ctx, &mut parameter_section, module_scope, definition_id
         )?;
         let parameters = parameter_section.into_vec();
         // Consume return types
         consume_token(&module.source, iter, TokenKind::ArrowRight)?;
         let mut return_types = self.parser_types.start_section();
         let mut open_curly_pos = iter.last_valid_pos(); // bogus value
         consume_comma_separated_until(
             TokenKind::OpenCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
                 let poly_vars = ctx.heap[definition_id].poly_vars();

src/protocol/parser/type_table.rs

➞

Show inline comments

 /**
  * type_table.rs
+ *
  * The type table is a lookup from AST definition (which contains just what the
  * programmer typed) to a type with additional information computed (e.g. the
  * byte size and offsets of struct members). The type table should be considered
  * the authoritative source of information on types by the compiler (not the
  * AST itself!).
+ *
  * The type table operates in two modes: one is where we just look up the type,
  * check its fields for correctness and mark whether it is polymorphic or not.
  * The second one is where we compute byte sizes, alignment and offsets.
+ *
  * The basic algorithm for type resolving and computing byte sizes is to
  * recursively try to lay out each member type of a particular type. This is
  * done in a stack-like fashion, where each embedded type pushes a breadcrumb
  * unto the stack. We may discover a cycle in embedded types (we call this a
  * "type loop"). After which the type table attempts to break the type loop by
  * making specific types heap-allocated. Upon doing so we know their size
  * because their stack-size is now based on pointers. Hence breaking the type
  * loop required for computing the byte size of types.
+ *
  * The reason for these type shenanigans is because PDL is a value-based
  * language, but we would still like to be able to express recursively defined
  * types like trees or linked lists. Hence we need to insert pointers somewhere
  * to break these cycles.
+ *
  * We will insert these pointers into the variants of unions. However note that
  * we can only compute the stack size of a union until we've looked at *all*
  * variants. Hence we perform an initial pass where we detect type loops, a
  * second pass where we compute the stack sizes of everything, and a third pass
  * where we actually compute the size of the heap allocations for unions.
+ *
  * As a final bit of global documentation: non-polymorphic types will always
  * have one "monomorph" entry. This contains the non-polymorphic type's memory
  * layout.
  */
 use std::fmt::{Formatter, Result as FmtResult};
 use std::collections::HashMap;
 use crate::protocol::ast::*;
 use crate::protocol::parser::symbol_table::SymbolScope;
 use crate::protocol::input_source::ParseError;
 use crate::protocol::parser::*;
 //------------------------------------------------------------------------------
 // Defined Types
 //------------------------------------------------------------------------------
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum TypeClass {
     Enum,
     Union,
     Struct,
     Function,
     Component
+}
 impl TypeClass {
     pub(crate) fn display_name(&self) -> &'static str {
         match self {
             TypeClass::Enum => "enum",
             TypeClass::Union => "union",
             TypeClass::Struct => "struct",
             TypeClass::Function => "function",
             TypeClass::Component => "component",
+        }
+    }
+}
 impl std::fmt::Display for TypeClass {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         write!(f, "{}", self.display_name())
+    }
+}
 /// Struct wrapping around a potentially polymorphic type. If the type does not
 /// have any polymorphic arguments then it will not have any monomorphs and
 /// `is_polymorph` will be set to `false`. A type with polymorphic arguments
 /// only has `is_polymorph` set to `true` if the polymorphic arguments actually
 /// appear in the types associated types (function return argument, struct
 /// field, enum variant, etc.). Otherwise the polymorphic argument is just a
 /// marker and does not influence the bytesize of the type.
 pub struct DefinedType {
     pub(crate) ast_root: RootId,
     pub(crate) ast_definition: DefinitionId,
     pub(crate) definition: DefinedTypeVariant,
     pub(crate) poly_vars: Vec<PolymorphicVariable>,
     pub(crate) is_polymorph: bool,
+}
 impl DefinedType {
     /// Checks if the monomorph at the specified index has polymorphic arguments
     /// that match the provided polymorphic arguments. Only the polymorphic
     /// variables that are in use by the type are checked.
     #[deprecated]
     pub(crate) fn monomorph_matches_poly_args(&self, monomorph_idx: usize, checking_poly_args: &[ConcreteType]) -> bool {
         use DefinedTypeVariant as DTV;
         debug_assert!(self.poly_vars.len(), checking_poly_args.len());
         if !self.is_polymorph {
             return true;
+        }
         let existing_poly_args = match &self.definition {
             DTV::Enum(def) => &def.monomorphs[monomorph_idx].poly_args,
             DTV::Union(def) => &def.monomorphs[monomorph_idx].poly_args,
             DTV::Struct(def) => &def.monomorphs[monomorph_idx].poly_args,
             DTV::Function(def) => &def.monomorphs[monomorph_idx].poly_args,
             DTV::Component(def) => &def.monomorphs[monomorph_idx].poly_args
         };
         for poly_idx in 0..num_args {
             let poly_var = &self.poly_vars[poly_idx];
             if !poly_var.is_in_use {
                 continue;
+            }
             let existing_arg = &existing_poly_args[poly_idx];
             let checking_arg = &checking_poly_args[poly_idx];
             if existing_arg != checking_arg {
                 return false;
+            }
+        }
         return true;
+    }
     /// Checks if a monomorph with the provided polymorphic arguments already
     /// exists. The polymorphic variables that are not in use by the type will
     /// not contribute to the checking (e.g. an `enum` type will always return
     /// `true`, because it cannot embed its polymorphic variables). Returns the
     /// index of the matching monomorph.
     #[deprecated]
     pub(crate) fn has_monomorph(&self, poly_args: &[ConcreteType]) -> Option<usize> {
     /// Returns the number of monomorphs that are instantiated. Remember that
     /// during the type loop detection, and the memory layout phase we will
     /// pre-allocate monomorphs which are not yet fully laid out in memory.
     pub(crate) fn num_monomorphs(&self) -> usize {
         use DefinedTypeVariant as DTV;
         // Quick check if type is polymorphic at all
         let num_args = poly_args.len();
         let num_monomorphs = match &self.definition {
         match &self.definition {
             DTV::Enum(def) => def.monomorphs.len(),
             DTV::Union(def) => def.monomorphs.len(),
             DTV::Struct(def) => def.monomorphs.len(),
             DTV::Function(def) => def.monomorphs.len(),
             DTV::Component(def) => def.monomorphs.len(),
         };
         debug_assert_eq!(self.poly_vars.len(), num_args);
         if !self.is_polymorph {
             debug_assert!(num_monomorphs <= 1);
             if num_monomorphs == 0 {
                 return None;
             } else {
                 return Some(0);
+            }
+        }
         for monomorph_idx in 0..num_monomorphs {
             if self.monomorph_matches_poly_args(monomorph_idx, poly_args) {
                 return Some(monomorph_idx);
+            }
             DTV::Function(_) | DTV::Component(_) => unreachable!(),
+        }
         return None;
+    }
     /// Returns the index at which a monomorph occurs. Will only check the
     /// polymorphic arguments that are in use (none of the, in rust lingo,
     /// phantom types).
     /// phantom types). If the type is not polymorphic and its memory has been
     /// layed out, then this will always return `Some(0)`.
     pub(crate) fn get_monomorph_index(&self, concrete_type: &ConcreteType) -> Option<usize> {
         use DefinedTypeVariant as DTV;
         // Helper to compare two types, while disregarding the polymorphic
         // variables that are not in use.
         let concrete_types_match = |type_a: &ConcreteType, type_b: &ConcreteType| -> bool {
             let mut a_iter = type_a.embedded_iter(0).enumerate();
             let mut b_iter = type_b.embedded_iter(0);
             while let Some((section_idx, a_section)) = a_iter.next() {
                 let b_section = b_iter.next();
+                let b_section = b_iter.next().unwrap();
                 if !self.poly_vars[section_idx].is_in_use {
                     continue;
+                }
                 if a_section != b_section {
                     return false;
+                }
+            }
             return true;
         };
         // Check check if type is polymorphic to some degree at all
         if cfg!(debug_assertions) {
             if let ConcreteTypePart::Instance(definition_id, num_poly_args) = concrete_type.parts[0] {
                 assert_eq!(definition_id, self.ast_definition);
                 assert_eq!(num_poly_args, self.poly_vars.len());
+                assert_eq!(num_poly_args as usize, self.poly_vars.len());
             } else {
                 assert!(false, "concrete type {:?} is not a user-defined type", concrete_type);
+            }
+        }
         match &self.definition {
             DTV::Enum(definition) => {
                 // Special case, enum is never a "true polymorph"
                 debug_assert!(!self.is_polymorph);
                 if definition.monomorphs.is_empty() {
                     return None
                 } else {
                     return Some(0)
+                }
             },
             DTV::Union(definition) => {
                 for (monomorph_idx, monomorph) in definition.monomorphs.iter().enumerate() {
                     if concrete_types_match(&monomorph.concrete_type, concrete_type) {
                         return Some(monomorph_idx);
+                    }
+                }
             },
             DTV::Struct(definition) => {
                 for (monomorph_idx, monomorph) in definition.monomorphs.iter().enumerate() {
                     if concrete_types_match(&monomorph.concrete_type, concrete_type) {
                         return Some(monomorph_idx);
+                    }
+                }
             },
             DTV::Function(_) | DTV::Component(_) => {
                 unreachable!("called get_monomorph_index on a procedure type");
+            }
+        }
         // Nothing matched
         return None;
+    }
     /// Retrieves size and alignment of the particular type's monomorph
     pub(crate) fn get_monomorph_size_alignment(&self, idx: usize) -> (usize, usize) {
     /// Retrieves size and alignment of the particular type's monomorph if it
     /// has been layed out in memory.
     pub(crate) fn get_monomorph_size_alignment(&self, idx: usize) -> Option<(usize, usize)> {
         use DefinedTypeVariant as DTV;
         match &self.definition {
+        let (size, alignment) = match &self.definition {
             DTV::Enum(def) => {
                 debug_assert!(idx == 0);
                 (def.size, def.alignment)
             },
             DTV::Union(def) => {
                 let monomorph = &def.monomorphs[idx];
                 // TODO: @Revise, probably not what I want
                 (monomorph.stack_byte_size, monomorph.alignment)
                 (monomorph.stack_size, monomorph.stack_alignment)
             },
             DTV::Struct(def) => {
                 let monomorph = &def.monomorphs[idx];
                 (monomorph.size, monomorph.alignment)
             },
             DTV::Function(_) | DTV::Component(_) => {
                 // Type table should never be able to arrive here during layout
                 // of types. Types may only contain function prototypes.
-                unreachable!("retrieving size and alignment of {:?}", self);
+                unreachable!("retrieving size and alignment of procedure type");
+            }
         };
         if size == 0 && alignment == 0 {
             // The "marker" for when the type has not been layed out yet. Even
             // for zero-size types we will set alignment to `1` to simplify
             // alignment calculations.
             return None;
         } else {
             return Some((size, alignment));
+        }
+    }
+}
 pub enum DefinedTypeVariant {
     Enum(EnumType),
     Union(UnionType),
     Struct(StructType),
     Function(FunctionType),
     Component(ComponentType)
+}
 impl DefinedTypeVariant {
     pub(crate) fn type_class(&self) -> TypeClass {
         match self {
             DefinedTypeVariant::Enum(_) => TypeClass::Enum,
             DefinedTypeVariant::Union(_) => TypeClass::Union,
             DefinedTypeVariant::Struct(_) => TypeClass::Struct,
             DefinedTypeVariant::Function(_) => TypeClass::Function,
             DefinedTypeVariant::Component(_) => TypeClass::Component
+        }
+    }
     pub(crate) fn as_struct(&self) -> &StructType {
         match self {
             DefinedTypeVariant::Struct(v) => v,
             _ => unreachable!("Cannot convert {} to struct variant", self.type_class())
+        }
+    }
     pub(crate) fn as_struct_mut(&mut self) -> &mut StructType {
         match self {
             DefinedTypeVariant::Struct(v) => v,
             _ => unreachable!("Cannot convert {} to struct variant", self.type_class())
+        }
+    }
     pub(crate) fn as_enum(&self) -> &EnumType {
         match self {
             DefinedTypeVariant::Enum(v) => v,
             _ => unreachable!("Cannot convert {} to enum variant", self.type_class())
+        }
+    }
     pub(crate) fn as_enum_mut(&mut self) -> &mut EnumType {
         match self {
             DefinedTypeVariant::Enum(v) => v,
             _ => unreachable!("Cannot convert {} to enum variant", self.type_class())
@@ @@ -447,219 +401,210 @@ pub struct StructMonomorph { @@
     pub fields: Vec<StructMonomorphField>,
     pub size: usize,
     pub alignment: usize,
+}
 pub struct StructMonomorphField {
     pub concrete_type: ConcreteType,
     pub size: usize,
     pub alignment: usize,
     pub offset: usize,
+}
 /// `FunctionType` is what you expect it to be: a particular function's
 /// signature.
 pub struct FunctionType {
     pub return_types: Vec<ParserType>,
     pub arguments: Vec<FunctionArgument>,
     pub monomorphs: Vec<ProcedureMonomorph>,
+}
 pub struct ComponentType {
     pub variant: ComponentVariant,
     pub arguments: Vec<FunctionArgument>,
     pub monomorphs: Vec<ProcedureMonomorph>
+}
 pub struct FunctionArgument {
     identifier: Identifier,
     parser_type: ParserType,
+}
 /// Represents the data associated with a single expression after type inference
 /// for a monomorph (or just the normal expression types, if dealing with a
 /// non-polymorphic function/component).
 pub struct MonomorphExpression {
     // The output type of the expression. Note that for a function it is not the
     // function's signature but its return type
     pub(crate) expr_type: ConcreteType,
     // Has multiple meanings: the field index for select expressions, the
     // monomorph index for polymorphic function calls or literals. Negative
     // values are never used, but used to catch programming errors.
     pub(crate) field_or_monomorph_idx: i32,
+}
 //------------------------------------------------------------------------------
 // Type table
 //------------------------------------------------------------------------------
 struct LayoutBreadcrumb {
     root_id: RootId,
     definition_id: DefinitionId,
     monomorph_idx: usize,
     next_member: usize,
     next_embedded: usize, // for unions, the next embedded value inside the member
+}
 /// Result from attempting to progress a breadcrumb
 enum LayoutResult {
     PopBreadcrumb,
     PushBreadcrumb(DefinitionId, Vec<ConcreteType>),
     TypeLoop(usize),
+}
 enum LookupResult {
     Exists(ConcreteType, usize, usize), // type was looked up and exists (or is a builtin). Also returns size and alignment
     Missing(DefinitionId, Vec<ConcreteType>), // type was looked up and doesn't exist, vec contains poly args
     TypeLoop(usize), // type is already in the breadcrumbs, index points into the matching breadcrumb
+}
 macro_rules! unwrap_lookup_result {
     ($result:expr) => {
         match $result {
             LookupResult::Exists(a, b, c) => (a, b, c)
             LookupResult::Missing(a, b) => return LayoutResult::PushBreadcrumb(a, b),
             LookupResult::TypeLoop(a) => return LayoutResult::TypeLoop(a),
+        }
+    }
+}
 struct TypeLoopBreadcrumb {
     definition_id: DefinitionId,
     monomorph_idx: usize,
     next_member: usize,
     next_embedded: usize, // for unions, the index into the variant's embedded types
+}
 #[derive(PartialEq, Eq)]
 enum BreadcrumbResult {
     TypeExists,
     PushedBreadcrumb,
     TypeLoop(usize), // index into vec of breadcrumbs at which the type matched
+}
 enum MemoryLayoutResult {
     TypeExists(usize, usize), // (size, alignment)
     PushBreadcrumb(TypeLoopBreadcrumb),
+}
 // TODO: @Optimize, initial memory-unoptimized implementation
 struct TypeLoopEntry {
     definition_id: DefinitionId,
     monomorph_idx: usize,
     is_union: bool,
+}
 struct TypeLoop {
     members: Vec<TypeLoopEntry>
+}
 pub struct TypeTable {
     /// Lookup from AST DefinitionId to a defined type. Considering possible
     /// polymorphs is done inside the `DefinedType` struct.
     lookup: HashMap<DefinitionId, DefinedType>,
     /// Breadcrumbs left behind while resolving embedded types
     breadcrumbs_old: Vec<LayoutBreadcrumb>,
     /// Breadcrumbs left behind while trying to find type loops. Also used to
     /// determine sizes of types when all type loops are detected.
     breadcrumbs: Vec<TypeLoopBreadcrumb>,
     type_loops: Vec<TypeLoop>,
     encountered_types: Vec<TypeLoopEntry>,
+}
 impl TypeTable {
     /// Construct a new type table without any resolved types.
     pub(crate) fn new() -> Self {
         Self{
             lookup: HashMap::new(),
             breadcrumbs_old: Vec::with_capacity(32),
             breadcrumbs: Vec::with_capacity(32),
             type_loops: Vec::with_capacity(8),
             encountered_types: Vec::with_capacity(32),
+        }
+    }
     /// Iterates over all defined types (polymorphic and non-polymorphic) and
     /// add their types in two passes. In the first pass we will just add the
     /// base types (we will not consider monomorphs, and we will not compute
     /// byte sizes). In the second pass we will compute byte sizes of
     /// non-polymorphic types, and potentially the monomorphs that are embedded
     /// in those types.
     pub(crate) fn build_base_types(&mut self, modules: &mut [Module], ctx: &mut PassCtx) -> Result<(), ParseError> {
         // Make sure we're allowed to cast root_id to index into ctx.modules
         debug_assert!(modules.iter().all(|m| m.phase >= ModuleCompilationPhase::DefinitionsParsed));
         debug_assert!(self.lookup.is_empty());
         if cfg!(debug_assertions) {
             for (index, module) in modules.iter().enumerate() {
                 debug_assert_eq!(index, module.root_id.index as usize);
+            }
+        }
         // Use context to guess hashmap size of the base types
         let reserve_size = ctx.heap.definitions.len();
         self.lookup.reserve(reserve_size);
         // Resolve all base types
         for definition_idx in 0..ctx.heap.definitions.len() {
             let definition_id = ctx.heap.definitions.get_id(definition_idx);
             let definition = &ctx.heap[definition_id];
             match definition {
                 Definition::Enum(_) => self.build_base_enum_definition(modules, ctx, definition_id)?,
                 Definition::Union(_) => self.build_base_union_definition(modules, ctx, definition_id)?,
                 Definition::Struct(_) => self.build_base_struct_definition(modules, ctx, definition_id)?,
                 Definition::Function(_) => self.build_base_function_definition(modules, ctx, definition_id)?,
                 Definition::Component(_) => self.build_base_component_definition(modules, ctx, definition_id)?,
+            }
+        }
         debug_assert_eq!(self.lookup.len(), reserve_size, "mismatch in reserved size of type table"); // NOTE: Temp fix for builtin functions
         for module in modules {
             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.
         // TODO: Finish this
         let empty_concrete_type = ConcreteType{ parts: Vec::new() };
         for definition_idx in 0..ctx.heap.definitions.len() {
             let definition_id = ctx.heap.definitions.get_id(definition_idx);
             let poly_type = self.lookup.get(&definition_id).unwrap();
             // Here we explicitly want to instantiate types which have no
             // polymorphic arguments (even if it has phantom polymorphic
             // arguments) because otherwise the user will see very weird
             // error messages.
             if poly_type.poly_vars.is_empty() && poly_type.num_monomorphs() == 0 {
                 self.detect_and_resolve_type_loops_for(
                     modules, ctx,
                     ConcreteType{
                         parts: vec![ConcreteTypePart::Instance(definition_id, 0)]
                     },
                 )?;
                 self.lay_out_memory_for_encountered_types(ctx);
+            }
+        }
         Ok(())
+    }
     /// Retrieves base definition from type table. We must be able to retrieve
     /// it as we resolve all base types upon type table construction (for now).
     /// However, in the future we might do on-demand type resolving, so return
     /// an option anyway
     pub(crate) fn get_base_definition(&self, definition_id: &DefinitionId) -> Option<&DefinedType> {
         self.lookup.get(&definition_id)
+    }
     /// Returns the index into the monomorph type array if the procedure type
     /// already has a (reserved) monomorph.
     pub(crate) fn get_procedure_monomorph_index(&self, definition_id: &DefinitionId, types: &Vec<ConcreteType>) -> Option<i32> {
         let def = self.lookup.get(definition_id).unwrap();
         if def.is_polymorph {
             let monos = def.definition.procedure_monomorphs();
             return monos.iter()
                 .position(|v| v.poly_args == *types)
                 .map(|v| v as i32);
         } else {
             // We don't actually care about the types
             let monos = def.definition.procedure_monomorphs();
             if monos.is_empty() {
                 return None
             } else {
                 return Some(0)
+            }
+        }
+    }
     /// Returns a mutable reference to a procedure's monomorph expression data.
     /// Used by typechecker to fill in previously reserved type information
     pub(crate) fn get_procedure_expression_data_mut(&mut self, definition_id: &DefinitionId, monomorph_idx: i32) -> &mut ProcedureMonomorph {
         debug_assert!(monomorph_idx >= 0);
         let def = self.lookup.get_mut(definition_id).unwrap();
         let monomorphs = def.definition.procedure_monomorphs_mut();
         return &mut monomorphs[monomorph_idx as usize];
+    }
     pub(crate) fn get_procedure_expression_data(&self, definition_id: &DefinitionId, monomorph_idx: i32) -> &ProcedureMonomorph {
         debug_assert!(monomorph_idx >= 0);
         let def = self.lookup.get(definition_id).unwrap();
         let monomorphs = def.definition.procedure_monomorphs();
         return &monomorphs[monomorph_idx as usize];
+    }
@@ @@ -1085,311 +1030,312 @@ impl TypeTable { @@
+    }
     /// 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], ctx: &PassCtx, concrete_type: ConcreteType) -> Result<(), ParseError> {
         use DefinedTypeVariant as DTV;
         debug_assert!(self.breadcrumbs.is_empty());
         debug_assert!(self.type_loops.is_empty());
         debug_assert!(self.encountered_types.is_empty());
         // Push the initial breadcrumb
-        let _initial_result = self.push_breadcrumb_for(get_concrete_type_definition(&concrete_type), &concrete_type);
+        let _initial_result = self.push_breadcrumb_for_type_loops(get_concrete_type_definition(&concrete_type), &concrete_type);
         debug_assert_eq!(_initial_result, BreadcrumbResult::PushedBreadcrumb);
         // Enter into the main resolving loop
         while !self.breadcrumbs.is_empty() {
             let breadcrumb_idx = self.breadcrumbs.len() - 1;
             let breadcrumb = self.breadcrumbs.last_mut().unwrap();
             let poly_type = self.lookup.get(&breadcrumb.definition_id).unwrap();
             // TODO: Misuse of BreadcrumbResult enum?
             let resolve_result = match &poly_type.definition {
                 DTV::Enum(_) => {
                     BreadcrumbResult::TypeExists
                 },
                 DTV::Union(definition) => {
                     let monomorph = &definition.monomorphs[breadcrumb.monomorph_idx];
                     let num_variants = monomorph.variants.len();
                     let mut union_result = BreadcrumbResult::TypeExists;
                     'member_loop: while breadcrumb.next_member < num_variants {
                         let mono_variant = &monomorph.variants[breadcrumb.next_member];
                         let num_embedded = mono_variant.embedded.len();
                         while breadcrumb.next_embedded < num_embedded {
                             let mono_embedded = &mono_variant.embedded[breadcrumb.next_embedded];
-                            union_result = self.push_breadcrumb_for(poly_type.ast_definition, &mono_embedded.concrete_type);
+                            union_result = self.push_breadcrumb_for_type_loops(poly_type.ast_definition, &mono_embedded.concrete_type);
                             if union_result != BreadcrumbResult::TypeExists {
                                 // In type loop or new breadcrumb pushed, so
                                 // break out of the resolving loop
                                 break 'member_loop;
+                            }
                             breadcrumb.next_embedded += 1;
+                        }
                         breadcrumb.next_embedded = 0;
                         breadcrumb.next_member += 1
+                    }
                     union_result
                 },
                 DTV::Struct(definition) => {
                     let monomorph = &definition.monomorphs[breadcrumb.monomorph_idx];
                     let num_fields = monomorph.fields.len();
                     let mut struct_result = BreadcrumbResult::TypeExists;
                     while breadcrumb.next_member < num_fields {
                         let mono_field = &monomorph.fields[breadcrumb.next_member];
-                        struct_result = self.push_breadcrumb_for(poly_type.ast_definition, &mono_field.concrete_type);
+                        struct_result = self.push_breadcrumb_for_type_loops(poly_type.ast_definition, &mono_field.concrete_type);
                         if struct_result != BreadcrumbResult::TypeExists {
                             // Type loop or breadcrumb pushed, so break out of
                             // the resolving loop
                             break;
+                        }
                         breadcrumb.next_member += 1;
+                    }
-                    struct_result,
                     struct_result
                 },
                 DTV::Function(_) | DTV::Component(_) => unreachable!(),
             };
             // Handle the result of attempting to resolve the current breadcrumb
             match resolve_result {
                 BreadcrumbResult::TypeExists => {
                     // We finished parsing the type
                     self.breadcrumbs.pop();
                 },
                 BreadcrumbResult::PushedBreadcrumb => {
                     // We recurse into the member type, since the breadcrumb is
                     // already pushed we don't take any action here.
                 },
                 BreadcrumbResult::TypeLoop(first_idx) => {
                     // We're in a type loop. Add the type loop
                     let mut loop_members = Vec::with_capacity(self.breadcrumbs.len() - first_idx);
                     for breadcrumb_idx in first_idx..self.breadcrumbs.len() {
                         let breadcrumb = &mut self.breadcrumbs[breadcrumb_idx];
                         let mut is_union = false;
                         match self.lookup.get_mut(&breadcrumb.definition_id).unwrap() {
                             DTV::Union(definition) => {
                                 // Mark the currently processed variant as requiring heap
                                 // allocation, then advance the *embedded* type. The loop above
                                 // will then take care of advancing it to the next *member*.
                                 let monomorph = &mut definition.monomorphs[breadcrumb.monomorph_idx];
                                 let variant = &mut monomorph.variants[breadcrumb.next_member];
                                 variant.lives_on_heap = true;
                                 breadcrumb.next_embedded += 1;
                                 is_union = true;
                             },
                             _ => {}, // else: we don't care for now
+                        }
                         loop_members.push(TypeLoopEntry{
                             definition_id: breadcrumb.definition_id,
                             monomorph_idx: breadcrumb.monomorph_idx,
                             is_union
                         });
+                    }
                     self.type_loops.push(TypeLoop{ members: loop_members });
+                }
+            }
+        }
         // 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], ctx: &PassCtx, defined_type: &DefinedType, monomorph_idx: usize, index_in_loop: usize
         ) -> (&'a InputSource, InputSpan, String) {
             // Note: because we will discover the type loop the *first* time we
             // instantiate a monomorph with the provided polymorphic arguments
             // (not all arguments are actually used in the type). We don't have
             // to care about a second instantiation where certain unused
             // polymorphic arguments are different.
             use DefinedTypeVariant as DTV;
             let monomorph_type = match &defined_type.definition {
                 DTV::Union(definition) => &definition.monomorphs[monomorph_idx].concrete_type,
                 DTV::Struct(definition) => &definition.monomorphs[monomorph_idx].concrete_type,
                 DTV::Enum(_) | DTV::Function(_) | DTV::Component(_) =>
                     unreachable!(), // impossible to have an enum/procedure in a type loop
             };
             let type_name = monomorph_type.display_name(&ctx.heap);
             let message = if index_in_loop == 0 {
                 format!(
-                    "encountered an infinitely large type for '{}', which can be fixed by \
+                    "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",
+                    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 = &ctx.heap[defined_type.ast_definition];
             let ast_root_id = ast_definition.defined_in();
             return (
                 &modules[ast_root_id.index as usize].source,
                 ast_definition.identifier().span,
                 message
             );
+        }
         for type_loop in &self.type_loops {
             let mut can_be_broken = false;
             debug_assert!(!type_loop.members.is_empty());
             for entry in &type_loop.members {
                 if entry.is_union {
                     let base_type = self.lookup.get(&entry.definition_id).unwrap();
                     let monomorph = &base_type.definition.as_union().monomorphs[entry.monomorph_idx];
                     debug_assert!(!monomorph.variants.is_empty()); // otherwise it couldn't be part of the type loop
                     let has_stack_variant = monomorph.variants.iter().any(|variant| !variant.lives_on_heap);
                     if has_stack_variant {
                         can_be_broken = true;
+                    }
+                }
+            }
             if !can_be_broken {
                 // Construct a type loop error
                 let first_entry = &type_loop.members[0];
                 let first_type = self.lookup.get(&first_entry.definition_id).unwrap();
                 let (first_module, first_span, first_message) = type_loop_source_span_and_message(
                     modules, ctx, first_type, first_entry.monomorph_idx, 0
                 );
                 let mut parse_error = ParseError::new_error_at_span(first_module, first_span, first_message);
                 for member_idx in 1..type_loop.members.len() {
                     let entry = &type_loop.members[member_idx];
                     let entry_type = self.lookup.get(&first_entry.definition_id).unwrap();
                     let (module, span, message) = type_loop_source_span_and_message(
                         modules, ctx, entry_type, entry.monomorph_idx, member_idx
                     );
                     parse_error = parse_error.with_info_at_span(module, span, message);
+                }
                 return Err(parse_error);
+            }
+        }
         // If here, then all type loops have been resolved and we can lay out
         // all of the members
-        // TODO: Continue here
+        self.type_loops.clear();
         return Ok(());
+    }
     // TODO: Pass in definition_type by value?
-    fn push_breadcrumb_for(&mut self, definition_id: DefinitionId, definition_type: &ConcreteType) -> BreadcrumbResult {
+    fn push_breadcrumb_for_type_loops(&mut self, definition_id: DefinitionId, definition_type: &ConcreteType) -> BreadcrumbResult {
         use DefinedTypeVariant as DTV;
         let mut base_type = self.lookup.get_mut(&definition_id).unwrap();
         if let Some(mono_idx) = base_type.get_monomorph_index(&definition_type) {
             // Monomorph is already known. Check if it is present in the
             // breadcrumbs. If so, then we are in a type loop
             for (breadcrumb_idx, breadcrumb) in self.breadcrumbs.iter().enumerate() {
                 if breadcrumb.definition_id == definition_id && breadcrumb.monomorph_idx == mono_idx {
                     return BreadcrumbResult::TypeLoop(breadcrumb_idx);
+                }
+            }
             return BreadcrumbResult::TypeExists;
+        }
         // Type is not yet known, so we need to insert it into the lookup and
         // push a new breadcrumb.
         let mut is_union = false;
         let monomorph_idx = match &mut base_type.definition {
             DTV::Enum(definition) => {
                 debug_assert!(definition.monomorphs.is_empty());
                 definition.monomorphs.push(EnumMonomorph{
                     concrete_type: definition_type.clone(),
                 });
             },
             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_idx = definition.monomorphs.len();
@@ @@ -1472,119 +1418,373 @@ impl TypeTable { @@
                 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::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 {
                 debug_assert_eq!(*_container_definition_id, get_concrete_type_definition(container_type));
                 let mut container_iter = container_type.embedded_iter(0);
                 for _ in 0..*poly_arg_idx {
                     container_iter.next();
+                }
                 let poly_section = container_iter.next().unwrap();
                 parts.extend(poly_section);
                 continue;
+            }
             unreachable!("unexpected type part {:?} from {:?}", member_part, member_type);
+        }
         return ConcreteType{ parts };
+    }
     //--------------------------------------------------------------------------
     // Determining memory layout for types
     //--------------------------------------------------------------------------
     fn lay_out_memory_for_encountered_types(&mut self, ctx: &PassCtx) {
         use DefinedTypeVariant as DTV;
         // Just finished type loop detection, so we're left with the encountered
         // types only
         debug_assert!(self.breadcrumbs.is_empty());
         debug_assert!(self.type_loops.is_empty());
         debug_assert!(!self.encountered_types.is_empty());
         // Push the first entry (the type we originally started with when we
         // were detecting type loops)
         let first_entry = &self.encountered_types[0];
         self.breadcrumbs.push(TypeLoopBreadcrumb{
             definition_id: first_entry.definition_id,
             monomorph_idx: first_entry.monomorph_idx,
             next_member: 0,
             next_embedded: 0,
         });
         // Enter the main resolving loop
         'breadcrumb_loop: while !self.breadcrumbs.is_empty() {
             let breadcrumb_idx = self.breadcrumbs.len() - 1;
             let breadcrumb = &mut self.breadcrumbs[breadcrumb_idx];
             let poly_type = self.lookup.get_mut(&breadcrumb.definition_id).unwrap();
             match &mut poly_type.definition {
                 DTV::Enum(definition) => {
                     // Size should already be computed
                     debug_assert!(definition.size != 0 && definition.alignment != 0);
                 },
                 DTV::Union(definition) => {
                     // Retrieve size/alignment of each embedded type. We do not
                     // compute the offsets or total type sizes yet.
                     let mono_type = &mut definition.monomorphs[breadcrumb.monomorph_idx];
                     let num_variants = mono_type.variants.len();
                     while breadcrumb.next_member < num_variants {
                         let mono_variant = &mut mono_type.variants[breadcrumb.next_member];
                         if mono_variant.lives_on_heap {
                             // To prevent type loops we made this a heap-
                             // allocated variant. This implies we cannot
                             // compute sizes of members at this point.
                         } else {
                             let num_embedded = mono_variant.embedded.len();
                             while breadcrumb.next_embedded < num_embedded {
                                 let mono_embedded = &mut mono_variant.embedded[breadcrumb.next_embedded];
                                 match self.get_memory_layout_or_breadcrumb(ctx, &mono_embedded.concrete_type) {
                                     MemoryLayoutResult::TypeExists(size, alignment) => {
                                         mono_embedded.size = size;
                                         mono_embedded.alignment = alignment;
                                     },
                                     MemoryLayoutResult::PushBreadcrumb(new_breadcrumb) => {
                                         self.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;
                     for variant in &mut mono_type.variants {
                         // We're doing stack computations, so always start with
                         // the tag size/alignment.
                         let mut variant_offset = definition.tag_size;
                         let mut variant_alignment = definition.tag_size;
                         if variant.lives_on_heap {
                             // Variant lives on heap, so just a pointer
                             let (ptr_size, ptr_align) = ctx.arch.pointer_size_alignment;
                             align_offset_to(&mut variant_offset, ptr_align);
                             variant_offset += ptr_size;
                             variant_alignment = variant_alignment.max(ptr_align);
                         } else {
                             // Variant lives on stack, so walk all embedded
                             // types.
                             for embedded in &mut variant.embedded {
                                 align_offset_to(&mut variant_offset, embedded.alignment);
                                 embedded.offset = variant_offset;
                                 variant_offset += embedded.size;
                                 variant_alignment = variant_alignment.max(embedded.alignment);
+                            }
                         };
                         max_size = max_size.max(variant_offset);
                         max_alignment = max_alignment.max(variant_alignment);
+                    }
                     mono_type.stack_size = max_size;
                     mono_type.stack_alignment = max_alignment;
                 },
                 DTV::Struct(definition) => {
                     // Retrieve size and alignment of each struct member. We'll
                     // compute the offsets once all of those are known
                     let mono_type = &mut definition.monomorphs[breadcrumb.monomorph_idx];
                     let num_fields = mono_type.fields.len();
                     while breadcrumb.next_member < num_fields {
                         let mono_field = &mut mono_type.fields[breadcrumb.next_member];
                         match self.get_memory_layout_or_breadcrumb(ctx, &mono_field.concrete_type) {
                             MemoryLayoutResult::TypeExists(size, alignment) => {
                                 mono_field.size = size;
                                 mono_field.alignment = alignment;
                             },
                             MemoryLayoutResult::PushBreadcrumb(new_breadcrumb) => {
                                 self.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;
                     for field in &mut mono_type.fields {
                         align_offset_to(&mut cur_offset, field.alignment);
                         field.offset = cur_offset;
                         cur_offset += field.size;
                         max_alignment = max_alignment.max(field.alignment);
+                    }
                     mono_type.size = cur_offset;
                     mono_type.alignment = max_alignment;
                 },
                 DTV::Function(_) | DTV::Component(_) => {
                     unreachable!();
+                }
+            }
             // If here, then we completely layed out the current type. So move
             // to the next breadcrumb
             self.breadcrumbs.pop();
+        }
         // 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;
+            }
             let poly_type = self.lookup.get_mut(&entry.definition_id).unwrap();
             match &mut poly_type.definition {
                 DTV::Union(definition) => {
                     let mono_type = &mut definition.monomorphs[entry.monomorph_idx];
                     let mut max_size = 0;
                     let mut max_alignment = 1;
                     for variant in &mut mono_type.variants {
                         if !variant.lives_on_heap {
                             continue;
+                        }
                         let mut variant_offset = 0;
                         let mut variant_alignment = 1;
                         debug_assert!(!variant.embedded.is_empty());
                         for embedded in &mut variant.embedded {
                             match self.get_memory_layout_or_breadcrumb(ctx, &embedded.concrete_type) {
                                 MemoryLayoutResult::TypeExists(size, alignment) => {
                                     embedded.size = size;
                                     embedded.alignment = alignment;
                                     align_offset_to(&mut variant_offset, alignment);
                                     embedded.alignment = variant_offset;
                                     variant_offset += size;
                                     variant_alignment = variant_alignment.max(alignment);
                                 },
                                 _ => unreachable!(),
+                            }
+                        }
                         // Update heap size/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;
+                    }
                 },
                 _ => unreachable!(),
+            }
+        }
         // And now, we're actually, properly, done
         self.encountered_types.clear();
+    }
     fn get_memory_layout_or_breadcrumb(&self, ctx: &PassCtx, concrete_type: &ConcreteType) -> MemoryLayoutResult {
         use ConcreteTypePart as CTP;
         // Before we do any fancy shenanigans, we need to check if the concrete
         // type actually requires laying out memory.
         debug_assert!(!concrete_type.parts.is_empty());
         let (builtin_size, builtin_alignment) = match concrete_type.parts[0] {
             CTP::Void   => (0, 1),
             CTP::Message => ctx.arch.array_size_alignment,
             CTP::Bool   => (1, 1),
             CTP::UInt8  => (1, 1),
             CTP::UInt16 => (2, 2),
             CTP::UInt32 => (4, 4),
             CTP::UInt64 => (8, 8),
             CTP::SInt8  => (1, 1),
             CTP::SInt16 => (2, 2),
             CTP::SInt32 => (4, 4),
             CTP::SInt64 => (8, 8),
             CTP::Character => (4, 4),
             CTP::String => ctx.arch.string_size_alignment,
             CTP::Array => ctx.arch.array_size_alignment,
             CTP::Slice => ctx.arch.array_size_alignment,
             CTP::Input => ctx.arch.port_size_alignment,
             CTP::Output => ctx.arch.port_size_alignment,
             CTP::Instance(definition_id, _) => {
                 // Special case where we explicitly return to simplify the
                 // return case for the builtins.
                 let entry = self.lookup.get(&definition_id).unwrap();
                 let monomorph_idx = entry.get_monomorph_index(concrete_type).unwrap();
                 if let Some((size, alignment)) = entry.get_monomorph_size_alignment(monomorph_idx) {
                     // Type has been layed out in memory
                     return MemoryLayoutResult::TypeExists(size, alignment);
                 } else {
                     return MemoryLayoutResult::PushBreadcrumb(TypeLoopBreadcrumb {
                         definition_id,
                         monomorph_idx,
                         next_member: 0,
                         next_embedded: 0,
                     });
+                }
+            }
         };
         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) {
+            } 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 @@

0 comments (0 inline, 0 general)