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

Changeset - 91b15f92bab5

Parent rev.

Child rev.

[Not reviewed]

0 3 0

MH - 4 years ago 2021-07-12 15:49:00
contact@maxhenger.nl

start on memory layout of types

3 files changed with 306 insertions and 87 deletions:

docs/types/infinite_types.md

src/protocol/ast.rs

src/protocol/parser/type_table.rs

290

0 comments (0 inline, 0 general)

docs/types/infinite_types.md

➞

Show inline comments

 And finally, in human terms: a type is not actually infinite if, given enough time, a programmer can express a literal of that type. So one may type (using the examples above):
 ```pdl
 auto thing = List::Entry(3, List::Entry(2, List::Entry(1, List::End)));
 auto flong = U32TreeExample{
     value: 0,
     left: Option::Some(U32TreeExample{
         value: 1,
         left: Option::None
     },
     right: Option::None
+}
 ```
 But one simply cannot express:
 ```pdl
 auto cannot_construct = A::B(B::C(C::A(A::C(C::B( /* onwards, to infinity )))));
 ```
 Now we arrive at several conditions to end up at a concrete algorithm. Firsly we have that types whose literals are expressable should be constructable in the language. Secondly, for the performance reasons mentioned above we would like to specify the memory layout for each type. So that includes the size and alignment of the type itself, and the offset (with implicit alignment and size) of each of its members. Thirdly, because we're going to have to put pointers somewhere in the aforementioned type loops (necessarily, because we have variably sized values, we need to perform some kind of allocation somewhere, hence we need to have pointers somewhere), we need these pointers to be placed consistently throughout the code. This last point is a design decision: we could decide to have some types including pointers to members, and some types excluding pointers to members. This would then require special conversion functions implemented when two values of the same type, but with a different memory layout, are converted into one another. This on top of the fact that each of the types containing a pointer will require a constructor and a destructor. Finally, albeit this point looks ahead a bit at the implementation, we desire that subsequent compilations of the same files, but potentially in a different order, result in the same layout of each of the types.
 We may observe that only unions may break up potentially infinite types. So for each loop that contains a non-infinite union we need at least one union that is implemented using some kind of pointer. There are multiple ways we can fix the byte size of the union, thereby breaking the type loop:
 . Make each instance of the union a pointer to the data in that union: both the tag and the potentially embedded values. This has the upside of being relatively simple to implement. Furthermore the union itself will just have a fixed size. The downside is that for a tag lookup we have to follow the pointer, generally causing cache misses in the case that we just want to check the tag.
 . Keep the tag in a union value, but dynamically allocate all of the contents. This way the size of a union value becomes a tag and a pointer. On 32-bit systems this is most likely fine, on 64-bit systems (which is the norm, if we're not talking about embedded computers) alignment will generally cause the union size to bloat to 16-bytes. This kind of implementation has two subcases to consider.
     - Allocate as much memory as the maximum union variant. This way changing the union variant will not force a reallocation. Instead we can use up the allocated memory.
     - Allocate as much memory as the variant requires. This way we will not waste any memory, at the cost of having to reallocate when the variant is changed.
 . Keep the tag in the union value, with the same up- and downsides as the previous point. Then dynamically allocate the members of the variants (that is, if we have `union Foo { Bar(CyclicType, u64, u64), Qux }`, then we will just make `CyclicType` a pointer). The obvious downside is that changing variants might cause (de)allocations. And if we have multiple members that cause a loop then we need to allocate each of them. The upside is that when we're only accessing the non-pointer members that they're likely already in the cache.
 There are many more tiny variants here that are not explicitly stated. I'll document my reasons for choosing the variant I think works best:
 - The whole idea of breaking the type cycles is not to allocate an infinite amount of memory, so always allocating the union is naturally out of the question. Furthermore type loops will generally only occur in particular datastructures that are potentially infinite: trees, linked lists, hashmaps, etc.
 - The contract when using a union is that the byte size of a union value is the size of the largest member plus the size of the tag (plus padding). So allocating the union just once, with enough size to fit all possible allocated variants seems like a good idea to me. I suspect that in most cases these unions will express something along the lines of: there is nothing, or there is nothing.
 Finally, as a note: all of this type-loop checking has to be performed per monomorphization. A polymorphic type specification itself does not need to be checked for type loops.
 Lastly, we have to consider the point of making sure that multiple compilations, where the AST is constructed in a different order, hence where the types are "discovered" in a different order, will result in the same types. As a rather simple solution, instead of just marking one union in the type loop as pointerlike, all of the unions in the type loops will be implemented using some kind of pointer scheme.
 ## Concluding on the Algorithm
 As an initial conclusion:
 - All non-infinite unions in type loops are implemented using dynamic allocation to break the type loops and to prevent potentially infinite types from being truly infinite.
 - The tag of the union will be a non-allocated value associated with the union. Considering that most of the time these kinds of unions will represent an option-like type (there is one more entry in the linked list, there is one more node in the tree, etc.) I think it is nice to not have cache misses when checking whether a value is present, or whether it is not present.
 - Considering that we cannot allocate all of the time (because then we will still end up with an infinite amount of allocated memory), but I do not currently want to implement very complicated logic in the compiler for handling memory allocations, I will initially implement the following scheme: all union variants that do not contain any types part of a type loop will be stored on the stack, contributing to the byte size of the union. All variants that do contain such types will be fully allocated on the heap in one allocation. The size of the allocated region will be the size of the largest variant that requires dynamic allocation.
 ## Rough Specification of the Algorithm
 I might be missing some stuff here, that stuff will probably pop up while I'm implementing this:
+-
    Perform the basic pre-compilation for symbol discovery and definition discovery. This constructs the AST such that we can parse the AST to determine what fields are present on each `struct` and what variants are used in each `union`.
+-
     For each type added to the type table (including monomorphs where we have all of the polymorphic variables fully specified), we will traverse all of the members and their types. For each type we will check if was already checked not to be cyclic. If it was already completely checked, then all types up until the most recently checked type cannot be cyclic (another member might still make them cyclic). If the type was not completely checked, but previously encountered in our search for loops, then all of types from the first encounter of that type are considered part of a type loop.
+-
     Note that this algorithm is recursive in the sense that for structs we need to check each member for type loops. For unions we need to check each embedded type in each variant. So when we encounter a type loop for a specific set of members, we walk back and mark each of the unions along the way as requiring allocation. If there were no such unions then we immediately return an error. We keep all of the unions that require allocation around in a list.
+-
    While we're doing the above, if we encounter a union who has a member that does not exist in a type loop then we mark it as non-infinite.
+-
    After all of the above is done, we need to check all of the unions we have encountered. Necessarily if we started with a particular type, and recursively checked all of the embedded types, then we will discover *all* type loops. If none of the unions is non-infinite, then we throw an error (which might be kind of hard, because what kind of error do we show in the case of the `union A; union B; union C;` example?). With the algorithm above, we now know that if there are type loops, that each of them contains at least one union. With the condition that there is at least one non-infinite union we now know that the type is expressable. The constructed list of unions only contains unions that were part of a type loop.
    With that knowledge, to guarantee consistent compilation, we will decide to make each union in each type loop, whether it is infinite or non-infinite, a pointerlike union.
+-
    A pointerlike union's value will consist of a tag, plus reserved size (with the proper alignment) for the largest non-pointerlike union variant if it is larger than the size of a pointer on the particular machine. If it is smaller, than we just need a tag, and a pointer that is properly aligned. So the union value will have a fixed size that is not dependent on the types that were part of the type cycle. I'll call the variants that were not part of type cycles "value variants", and parts that *were* part of type cycles "pointer variants".
 Then, during runtime, as an initial implementation (we could be smarter if we know the old value and know the new value, but that would take a lot of static analysis, we're not yet at that point in the compiler), we will check the tag value whether the old and new values are pointers. If the old and new variants are both pointer variants, or when they're both value variants, then we do not (re)allocate. If we go from a value variant to a pointer variant then we allocate. If we go from a pointer variant to a value variant then we deallocate.
 ## Some Examples of the Algorithm
 I wrote these before I started writing all of the above, I'll keep it here for some concrete examples of the algorithm.
 ### Truly Infinite Example with Structs
 ```pdl
 // Most simple case
 struct SelfReferential{ SelfReferential field }
 // Slightly more complicated case
 struct DualA { DualB b }
 struct DualB { DualA a }
 ```
 In some sense we would be able to compute the sizes of these datastructures, we simply make their fields pointers. Let's assume 64 bit systems for all of these examples. For just the first case we would then have that `SelfReferential` has a size of 8 bytes. However, we always need to allocate its member `field`. So this would always take up an infinite amount of memory. We disallow this case because we would never be able to construct a literal of these kinds of datatypes.
 ### Truly Infinite Example with Unions
 ```pdl
 struct S { UOne one, UTwo two }
 union UOne { Struct(S), One(UOne), Two(UTwo) }
 union UTwo { One(UOne), Two(UTwo) }
 ```
 Again, here we have a case where we can compute the sizes. We make the unions have pointerlike contents. So the unions will be 16 bytes (8 bytes for the tag and padding for pointer alignment, then an 8 byte pointer). Hence the struct will be 32 bytes. But once more we can never construct a literal and instantiating an element would always take up an infinite amount of memory.
 ### Slightly Ambiguous Example
 With the following example we get one union which is non-infinite.
 ```pdl
 struct SEnd { u32 some_value }
 struct SMiddle {
    SEnd this_ends,
    UOne union_one,
    UTwo union_two,
+}
 union UOne { One(UOne), Two(UTwo), Struct(SMiddle) }
 union UTwo { One(UOne), Two(UTwo), End(u32) }
 ```
 If we draw the type graph, we get something like:
 ```pdl
 +--------+        +---------+        +-------+        +-------+
 | struct |        | struct  | <----- | union | <----- | union |
 | SEnd   | -----> | SMiddle | -----> | UOne  | -----> | UTwo  |
 +--------+        +---------+        +-------+        +-------+
                                       |     ^          |     ^
                                       |     |          |     |
                                       \-----/          \-----/
 ```
 For this case we can actually always construct a literal of `SMiddle`. Viewing the literal as a tree (each node a type instance) then we can terminate the tree branches using `UTwo::End`. However, if we would just make `UTwo` pointerlike, we cannot compute the size of `UOne` (it contains a reference to itself, so would grow infinitely in size). This hints at that we should make `UOne` pointerlike as well.
 ### Slightly Ambiguous Example, Version 2
 Not really ambiguous, but just to show that not all unions which are part of a connected type graph need to be turned into pointerlike unions.
 ```pdl
 union Value {
     Unsigned(u64),
     Signed(s64),
     Undefined
+}
 struct Node {
     Value value,
     Children children
+}
 union Children {
     One(Node),
     Two(Node, Node),
     None
+}
 ```
 We get a cycle between `Node` and `Children`, so we would want to implement `Children` as being pointerlike. But we don't have to make `Value` pointerlike. In terms of the described algorithm: `Value` is not part of a type loop, so is not considered a candidate for being pointerlike.
 ### Slightly Ambigious Example, Version 3
 Contains part of the type graph that is not part of a type loop. So the associated union should not be pointerlike.
 ```pdl
 // Parts that are outside of the type loop
 struct SOutside {
     UOutside next,
+}
 union UOutside {
     Next(SInside)
+}
 // Parts that are inside the type loop
 struct SInside {
     UInside next,
+}
 union UInside {
     Next(SInside),
     NoNext,
+}
 ```
 Here `UInside` should become pointerlike, but `UOutside` should remain a normal value.
 ### Which Union Breaks the Cycle?
 ```pdl
 struct S { UOne one }
 union UOne { Two(UTwo), Nope }
 union UTwo { Struct(S), Nope }
 ```
 Here we see that we have a type loop to which both unions contribute. We can either lay out `UOne` as pointerlike, or `UTwo`. Both would allow us to calculate the size of the types and make the type expressable. However we need consistent compilation. For this reason and this reason only (because it is much more efficient to only lay out one of the unions as a pointer) we have to make both unions pointerlike. Perhaps in the future some other consistent metric can be applied.
 ### Does it even Matter?
 ```pdl
 // Obviously doesn't use `T`
 enum Something<T> { A, B }
 // So this should be fine
 struct Foo {
     Something<Foo> some_member,
+}
 ```
 Here we have a struct `Foo` that has a reliance on `Something<Foo>`, but this shouldn't case a type loop. Because `Foo` doesn't actually appear in `Something`. So whatever algorithm we come up with should resolve member types not by iterating over each individual type, but by attempting to instantiate a monomorph of that type, then to check the members of that monomorph.
@@ \ No newline at end of file @@

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -544,428 +544,422 @@ pub struct ScopeNode { @@
 impl ScopeNode {
     pub(crate) fn new_invalid() -> Self {
         ScopeNode{
             parent: Scope::Definition(DefinitionId::new_invalid()),
             nested: Vec::new(),
+        }
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum VariableKind {
     Parameter,      // in parameter list of function/component
     Local,          // declared in function/component body
     Binding,        // may be bound to in a binding expression (determined in validator/linker)
+}
 #[derive(Debug, Clone)]
 pub struct Variable {
     pub this: VariableId,
     // Parsing
     pub kind: VariableKind,
     pub parser_type: ParserType,
     pub identifier: Identifier,
     // Validator/linker
     pub relative_pos_in_block: u32,
     pub unique_id_in_scope: i32, // Temporary fix until proper bytecode/asm is generated
+}
 #[derive(Debug, Clone)]
 pub enum Definition {
     Struct(StructDefinition),
     Enum(EnumDefinition),
     Union(UnionDefinition),
     Component(ComponentDefinition),
     Function(FunctionDefinition),
+}
 impl Definition {
     pub fn is_struct(&self) -> bool {
         match self {
             Definition::Struct(_) => true,
             _ => false
+        }
+    }
     pub(crate) fn as_struct(&self) -> &StructDefinition {
         match self {
             Definition::Struct(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'StructDefinition'"),
+        }
+    }
     pub(crate) fn as_struct_mut(&mut self) -> &mut StructDefinition {
         match self {
             Definition::Struct(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'StructDefinition'"),
+        }
+    }
     pub fn is_enum(&self) -> bool {
         match self {
             Definition::Enum(_) => true,
             _ => false,
+        }
+    }
     pub(crate) fn as_enum(&self) -> &EnumDefinition {
         match self {
             Definition::Enum(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'EnumDefinition'"),
+        }
+    }
     pub(crate) fn as_enum_mut(&mut self) -> &mut EnumDefinition {
         match self {
             Definition::Enum(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'EnumDefinition'"),
+        }
+    }
     pub fn is_union(&self) -> bool {
         match self {
             Definition::Union(_) => true,
             _ => false,
+        }
+    }
     pub(crate) fn as_union(&self) -> &UnionDefinition {
         match self {
             Definition::Union(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'UnionDefinition'"),
+        }
+    }
     pub(crate) fn as_union_mut(&mut self) -> &mut UnionDefinition {
         match self {
             Definition::Union(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'UnionDefinition'"),
+        }
+    }
     pub fn is_component(&self) -> bool {
         match self {
             Definition::Component(_) => true,
             _ => false,
+        }
+    }
     pub(crate) fn as_component(&self) -> &ComponentDefinition {
         match self {
             Definition::Component(result) => result,
             _ => panic!("Unable to cast `Definition` to `Component`"),
+        }
+    }
     pub(crate) fn as_component_mut(&mut self) -> &mut ComponentDefinition {
         match self {
             Definition::Component(result) => result,
             _ => panic!("Unable to cast `Definition` to `Component`"),
+        }
+    }
     pub fn is_function(&self) -> bool {
         match self {
             Definition::Function(_) => true,
             _ => false,
+        }
+    }
     pub(crate) fn as_function(&self) -> &FunctionDefinition {
         match self {
             Definition::Function(result) => result,
             _ => panic!("Unable to cast `Definition` to `Function`"),
+        }
+    }
     pub(crate) fn as_function_mut(&mut self) -> &mut FunctionDefinition {
         match self {
             Definition::Function(result) => result,
             _ => panic!("Unable to cast `Definition` to `Function`"),
+        }
+    }
     pub fn parameters(&self) -> &Vec<VariableId> {
         match self {
             Definition::Component(def) => &def.parameters,
             Definition::Function(def) => &def.parameters,
             _ => panic!("Called parameters() on {:?}", self)
+        }
+    }
     pub fn defined_in(&self) -> RootId {
         match self {
             Definition::Struct(def) => def.defined_in,
             Definition::Enum(def) => def.defined_in,
             Definition::Union(def) => def.defined_in,
             Definition::Component(def) => def.defined_in,
             Definition::Function(def) => def.defined_in,
+        }
+    }
     pub fn identifier(&self) -> &Identifier {
         match self {
             Definition::Struct(def) => &def.identifier,
             Definition::Enum(def) => &def.identifier,
             Definition::Union(def) => &def.identifier,
             Definition::Component(def) => &def.identifier,
             Definition::Function(def) => &def.identifier,
+        }
+    }
     pub fn poly_vars(&self) -> &Vec<Identifier> {
         match self {
             Definition::Struct(def) => &def.poly_vars,
             Definition::Enum(def) => &def.poly_vars,
             Definition::Union(def) => &def.poly_vars,
             Definition::Component(def) => &def.poly_vars,
             Definition::Function(def) => &def.poly_vars,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct StructFieldDefinition {
     pub span: InputSpan,
     pub field: Identifier,
     pub parser_type: ParserType,
+}
 #[derive(Debug, Clone)]
 pub struct StructDefinition {
     pub this: StructDefinitionId,
     pub defined_in: RootId,
     // Symbol scanning
     pub span: InputSpan,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Parsing
     pub fields: Vec<StructFieldDefinition>
+}
 impl StructDefinition {
     pub(crate) fn new_empty(
         this: StructDefinitionId, defined_in: RootId, span: InputSpan,
         identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self{ this, defined_in, span, identifier, poly_vars, fields: Vec::new() }
+    }
+}
 #[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 pub enum EnumVariantValue {
     None,
     Integer(i64),
+}
 #[derive(Debug, Clone)]
 pub struct EnumVariantDefinition {
     pub identifier: Identifier,
     pub value: EnumVariantValue,
+}
 #[derive(Debug, Clone)]
 pub struct EnumDefinition {
     pub this: EnumDefinitionId,
     pub defined_in: RootId,
     // Symbol scanning
     pub span: InputSpan,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Parsing
     pub variants: Vec<EnumVariantDefinition>,
+}
 impl EnumDefinition {
     pub(crate) fn new_empty(
         this: EnumDefinitionId, defined_in: RootId, span: InputSpan,
         identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self{ this, defined_in, span, identifier, poly_vars, variants: Vec::new() }
+    }
+}
 #[derive(Debug, Clone)]
 pub enum UnionVariantValue {
     None,
     Embedded(Vec<ParserType>),
+}
 #[derive(Debug, Clone)]
 pub struct UnionVariantDefinition {
     pub span: InputSpan,
     pub identifier: Identifier,
-    pub value: UnionVariantValue,
+    pub value: Vec<ParserType>, // if empty, then union variant does not contain any embedded types
+}
 #[derive(Debug, Clone)]
 pub struct UnionDefinition {
     pub this: UnionDefinitionId,
     pub defined_in: RootId,
     // Phase 1: symbol scanning
     pub span: InputSpan,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Phase 2: parsing
     pub variants: Vec<UnionVariantDefinition>,
+}
 impl UnionDefinition {
     pub(crate) fn new_empty(
         this: UnionDefinitionId, defined_in: RootId, span: InputSpan,
         identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self{ this, defined_in, span, identifier, poly_vars, variants: Vec::new() }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum ComponentVariant {
     Primitive,
     Composite,
+}
 #[derive(Debug, Clone)]
 pub struct ComponentDefinition {
     pub this: ComponentDefinitionId,
     pub defined_in: RootId,
     // Symbol scanning
     pub span: InputSpan,
     pub variant: ComponentVariant,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Parsing
     pub parameters: Vec<VariableId>,
     pub body: BlockStatementId,
     // Validation/linking
     pub num_expressions_in_body: i32,
+}
 impl ComponentDefinition {
     // Used for preallocation during symbol scanning
     pub(crate) fn new_empty(
         this: ComponentDefinitionId, defined_in: RootId, span: InputSpan,
         variant: ComponentVariant, identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self{
             this, defined_in, span, variant, identifier, poly_vars,
             parameters: Vec::new(),
             body: BlockStatementId::new_invalid(),
             num_expressions_in_body: -1,
+        }
+    }
+}
 // Note that we will have function definitions for builtin functions as well. In
 // that case the span, the identifier span and the body are all invalid.
 #[derive(Debug, Clone)]
 pub struct FunctionDefinition {
     pub this: FunctionDefinitionId,
     pub defined_in: RootId,
     // Symbol scanning
     pub builtin: bool,
     pub span: InputSpan,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Parser
     pub return_types: Vec<ParserType>,
     pub parameters: Vec<VariableId>,
     pub body: BlockStatementId,
     // Validation/linking
     pub num_expressions_in_body: i32,
+}
 impl FunctionDefinition {
     pub(crate) fn new_empty(
         this: FunctionDefinitionId, defined_in: RootId, span: InputSpan,
         identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self {
             this, defined_in,
             builtin: false,
             span, identifier, poly_vars,
             return_types: Vec::new(),
             parameters: Vec::new(),
             body: BlockStatementId::new_invalid(),
             num_expressions_in_body: -1,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub enum Statement {
     Block(BlockStatement),
     EndBlock(EndBlockStatement),
     Local(LocalStatement),
     Labeled(LabeledStatement),
     If(IfStatement),
     EndIf(EndIfStatement),
     While(WhileStatement),
     EndWhile(EndWhileStatement),
     Break(BreakStatement),
     Continue(ContinueStatement),
     Synchronous(SynchronousStatement),
     EndSynchronous(EndSynchronousStatement),
     Return(ReturnStatement),
     Goto(GotoStatement),
     New(NewStatement),
     Expression(ExpressionStatement),
+}
 impl Statement {
     pub fn as_block(&self) -> &BlockStatement {
         match self {
             Statement::Block(result) => result,
             _ => panic!("Unable to cast `Statement` to `BlockStatement`"),
+        }
+    }
     pub fn as_local(&self) -> &LocalStatement {
         match self {
             Statement::Local(result) => result,
             _ => panic!("Unable to cast `Statement` to `LocalStatement`"),
+        }
+    }
     pub fn as_memory(&self) -> &MemoryStatement {
         self.as_local().as_memory()
+    }
     pub fn as_channel(&self) -> &ChannelStatement {
         self.as_local().as_channel()
+    }
     pub fn as_new(&self) -> &NewStatement {
         match self {
             Statement::New(result) => result,
             _ => panic!("Unable to cast `Statement` to `NewStatement`"),
+        }
+    }
     pub fn span(&self) -> InputSpan {
         match self {
             Statement::Block(v) => v.span,
             Statement::Local(v) => v.span(),
             Statement::Labeled(v) => v.label.span,
             Statement::If(v) => v.span,
             Statement::While(v) => v.span,
             Statement::Break(v) => v.span,
             Statement::Continue(v) => v.span,
             Statement::Synchronous(v) => v.span,
             Statement::Return(v) => v.span,
             Statement::Goto(v) => v.span,
             Statement::New(v) => v.span,
             Statement::Expression(v) => v.span,
             Statement::EndBlock(_) | Statement::EndIf(_) | Statement::EndWhile(_) | Statement::EndSynchronous(_) => unreachable!(),
+        }
+    }
     pub fn link_next(&mut self, next: StatementId) {
         match self {
             Statement::Block(stmt) => stmt.next = next,
             Statement::EndBlock(stmt) => stmt.next = next,
             Statement::Local(stmt) => match stmt {
                 LocalStatement::Channel(stmt) => stmt.next = next,
                 LocalStatement::Memory(stmt) => stmt.next = next,
             },
             Statement::EndIf(stmt) => stmt.next = next,
             Statement::EndWhile(stmt) => stmt.next = next,
             Statement::EndSynchronous(stmt) => stmt.next = next,
             Statement::New(stmt) => stmt.next = next,
             Statement::Expression(stmt) => stmt.next = next,
             Statement::Return(_)
             | Statement::Break(_)
             | Statement::Continue(_)
             | Statement::Synchronous(_)
             | Statement::Goto(_)
             | Statement::While(_)
             | Statement::Labeled(_)
             | Statement::If(_) => unreachable!(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct BlockStatement {
     pub this: BlockStatementId,
     // Phase 1: parser
     pub is_implicit: bool,
     pub span: InputSpan, // of the complete block
     pub statements: Vec<StatementId>,

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 (called 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.
+ *
  * 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.
  */
 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,
+}
 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_enum(&self) -> &EnumType {
         match self {
             DefinedTypeVariant::Enum(v) => v,
             _ => unreachable!("Cannot convert {} to enum variant", self.type_class())
+        }
+    }
     pub(crate) fn as_union(&self) -> &UnionType {
         match self {
             DefinedTypeVariant::Union(v) => v,
             _ => unreachable!("Cannot convert {} to union variant", self.type_class())
+        }
+    }
     pub(crate) fn as_union_mut(&mut self) -> &mut UnionType {
         match self {
             DefinedTypeVariant::Union(v) => v,
             _ => unreachable!("Cannot convert {} to union variant", self.type_class())
+        }
+    }
     pub(crate) fn data_monomorphs(&self) -> &Vec<DataMonomorph> {
         use DefinedTypeVariant::*;
         match self {
             Enum(v) => &v.monomorphs,
             Union(v) => &v.monomorphs,
             Struct(v) => &v.monomorphs,
             _ => unreachable!("cannot get data monomorphs from {}", self.type_class()),
+        }
+    }
     pub(crate) fn data_monomorphs_mut(&mut self) -> &mut Vec<DataMonomorph> {
         use DefinedTypeVariant::*;
         match self {
             Enum(v) => &mut v.monomorphs,
             Union(v) => &mut v.monomorphs,
             Struct(v) => &mut v.monomorphs,
             _ => unreachable!("cannot get data monomorphs from {}", self.type_class()),
+        }
+    }
     pub(crate) fn procedure_monomorphs(&self) -> &Vec<ProcedureMonomorph> {
         use DefinedTypeVariant::*;
         match self {
             Function(v) => &v.monomorphs,
             Component(v) => &v.monomorphs,
             _ => unreachable!("cannot get procedure monomorphs from {}", self.type_class()),
+        }
+    }
     pub(crate) fn procedure_monomorphs_mut(&mut self) -> &mut Vec<ProcedureMonomorph> {
         use DefinedTypeVariant::*;
         match self {
             Function(v) => &mut v.monomorphs,
             Component(v) => &mut v.monomorphs,
             _ => unreachable!("cannot get procedure monomorphs from {}", self.type_class()),
+        }
+    }
+}
 pub struct PolymorphicVariable {
     identifier: Identifier,
     is_in_use: bool, // a polymorphic argument may be defined, but not used by the type definition
+}
 /// Data associated with a monomorphized datatype
 pub struct DataMonomorph {
     pub poly_args: Vec<ConcreteType>,
+}
 /// Data associated with a monomorphized procedure type. Has the wrong name,
 /// because it will also be used to store expression data for a non-polymorphic
 /// procedure. (in that case, there will only ever be one)
 pub struct ProcedureMonomorph {
     // Expression data for one particular monomorph
     pub poly_args: Vec<ConcreteType>,
     pub expr_data: Vec<MonomorphExpression>,
+}
 /// `EnumType` is the classical C/C++ enum type. It has various variants with
 /// an assigned integer value. The integer values may be user-defined,
 /// compiler-defined, or a mix of the two. If a user assigns the same enum
 /// value multiple times, we assume the user is an expert and we consider both
 /// variants to be equal to one another.
 pub struct EnumType {
     pub variants: Vec<EnumVariant>,
     pub monomorphs: Vec<DataMonomorph>,
+}
 // TODO: Also support maximum u64 value
 pub struct EnumVariant {
     pub identifier: Identifier,
     pub value: i64,
+}
 /// `UnionType` is the algebraic datatype (or sum type, or discriminated union).
 /// A value is an element of the union, identified by its tag, and may contain
 /// a single subtype.
 /// For potentially infinite types (i.e. a tree, or a linked list) only unions
 /// can break the infinite cycle. So when we lay out these unions in memory we
 /// will reserve enough space on the stack for all union variants that do not
 /// cause "type loops" (i.e. a union `A` with a variant containing a struct
 /// `B`). And we will reserve enough space on the heap (and store a pointer in
 /// the union) for all variants which do cause type loops (i.e. a union `A`
 /// with a variant to a struct `B` that contains the union `A` again).
 pub struct UnionType {
     pub variants: Vec<UnionVariant>,
     pub monomorphs: Vec<DataMonomorph>,
     pub requires_allocation: bool,
     pub contains_unallocated_variant: bool,
+}
 pub struct UnionVariant {
     pub identifier: Identifier,
     pub embedded: Vec<ParserType>, // zero-length does not have embedded values
     pub tag_value: i64,
     pub exists_in_heap: bool,
+}
 pub struct StructType {
     pub fields: Vec<StructField>,
     pub monomorphs: Vec<DataMonomorph>,
+}
 pub struct StructField {
     pub identifier: Identifier,
     pub parser_type: ParserType,
+}
 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
 //------------------------------------------------------------------------------
 // TODO: @cleanup Do I really need this, doesn't make the code that much cleaner
 struct TypeIterator {
     breadcrumbs: Vec<(RootId, DefinitionId)>
+}
 impl TypeIterator {
     fn new() -> Self {
         Self{ breadcrumbs: Vec::with_capacity(32) }
+    }
     fn reset(&mut self, root_id: RootId, definition_id: DefinitionId) {
         self.breadcrumbs.clear();
         self.breadcrumbs.push((root_id, definition_id))
+    }
     fn push(&mut self, root_id: RootId, definition_id: DefinitionId) {
         self.breadcrumbs.push((root_id, definition_id));
+    }
     fn contains(&self, root_id: RootId, definition_id: DefinitionId) -> bool {
         for (stored_root_id, stored_definition_id) in self.breadcrumbs.iter() {
             if *stored_root_id == root_id && *stored_definition_id == definition_id { return true; }
+        }
         return false
+    }
     fn top(&self) -> Option<(RootId, DefinitionId)> {
         self.breadcrumbs.last().map(|(r, d)| (*r, *d))
+    }
     fn pop(&mut self) {
         debug_assert!(!self.breadcrumbs.is_empty());
         self.breadcrumbs.pop();
+    }
 struct ResolveBreadcrumb {
     root_id: RootId,
     definition_id: DefinitionId,
     next_member: u32,
     next_embedded: u32, // for unions, the next embedded value inside the member
     progression: DefinedTypeVariant
+}
 /// Result from attempting to resolve a `ParserType` using the symbol table and
 /// the type table.
 enum ResolveResult {
     Builtin,
     PolymoprhicArgument,
     /// ParserType points to a user-defined type that is already resolved in the
     /// type table.
     Resolved(RootId, DefinitionId),
     /// ParserType points to a user-defined type that is not yet resolved into
     /// the type table.
     Unresolved(RootId, DefinitionId)
+}
 /// Result from attempting to progress a breadcrumb
 enum ProgressResult {
     PopBreadcrumb,
     PushBreadcrumb(RootId, DefinitionId),
     TypeLoop(RootId, DefinitionId),
+}
 pub struct TypeTable {
     /// Lookup from AST DefinitionId to a defined type. Considering possible
     /// polymorphs is done inside the `DefinedType` struct.
     lookup: HashMap<DefinitionId, DefinedType>,
     /// Iterator over `(module, definition)` tuples used as workspace to make sure
     /// that each base definition of all a type's subtypes are resolved.
     iter: TypeIterator,
     /// Breadcrumbs left behind while resolving embedded types
     breadcrumbs: Vec<ResolveBreadcrumb>,
     infinite_unions: Vec<(RootId, DefinitionId)>,
+}
 impl TypeTable {
     /// Construct a new type table without any resolved types.
     pub(crate) fn new() -> Self {
         Self{
             lookup: HashMap::new(),
             iter: TypeIterator::new(),
             breadcrumbs: Vec::with_capacity(32),
             infinite_unions: Vec::with_capacity(16),
+        }
+    }
     /// 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());
         debug_assert!(self.iter.top().is_none());
         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
+        // 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);
             self.resolve_base_definition(modules, ctx, definition_id)?;
             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;
+        }
         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];
+    }
     /// Reserves space for a monomorph of a polymorphic procedure. The index
     /// will point into a (reserved) slot of the array of expression types. The
     /// monomorph may NOT exist yet (because the reservation implies that we're
     /// going to be performing typechecking on it, and we don't want to
     /// check the same monomorph twice)
     pub(crate) fn reserve_procedure_monomorph_index(&mut self, definition_id: &DefinitionId, types: Option<Vec<ConcreteType>>) -> i32 {
         let def = self.lookup.get_mut(definition_id).unwrap();
         if let Some(types) = types {
             // Expecting a polymorphic procedure
             let monos = def.definition.procedure_monomorphs_mut();
             debug_assert!(def.is_polymorph);
             debug_assert!(def.poly_vars.len() == types.len());
             debug_assert!(monos.iter().find(|v| v.poly_args == types).is_none());
             let mono_idx = monos.len();
             monos.push(ProcedureMonomorph{ poly_args: types, expr_data: Vec::new() });
             return mono_idx as i32;
         } else {
             // Expecting a non-polymorphic procedure
             let monos = def.definition.procedure_monomorphs_mut();
             debug_assert!(!def.is_polymorph);
             debug_assert!(def.poly_vars.is_empty());
             debug_assert!(monos.is_empty());
             monos.push(ProcedureMonomorph{ poly_args: Vec::new(), expr_data: Vec::new() });
             return 0;
+        }
+    }
     /// 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.
     pub(crate) fn add_data_monomorph(&mut self, definition_id: &DefinitionId, types: Vec<ConcreteType>) -> i32 {
         let def = self.lookup.get_mut(definition_id).unwrap();
         if !def.is_polymorph {
             // Not a polymorph, or polyvars are not used in type definition
             return 0;
+        }
         let monos = def.definition.data_monomorphs_mut();
         if let Some(index) = monos.iter().position(|v| v.poly_args == types) {
             // We already know about this monomorph
             return index as i32;
+        }
         let index = monos.len();
         monos.push(DataMonomorph{ poly_args: types });
         return index as i32;
+    }
     /// This function will resolve just the basic definition of the type, it
     /// will not handle any of the monomorphized instances of the type.
     fn resolve_base_definition<'a>(&'a mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {
         // Check if we have already resolved the base definition
         if self.lookup.contains_key(&definition_id) { return Ok(()); }
         let root_id = ctx.heap[definition_id].defined_in();
         self.iter.reset(root_id, definition_id);
         // We haven't, push the first breadcrumb and start resolving
         self.push_breadcrumb_for_definition(ctx, definition_id);
-        while let Some((root_id, definition_id)) = self.iter.top() {
+        while let Some(breadcrumb) = self.breadcrumbs.last() {
             // We have a type to resolve
             let definition = &ctx.heap[definition_id];
+            let definition = &ctx.heap[breadcrumb.definition_id];
             let can_pop_breadcrumb = match definition {
                 // Bit ugly, since we already have the definition, but we need
                 // to work around rust borrowing rules...
                 Definition::Enum(_) => self.resolve_base_enum_definition(modules, ctx, root_id, definition_id),
                 Definition::Union(_) => self.resolve_base_union_definition(modules, ctx, root_id, definition_id),
                 Definition::Struct(_) => self.resolve_base_struct_definition(modules, ctx, root_id, definition_id),
                 Definition::Component(_) => self.resolve_base_component_definition(modules, ctx, root_id, definition_id),
                 Definition::Function(_) => self.resolve_base_function_definition(modules, ctx, root_id, definition_id),
                 Definition::Enum(_) => self.resolve_base_enum_definition(modules, ctx),
                 Definition::Union(_) => self.resolve_base_union_definition(modules, ctx),
                 Definition::Struct(_) => self.resolve_base_struct_definition(modules, ctx),
                 Definition::Component(_) => self.resolve_base_component_definition(modules, ctx),
                 Definition::Function(_) => self.resolve_base_function_definition(modules, ctx),
             }?;
             // Otherwise: `ingest_resolve_result` has pushed a new breadcrumb
             // that we must follow before we can resolve the current type
             if can_pop_breadcrumb {
-                self.iter.pop();
+                self.breadcrumbs.pop();
+            }
+        }
         // We must have resolved the type
         debug_assert!(self.lookup.contains_key(&definition_id), "base type not resolved");
         Ok(())
+    }
     /// Builds the base type for an enum. Will not compute byte sizes
     fn build_base_enum_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {
         debug_assert!(!self.lookup.contains_key(&definition_id), "base enum already built");
         let definition = ctx.heap[definition_id].as_enum();
         let root_id = definition.defined_in;
         // Determine enum variants
         let mut enum_value = -1;
         let mut variants = Vec::with_capacity(definition.variants.len());
         for variant in &definition.variants {
             if enum_value == i64::MAX {
                 let source = &modules[definition.defined_in.index as usize].source;
                 return Err(ParseError::new_error_str_at_span(
                     source, variant.identifier.span,
                     "this enum variant has an integer value that is too large"
                 ));
+            }
             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);
+            }
+        }
         // TODO: Tag size determination, here or when laying out?
         // 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.lookup.insert(definition_id, DefinedType {
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Enum(EnumType{
                 variants,
                 monomorphs: Vec::new(),
             }),
             poly_vars,
             is_polymorph: false,
         });
         return Ok(());
+    }
     fn build_base_struct_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {
         debug_assert!(!self.lookup.contains_key(&definition_id), "base struct already built");
         let definition = ctx.heap[definition_id].as_struct();
         let root_id = definition.defined_in;
         // Go through all struct fields
         let mut fields = Vec::with_capacity(definition.fields.len());
         for field in &definition.fields {
             // Make sure the
+        }
+    }
     /// Resolve the basic enum definition to an entry in the type table. It will
     /// not instantiate any monomorphized instances of polymorphic enum
     /// definitions. If a subtype has to be resolved first then this function
     /// will return `false` after calling `ingest_resolve_result`.
     fn resolve_base_enum_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, root_id: RootId, definition_id: DefinitionId) -> Result<bool, ParseError> {
     fn resolve_base_enum_definition(&mut self, modules: &[Module], ctx: &mut PassCtx) -> Result<bool, ParseError> {
         // Retrieve breadcrumb and perform some basic checking
         let breadcrumb = self.breadcrumbs.last_mut().unwrap();
         let root_id = breadcrumb.root_id;
         let definition_id = breadcrumb.definition_id;
         debug_assert!(ctx.heap[definition_id].is_enum());
         debug_assert!(!self.lookup.contains_key(&definition_id), "base enum already resolved");
         let definition = ctx.heap[definition_id].as_enum();
         // Since we're dealing with an enum's base definition, we're not going
         // to check any embedded types and should finish layout out the enum in
         // one go.
         debug_assert!(breadcrumb.progression.is_none());
         // Determine enum variants
         let mut enum_value = -1;
         let mut min_enum_value = 0;
         let mut max_enum_value = 0;
         let mut variants = Vec::with_capacity(definition.variants.len());
         for variant in &definition.variants {
             enum_value += 1;
             match &variant.value {
                 EnumVariantValue::None => {
                     variants.push(EnumVariant{
                         identifier: variant.identifier.clone(),
                         value: enum_value,
                     });
                 },
                 EnumVariantValue::Integer(override_value) => {
                     enum_value = *override_value;
                     variants.push(EnumVariant{
                         identifier: variant.identifier.clone(),
                         value: enum_value,
                     });
+                }
+            }
             if enum_value < min_enum_value { min_enum_value = enum_value; }
             else if enum_value > max_enum_value { max_enum_value = enum_value; }
+        }
         // Ensure enum names and polymorphic args do not conflict
-        self.check_identifier_collision(
+        Self::check_identifier_collision(
             modules, root_id, &variants, |variant| &variant.identifier, "enum variant"
         )?;
         // Because we're parsing an enum, the programmer cannot put the
         // polymorphic variables inside the variants. But the polymorphic
         // variables might still be present as "marker types"
-        self.check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
+        Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
         let poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);
         self.lookup.insert(definition_id, DefinedType {
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Enum(EnumType{
                 variants,
                 monomorphs: Vec::new(),
             }),
             poly_vars,
             is_polymorph: false,
         });
         Ok(true)
+    }
     /// Resolves the basic union definiton to an entry in the type table. It
     /// will not instantiate any monomorphized instances of polymorphic union
     /// definitions. If a subtype has to be resolved first then this function
     /// will return `false` after calling `ingest_resolve_result`.
     fn resolve_base_union_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, root_id: RootId, definition_id: DefinitionId) -> Result<bool, ParseError> {
         debug_assert!(ctx.heap[definition_id].is_union());
         debug_assert!(!self.lookup.contains_key(&definition_id), "base union already resolved");
         let definition = ctx.heap[definition_id].as_union();
         // Make sure all embedded types are resolved
         for variant in &definition.variants {
             match &variant.value {
                 UnionVariantValue::None => {},
                 UnionVariantValue::Embedded(embedded) => {
                     for parser_type in embedded {
                         let resolve_result = self.resolve_base_parser_type(modules, ctx, root_id, parser_type, false)?;
                         if !self.ingest_resolve_result(modules, ctx, resolve_result)? {
                             return Ok(false)
+                        }
+                    }
+                }
+            }
+        }
         // If here then all embedded types are resolved
         // Determine the union variants
         let mut tag_value = -1;
         let mut variants = Vec::with_capacity(definition.variants.len());
         for variant in &definition.variants {
             tag_value += 1;
             let embedded = match &variant.value {
                 UnionVariantValue::None => { Vec::new() },
                 UnionVariantValue::Embedded(embedded) => {
                     // Type should be resolvable, we checked this above
                     embedded.clone()
                 },
             };
             variants.push(UnionVariant{
                 identifier: variant.identifier.clone(),
                 embedded,
                 tag_value,
                 exists_in_heap: false
             })
+        }
         // Ensure union names and polymorphic args do not conflict
-        self.check_identifier_collision(
+        Self::check_identifier_collision(
             modules, root_id, &variants, |variant| &variant.identifier, "union variant"
         )?;
-        self.check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
+        Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
         // Construct polymorphic variables and mark the ones that are in use
         let mut poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);
         for variant in &variants {
             for parser_type in &variant.embedded {
                 Self::mark_used_polymorphic_variables(&mut poly_vars, parser_type);
+            }
+        }
         let is_polymorph = poly_vars.iter().any(|arg| arg.is_in_use);
         // Insert base definition in type table
         self.lookup.insert(definition_id, DefinedType {
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Union(UnionType{
                 variants,
                 monomorphs: Vec::new(),
                 requires_allocation: false,
                 contains_unallocated_variant: true
             }),
             poly_vars,
             is_polymorph,
         });
         Ok(true)
+    }
     /// Resolves the basic struct definition to an entry in the type table. It
     /// will not instantiate any monomorphized instances of polymorphic struct
     /// definitions.
-    fn resolve_base_struct_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, root_id: RootId, definition_id: DefinitionId) -> Result<bool, ParseError> {
     fn resolve_base_struct_definition(&mut self, modules: &[Module], ctx: &mut PassCtx) -> Result<bool, ParseError> {
         debug_assert!(ctx.heap[definition_id].is_struct());
         debug_assert!(!self.lookup.contains_key(&definition_id), "base struct already resolved");
         let definition = ctx.heap[definition_id].as_struct();
         // Make sure all fields point to resolvable types
         for field_definition in &definition.fields {
             let resolve_result = self.resolve_base_parser_type(modules, ctx, root_id, &field_definition.parser_type, false)?;
             if !self.ingest_resolve_result(modules, ctx, resolve_result)? {
                 return Ok(false)
+            }
+        }
         // All fields types are resolved, construct base type
         let mut fields = Vec::with_capacity(definition.fields.len());
         for field_definition in &definition.fields {
             fields.push(StructField{
                 identifier: field_definition.field.clone(),
                 parser_type: field_definition.parser_type.clone(),
             })
+        }
         // And make sure no conflicts exist in field names and/or polymorphic args
-        self.check_identifier_collision(
+        Self::check_identifier_collision(
             modules, root_id, &fields, |field| &field.identifier, "struct field"
         )?;
-        self.check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
+        Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
         // Construct representation of polymorphic arguments
         let mut poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);
         for field in &fields {
             Self::mark_used_polymorphic_variables(&mut poly_vars, &field.parser_type);
+        }
         let is_polymorph = poly_vars.iter().any(|arg| arg.is_in_use);
         self.lookup.insert(definition_id, DefinedType{
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Struct(StructType{
                 fields,
                 monomorphs: Vec::new(),
             }),
             poly_vars,
             is_polymorph,
         });
         Ok(true)
+    }
     /// Resolves the basic function definition to an entry in the type table. It
     /// will not instantiate any monomorphized instances of polymorphic function
     /// definitions.
     fn resolve_base_function_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, root_id: RootId, definition_id: DefinitionId) -> Result<bool, ParseError> {
         debug_assert!(ctx.heap[definition_id].is_function());
         debug_assert!(!self.lookup.contains_key(&definition_id), "base function already resolved");
         let definition = ctx.heap[definition_id].as_function();
         // Check the return type
         debug_assert_eq!(definition.return_types.len(), 1, "not one return type"); // TODO: @ReturnValues
         let resolve_result = self.resolve_base_parser_type(modules, ctx, root_id, &definition.return_types[0], definition.builtin)?;
         if !self.ingest_resolve_result(modules, ctx, resolve_result)? {
             return Ok(false)
+        }
         // Check the argument types
         for param_id in &definition.parameters {
             let param = &ctx.heap[*param_id];
             let resolve_result = self.resolve_base_parser_type(modules, ctx, root_id, &param.parser_type, definition.builtin)?;
             if !self.ingest_resolve_result(modules, ctx, resolve_result)? {
                 return Ok(false)
+            }
+        }
         // Construct arguments to function
         let mut arguments = Vec::with_capacity(definition.parameters.len());
         for param_id in &definition.parameters {
             let param = &ctx.heap[*param_id];
             arguments.push(FunctionArgument{
                 identifier: param.identifier.clone(),
                 parser_type: param.parser_type.clone(),
             })
+        }
         // Check conflict of argument and polyarg identifiers
-        self.check_identifier_collision(
+        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)?;
+        Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
         // Construct polymorphic arguments
         let mut poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);
         Self::mark_used_polymorphic_variables(&mut poly_vars, &definition.return_types[0]);
         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);
         // Construct entry in type table
         self.lookup.insert(definition_id, DefinedType{
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Function(FunctionType{
                 return_types: definition.return_types.clone(),
                 arguments,
                 monomorphs: Vec::new(),
             }),
             poly_vars,
             is_polymorph,
         });
         Ok(true)
+    }
     /// Resolves the basic component definition to an entry in the type table.
     /// It will not instantiate any monomorphized instancees of polymorphic
     /// component definitions.
     fn resolve_base_component_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, root_id: RootId, definition_id: DefinitionId) -> Result<bool, ParseError> {
         debug_assert!(ctx.heap[definition_id].is_component());
         debug_assert!(!self.lookup.contains_key(&definition_id), "base component already resolved");
         let definition = ctx.heap[definition_id].as_component();
         let component_variant = definition.variant;
         // Check argument types
         for param_id in &definition.parameters {
             let param = &ctx.heap[*param_id];
             let resolve_result = self.resolve_base_parser_type(modules, ctx, root_id, &param.parser_type, false)?;
             if !self.ingest_resolve_result(modules, ctx, resolve_result)? {
                 return Ok(false)
+            }
+        }
         // Construct argument types
         let mut arguments = Vec::with_capacity(definition.parameters.len());
         for param_id in &definition.parameters {
             let param = &ctx.heap[*param_id];
             arguments.push(FunctionArgument{
                 identifier: param.identifier.clone(),
                 parser_type: param.parser_type.clone()
             })
+        }
         // Check conflict of argument and polyarg identifiers
-        self.check_identifier_collision(
+        Self::check_identifier_collision(
             modules, root_id, &arguments, |arg| &arg.identifier, "component argument"
         )?;
-        self.check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
+        Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
         // Construct polymorphic arguments
         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);
+        }
         let is_polymorph = poly_vars.iter().any(|v| v.is_in_use);
         // Construct entry in type table
         self.lookup.insert(definition_id, DefinedType{
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Component(ComponentType{
                 variant: component_variant,
                 arguments,
                 monomorphs: Vec::new(),
             }),
             poly_vars,
             is_polymorph,
         });
         Ok(true)
+    }
     /// Takes a ResolveResult and returns `true` if the caller can happily
     /// continue resolving its current type, or `false` if the caller must break
     /// resolving the current type and exit to the outer resolving loop. In the
     /// latter case the `result` value was `ResolveResult::Unresolved`, implying
     /// that the type must be resolved first.
     fn ingest_resolve_result(&mut self, modules: &[Module], ctx: &PassCtx, result: ResolveResult) -> Result<bool, ParseError> {
         match result {
             ResolveResult::Builtin | ResolveResult::PolymoprhicArgument => Ok(true),
             ResolveResult::Resolved(_, _) => Ok(true),
             ResolveResult::Unresolved(root_id, definition_id) => {
                 if self.iter.contains(root_id, definition_id) {
                     // Cyclic dependency encountered
                     // TODO: Allow this
                     let module_source = &modules[root_id.index as usize].source;
                 } else {
                     // Type is not yet resolved, so push IDs on iterator and
                     // continue the resolving loop
                     self.iter.push(root_id, definition_id);
                     Ok(false)
+                }
+            }
+        }
+    }
     fn construct_cyclic_type_error(
         &self, modules: &[Module], ctx: &PassCtx, type_root_id: RootId, type_definition_id: DefinitionId
     ) -> ParseError {
         debug_assert!(self.iter.contains(type_root_id, type_definition_id));
         // Construct error message put at the top
         let module_source = &modules[type_root_id.index as usize].source;
         let mut error = ParseError::new_error_str_at_span(
-                        module_source, ctx.heap[definition_id].identifier().span,
+            module_source, ctx.heap[type_definition_id].identifier().span,
             "Evaluating this type definition results in a cyclic type"
         );
         // Show a listing of all dependent types.
         // TODO: Make more correct later
         for (breadcrumb_idx, (root_id, definition_id)) in self.iter.breadcrumbs.iter().enumerate() {
             let msg = if breadcrumb_idx == 0 {
                 "The cycle started with this definition"
             } else {
                 "Which depends on this definition"
             };
             let module_source = &modules[root_id.index as usize].source;
             error = error.with_info_str_at_span(module_source, ctx.heap[*definition_id].identifier().span, msg);
+        }
                     Err(error)
                 } else {
                     // Type is not yet resolved, so push IDs on iterator and
                     // continue the resolving loop
                     self.iter.push(root_id, definition_id);
                     Ok(false)
+                }
+            }
         return error;
+    }
     /// Will check if the member type (field of a struct, embedded type in a
     /// union variant) is valid.
     fn check_parser_type_for_base_definition(
         &self, modules: &[Module], ctx: &PassCtx, base_definition_root_id: RootId,
         member_parser_type: &ParserType, allow_special_compiler_types: bool
     ) -> Result<(), ParseError> {
         use ParserTypeVariant as PTV;
+    }
     /// Each type may consist of embedded types. If this type does not have a
     /// fixed implementation (e.g. an input port may have an embedded type
     /// indicating the type of messages, but it always exists in the runtime as
     /// a port identifier, so it has a fixed implementation) then this function
     /// will traverse the embedded types to ensure all of them are resolved.
     ///
     /// Hence if one checks a particular parser type for being resolved, one may
     /// get back a result value indicating an embedded type (with a different
     /// DefinitionId) is unresolved.
     fn resolve_base_parser_type(
         &mut self, modules: &[Module], ctx: &PassCtx, root_id: RootId,
-        parser_type: &ParserType, is_builtin: bool
+        parser_type: &ParserType, allow_special_compiler_types: bool
     ) -> Result<ResolveResult, ParseError> {
         use ParserTypeVariant as PTV;
         // Result for the very first time we resolve a type (i.e the outer type
         // that we're actually looking up)
         let mut resolve_result = None;
         let mut set_resolve_result = |v: ResolveResult| {
             if resolve_result.is_none() { resolve_result = Some(v); }
         };
         for element in parser_type.elements.iter() {
             match element.variant {
                 PTV::Void | PTV::InputOrOutput | PTV::ArrayLike | PTV::IntegerLike => {
-                    if is_builtin {
+                    if allow_special_compiler_types {
                         set_resolve_result(ResolveResult::Builtin);
                     } else {
                         unreachable!("compiler-only ParserTypeVariant within type definition");
+                    }
                 },
                 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 => {
                     // Nothing to do: these are builtin types or types with a
                     // fixed implementation
                     set_resolve_result(ResolveResult::Builtin);
                 },
                 PTV::IntegerLiteral | PTV::Inferred => {
                     // As we're parsing the type definitions where these kinds
                     // of types are impossible/disallowed to express:
                     unreachable!("illegal ParserTypeVariant within type definition");
                 },
                 PTV::PolymorphicArgument(_, _) => {
                     set_resolve_result(ResolveResult::PolymoprhicArgument);
                 },
                 PTV::Definition(embedded_id, _) => {
                     let definition = &ctx.heap[embedded_id];
                     if !(definition.is_struct() || definition.is_enum() || definition.is_union()) {
                         let module_source = &modules[root_id.index as usize].source;
                         return Err(ParseError::new_error_str_at_span(
                             module_source, element.element_span, "expected a datatype (struct, enum or union)"
                         ))
+                    }
                     if self.lookup.contains_key(&embedded_id) {
                         set_resolve_result(ResolveResult::Resolved(definition.defined_in(), embedded_id))
                     } else {
                         return Ok(ResolveResult::Unresolved(definition.defined_in(), embedded_id))
+                    }
+                }
+            }
+        }
         // If here then all types in the embedded type's tree were resolved.
         debug_assert!(resolve_result.is_some(), "faulty logic in ParserType resolver");
         return Ok(resolve_result.unwrap())
+    }
     /// Go through a list of identifiers and ensure that all identifiers have
     /// unique names
     fn check_identifier_collision<T: Sized, F: Fn(&T) -> &Identifier>(
-        &self, modules: &[Module], root_id: RootId, items: &[T], getter: F, item_name: &'static str
         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(
-        &self, modules: &[Module], ctx: &PassCtx, root_id: RootId, poly_args: &[Identifier]
         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(())
+    }
     //--------------------------------------------------------------------------
     // Breadcrumb management
     //--------------------------------------------------------------------------
     /// Pushes a breadcrumb for a particular definition. The field in the
     /// breadcrumb tracking progress in defining the type will be preallocated
     /// as best as possible.
     fn push_breadcrumb_for_definition(&mut self, ctx: &PassCtx, definition_id: DefinitionId) {
         let definition = &ctx.heap[definition_id];
         let (root_id, progression) = match definition {
             Definition::Struct(definition) => {
+                (
                     definition.defined_in,
                     DefinedTypeVariant::Struct(StructType{
                         fields: Vec::with_capacity(definition.fields.len()),
                         monomorphs: Vec::new(),
                     })
+                )
             },
             Definition::Enum(definition) => {
+                (
                     definition.defined_in,
                     DefinedTypeVariant::Enum(EnumType{
                         variants: Vec::with_capacity(definition.variants.len()),
                         monomorphs: Vec::new(),
                     })
+                )
             },
             Definition::Union(definition) => {
+                (
                     definition.defined_in,
                     DefinedTypeVariant::Union(UnionType{
                         variants: Vec::with_capacity(definition.variants.len()),
                         monomorphs: Vec::new(),
                         requires_allocation: false,
                         contains_unallocated_variant: false
                     })
+                )
             },
             Definition::Component(definition) => {
+                (
                     definition.defined_in,
                     DefinedTypeVariant::Component(ComponentType{
                         variant: definition.variant,
                         arguments: Vec::with_capacity(definition.parameters.len()),
                         monomorphs: Vec::new(),
                     })
+                )
             },
             Definition::Function(definition) => {
+                (
                     definition.defined_in,
                     DefinedTypeVariant::Function(FunctionType{
                         return_types: Vec::with_capacity(1),
                         arguments: Vec::with_capacity(definition.parameters.len()),
                         monomorphs: Vec::new(),
                     })
+                )
+            }
         };
         self.breadcrumbs.push(ResolveBreadcrumb{
             root_id,
             definition_id,
             next_member: 0,
             next_embedded: 0,
             progression
         });
+    }
     //--------------------------------------------------------------------------
     // 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;
+            }
+        }
+    }
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)