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

Changeset - 6ec2e0261a03

Parent rev.

Child rev.

[Not reviewed]

0 14 0

MH - 4 years ago 2021-03-22 18:24:54
contact@maxhenger.nl

debugging type inference

14 files changed with 629 insertions and 142 deletions:

src/protocol/arena.rs

src/protocol/ast.rs

src/protocol/ast_printer.rs

119

src/protocol/eval.rs

src/protocol/inputsource.rs

src/protocol/lexer.rs

src/protocol/mod.rs

src/protocol/parser/mod.rs

src/protocol/parser/type_resolver.rs

354

src/protocol/parser/type_table.rs

src/protocol/parser/visitor_linker.rs

src/runtime/communication.rs

src/runtime/mod.rs

src/runtime/tests.rs

0 comments (0 inline, 0 general)

src/protocol/arena.rs

➞

Show inline comments

 use crate::common::*;
 use core::hash::Hash;
 use core::marker::PhantomData;
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct Id<T> {
     pub(crate) index: u32,
     _phantom: PhantomData<T>,
+}
 impl<T> Id<T> {
     pub(crate) fn new(index: u32) -> Self {
         Self{ index, _phantom: Default::default() }
+    }
+}
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 pub(crate) struct Arena<T> {
     store: Vec<T>,
+}
 //////////////////////////////////
 impl<T> Debug for Id<T> {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         f.debug_struct("Id").field("index", &self.index).finish()
+    }
+}
 impl<T> Clone for Id<T> {
     fn clone(&self) -> Self {
         *self
+    }
+}
 impl<T> Copy for Id<T> {}
 impl<T> PartialEq for Id<T> {
     fn eq(&self, other: &Self) -> bool {
         self.index.eq(&other.index)
+    }
+}
 impl<T> Eq for Id<T> {}
 impl<T> Hash for Id<T> {
     fn hash<H: std::hash::Hasher>(&self, h: &mut H) {
         self.index.hash(h);
+    }
+}
 impl<T> Arena<T> {
     pub fn new() -> Self {
         Self { store: vec![] }
+    }
     pub fn alloc_with_id(&mut self, f: impl FnOnce(Id<T>) -> T) -> Id<T> {
         use std::convert::TryFrom;
         let id = Id {
             index: u32::try_from(self.store.len()).expect("Out of capacity!"),
             _phantom: Default::default(),
         };
         let id = Id::new(u32::try_from(self.store.len()).expect("Out of capacity!"));
         self.store.push(f(id));
         id
+    }
     pub fn iter(&self) -> impl Iterator<Item = &T> {
         self.store.iter()
+    }
     pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
         self.store.iter_mut()
+    }
     pub fn len(&self) -> usize {
         self.store.len()
+    }
+}
 impl<T> core::ops::Index<Id<T>> for Arena<T> {
     type Output = T;
     fn index(&self, id: Id<T>) -> &Self::Output {
         self.store.index(id.index as usize)
+    }
+}
 impl<T> core::ops::IndexMut<Id<T>> for Arena<T> {
     fn index_mut(&mut self, id: Id<T>) -> &mut Self::Output {
         self.store.index_mut(id.index as usize)
+    }
+}
@@ \ No newline at end of file @@

src/protocol/ast.rs

➞

Show inline comments

 // TODO: @cleanup, rigorous cleanup of dead code and silly object-oriented
 //  trait impls where I deem them unfit.
 use std::fmt;
 use std::fmt::{Debug, Display, Formatter};
 use std::ops::{Index, IndexMut};
 use super::arena::{Arena, Id};
 // use super::containers::StringAllocator;
 // TODO: @cleanup, transform wrapping types into type aliases where possible
 use crate::protocol::inputsource::*;
 /// Helper macro that defines a type alias for a AST element ID. In this case
 /// only used to alias the `Id<T>` types.
 macro_rules! define_aliased_ast_id {
     // Variant where we just defined the alias, without any indexing
     ($name:ident, $parent:ty) => {
         pub type $name = $parent;
     };
     // Variant where we define the type, and the Index and IndexMut traits
     ($name:ident, $parent:ty, $indexed_type:ty, $indexed_arena:ident) => {
         define_aliased_ast_id!($name, $parent);
         impl Index<$name> for Heap {
             type Output = $indexed_type;
             fn index(&self, index: $name) -> &Self::Output {
                 &self.$indexed_arena[index]
+            }
+        }
         impl IndexMut<$name> for Heap {
             fn index_mut(&mut self, index: $name) -> &mut Self::Output {
                 &mut self.$indexed_arena[index]
+            }
+        }
+    }
+}
 /// Helper macro that defines a wrapper type for a particular variant of an AST
 /// element ID. Only used to define single-wrapping IDs.
 macro_rules! define_new_ast_id {
     // Variant where we just defined the new type, without any indexing
     ($name:ident, $parent:ty) => {
         #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
         pub struct $name (pub(crate) $parent);
         impl $name {
             pub fn upcast(self) -> $parent {
                 self.0
+            }
+        }
     };
     // Variant where we define the type, and the Index and IndexMut traits
     ($name:ident, $parent:ty, $indexed_type:ty, $wrapper_type:path, $indexed_arena:ident) => {
         define_new_ast_id!($name, $parent);
         impl Index<$name> for Heap {
             type Output = $indexed_type;
             fn index(&self, index: $name) -> &Self::Output {
                 if let $wrapper_type(v) = &self.$indexed_arena[index.0] {
+                    v
                 } else {
                     unreachable!()
+                }
+            }
+        }
         impl IndexMut<$name> for Heap {
             fn index_mut(&mut self, index: $name) -> &mut Self::Output {
                 if let $wrapper_type(v) = &mut self.$indexed_arena[index.0] {
+                    v
                 } else {
                     unreachable!()
+                }
+            }
+        }
+    }
+}
 define_aliased_ast_id!(RootId, Id<Root>, Root, protocol_descriptions);
 define_aliased_ast_id!(PragmaId, Id<Pragma>, Pragma, pragmas);
 define_aliased_ast_id!(ImportId, Id<Import>, Import, imports);
 define_aliased_ast_id!(ParserTypeId, Id<ParserType>, ParserType, parser_types);
 define_aliased_ast_id!(VariableId, Id<Variable>, Variable, variables);
 define_new_ast_id!(ParameterId, VariableId, Parameter, Variable::Parameter, variables);
 define_new_ast_id!(LocalId, VariableId, Local, Variable::Local, variables);
 define_aliased_ast_id!(DefinitionId, Id<Definition>, Definition, definitions);
 define_new_ast_id!(StructId, DefinitionId, StructDefinition, Definition::Struct, definitions);
 define_new_ast_id!(EnumId, DefinitionId, EnumDefinition, Definition::Enum, definitions);
 define_new_ast_id!(ComponentId, DefinitionId, Component, Definition::Component, definitions);
 define_new_ast_id!(FunctionId, DefinitionId, Function, Definition::Function, definitions);
 define_aliased_ast_id!(StatementId, Id<Statement>, Statement, statements);
 define_new_ast_id!(BlockStatementId, StatementId, BlockStatement, Statement::Block, statements);
 define_new_ast_id!(LocalStatementId, StatementId, LocalStatement, Statement::Local, statements);
 define_new_ast_id!(MemoryStatementId, LocalStatementId);
 define_new_ast_id!(ChannelStatementId, LocalStatementId);
 define_new_ast_id!(SkipStatementId, StatementId, SkipStatement, Statement::Skip, statements);
 define_new_ast_id!(LabeledStatementId, StatementId, LabeledStatement, Statement::Labeled, statements);
 define_new_ast_id!(IfStatementId, StatementId, IfStatement, Statement::If, statements);
 define_new_ast_id!(EndIfStatementId, StatementId, EndIfStatement, Statement::EndIf, statements);
 define_new_ast_id!(WhileStatementId, StatementId, WhileStatement, Statement::While, statements);
 define_new_ast_id!(EndWhileStatementId, StatementId, EndWhileStatement, Statement::EndWhile, statements);
 define_new_ast_id!(BreakStatementId, StatementId, BreakStatement, Statement::Break, statements);
 define_new_ast_id!(ContinueStatementId, StatementId, ContinueStatement, Statement::Continue, statements);
 define_new_ast_id!(SynchronousStatementId, StatementId, SynchronousStatement, Statement::Synchronous, statements);
 define_new_ast_id!(EndSynchronousStatementId, StatementId, EndSynchronousStatement, Statement::EndSynchronous, statements);
 define_new_ast_id!(ReturnStatementId, StatementId, ReturnStatement, Statement::Return, statements);
 define_new_ast_id!(AssertStatementId, StatementId, AssertStatement, Statement::Assert, statements);
 define_new_ast_id!(GotoStatementId, StatementId, GotoStatement, Statement::Goto, statements);
 define_new_ast_id!(NewStatementId, StatementId, NewStatement, Statement::New, statements);
 define_new_ast_id!(ExpressionStatementId, StatementId, ExpressionStatement, Statement::Expression, statements);
 define_aliased_ast_id!(ExpressionId, Id<Expression>, Expression, expressions);
 define_new_ast_id!(AssignmentExpressionId, ExpressionId, AssignmentExpression, Expression::Assignment, expressions);
 define_new_ast_id!(ConditionalExpressionId, ExpressionId, ConditionalExpression, Expression::Conditional, expressions);
 define_new_ast_id!(BinaryExpressionId, ExpressionId, BinaryExpression, Expression::Binary, expressions);
 define_new_ast_id!(UnaryExpressionId, ExpressionId, UnaryExpression, Expression::Unary, expressions);
 define_new_ast_id!(IndexingExpressionId, ExpressionId, IndexingExpression, Expression::Indexing, expressions);
 define_new_ast_id!(SlicingExpressionId, ExpressionId, SlicingExpression, Expression::Slicing, expressions);
 define_new_ast_id!(SelectExpressionId, ExpressionId, SelectExpression, Expression::Select, expressions);
 define_new_ast_id!(ArrayExpressionId, ExpressionId, ArrayExpression, Expression::Array, expressions);
 define_new_ast_id!(ConstantExpressionId, ExpressionId, ConstantExpression, Expression::Constant, expressions);
 define_new_ast_id!(CallExpressionId, ExpressionId, CallExpression, Expression::Call, expressions);
 define_new_ast_id!(VariableExpressionId, ExpressionId, VariableExpression, Expression::Variable, expressions);
 // TODO: @cleanup - pub qualifiers can be removed once done
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 pub struct Heap {
     // Root arena, contains the entry point for different modules. Each root
     // contains lists of IDs that correspond to the other arenas.
     pub(crate) protocol_descriptions: Arena<Root>,
     // Contents of a file, these are the elements the `Root` elements refer to
     pragmas: Arena<Pragma>,
     pub(crate) imports: Arena<Import>,
     identifiers: Arena<Identifier>,
     pub(crate) parser_types: Arena<ParserType>,
     pub(crate) variables: Arena<Variable>,
     pub(crate) definitions: Arena<Definition>,
     pub(crate) statements: Arena<Statement>,
     pub(crate) expressions: Arena<Expression>,
+}
 impl Heap {
     pub fn new() -> Heap {
         Heap {
             // string_alloc: StringAllocator::new(),
             protocol_descriptions: Arena::new(),
             pragmas: Arena::new(),
             imports: Arena::new(),
             identifiers: Arena::new(),
             parser_types: Arena::new(),
             variables: Arena::new(),
             definitions: Arena::new(),
             statements: Arena::new(),
             expressions: Arena::new(),
+        }
+    }
     pub fn alloc_parser_type(
         &mut self,
         f: impl FnOnce(ParserTypeId) -> ParserType,
     ) -> ParserTypeId {
         self.parser_types.alloc_with_id(|id| f(id))
+    }
     pub fn alloc_parameter(&mut self, f: impl FnOnce(ParameterId) -> Parameter) -> ParameterId {
         ParameterId(
             self.variables.alloc_with_id(|id| Variable::Parameter(f(ParameterId(id)))),
+        )
+    }
     pub fn alloc_local(&mut self, f: impl FnOnce(LocalId) -> Local) -> LocalId {
         LocalId(
             self.variables.alloc_with_id(|id| Variable::Local(f(LocalId(id)))),
+        )
+    }
     pub fn alloc_assignment_expression(
         &mut self,
         f: impl FnOnce(AssignmentExpressionId) -> AssignmentExpression,
     ) -> AssignmentExpressionId {
         AssignmentExpressionId(
             self.expressions.alloc_with_id(|id| {
                 Expression::Assignment(f(AssignmentExpressionId(id)))
             })
+        )
+    }
     pub fn alloc_conditional_expression(
         &mut self,
         f: impl FnOnce(ConditionalExpressionId) -> ConditionalExpression,
     ) -> ConditionalExpressionId {
         ConditionalExpressionId(
             self.expressions.alloc_with_id(|id| {
                 Expression::Conditional(f(ConditionalExpressionId(id)))
             })
+        )
+    }
     pub fn alloc_binary_expression(
         &mut self,
         f: impl FnOnce(BinaryExpressionId) -> BinaryExpression,
     ) -> BinaryExpressionId {
         BinaryExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Binary(f(BinaryExpressionId(id)))),
+        )
+    }
     pub fn alloc_unary_expression(
         &mut self,
         f: impl FnOnce(UnaryExpressionId) -> UnaryExpression,
     ) -> UnaryExpressionId {
         UnaryExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Unary(f(UnaryExpressionId(id)))),
+        )
+    }
     pub fn alloc_slicing_expression(
         &mut self,
         f: impl FnOnce(SlicingExpressionId) -> SlicingExpression,
     ) -> SlicingExpressionId {
         SlicingExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Slicing(f(SlicingExpressionId(id)))),
+        )
+    }
     pub fn alloc_indexing_expression(
         &mut self,
         f: impl FnOnce(IndexingExpressionId) -> IndexingExpression,
     ) -> IndexingExpressionId {
         IndexingExpressionId(
             self.expressions.alloc_with_id(|id| {
                 Expression::Indexing(f(IndexingExpressionId(id)))
             }),
+        )
+    }
     pub fn alloc_select_expression(
         &mut self,
         f: impl FnOnce(SelectExpressionId) -> SelectExpression,
     ) -> SelectExpressionId {
         SelectExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Select(f(SelectExpressionId(id)))),
+        )
+    }
     pub fn alloc_array_expression(
         &mut self,
         f: impl FnOnce(ArrayExpressionId) -> ArrayExpression,
     ) -> ArrayExpressionId {
         ArrayExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Array(f(ArrayExpressionId(id)))),
+        )
+    }
     pub fn alloc_constant_expression(
         &mut self,
         f: impl FnOnce(ConstantExpressionId) -> ConstantExpression,
     ) -> ConstantExpressionId {
         ConstantExpressionId(
             self.expressions.alloc_with_id(|id| {
                 Expression::Constant(f(ConstantExpressionId(id)))
             }),
+        )
+    }
     pub fn alloc_call_expression(
         &mut self,
         f: impl FnOnce(CallExpressionId) -> CallExpression,
     ) -> CallExpressionId {
         CallExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Call(f(CallExpressionId(id)))),
+        )
+    }
     pub fn alloc_variable_expression(
         &mut self,
         f: impl FnOnce(VariableExpressionId) -> VariableExpression,
     ) -> VariableExpressionId {
         VariableExpressionId(
             self.expressions.alloc_with_id(|id| {
                 Expression::Variable(f(VariableExpressionId(id)))
             }),
+        )
+    }
     pub fn alloc_block_statement(
         &mut self,
         f: impl FnOnce(BlockStatementId) -> BlockStatement,
     ) -> BlockStatementId {
         BlockStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Block(f(BlockStatementId(id)))),
+        )
+    }
     pub fn alloc_memory_statement(
         &mut self,
         f: impl FnOnce(MemoryStatementId) -> MemoryStatement,
     ) -> MemoryStatementId {
         MemoryStatementId(LocalStatementId(self.statements.alloc_with_id(|id| {
             Statement::Local(LocalStatement::Memory(
                 f(MemoryStatementId(LocalStatementId(id)))
             ))
         })))
+    }
     pub fn alloc_channel_statement(
         &mut self,
         f: impl FnOnce(ChannelStatementId) -> ChannelStatement,
     ) -> ChannelStatementId {
         ChannelStatementId(LocalStatementId(self.statements.alloc_with_id(|id| {
             Statement::Local(LocalStatement::Channel(
                 f(ChannelStatementId(LocalStatementId(id)))
             ))
         })))
+    }
     pub fn alloc_skip_statement(
         &mut self,
         f: impl FnOnce(SkipStatementId) -> SkipStatement,
     ) -> SkipStatementId {
         SkipStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Skip(f(SkipStatementId(id)))),
+        )
+    }
     pub fn alloc_if_statement(
         &mut self,
         f: impl FnOnce(IfStatementId) -> IfStatement,
     ) -> IfStatementId {
         IfStatementId(
             self.statements.alloc_with_id(|id| Statement::If(f(IfStatementId(id)))),
+        )
+    }
     pub fn alloc_end_if_statement(
         &mut self,
         f: impl FnOnce(EndIfStatementId) -> EndIfStatement,
     ) -> EndIfStatementId {
         EndIfStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::EndIf(f(EndIfStatementId(id)))),
+        )
+    }
     pub fn alloc_while_statement(
         &mut self,
         f: impl FnOnce(WhileStatementId) -> WhileStatement,
     ) -> WhileStatementId {
         WhileStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::While(f(WhileStatementId(id)))),
+        )
+    }
     pub fn alloc_end_while_statement(
         &mut self,
         f: impl FnOnce(EndWhileStatementId) -> EndWhileStatement,
     ) -> EndWhileStatementId {
         EndWhileStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::EndWhile(f(EndWhileStatementId(id)))),
+        )
+    }
     pub fn alloc_break_statement(
         &mut self,
         f: impl FnOnce(BreakStatementId) -> BreakStatement,
     ) -> BreakStatementId {
         BreakStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Break(f(BreakStatementId(id)))),
+        )
+    }
     pub fn alloc_continue_statement(
         &mut self,
         f: impl FnOnce(ContinueStatementId) -> ContinueStatement,
     ) -> ContinueStatementId {
         ContinueStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Continue(f(ContinueStatementId(id)))),
+        )
+    }
     pub fn alloc_synchronous_statement(
         &mut self,
         f: impl FnOnce(SynchronousStatementId) -> SynchronousStatement,
     ) -> SynchronousStatementId {
         SynchronousStatementId(self.statements.alloc_with_id(|id| {
             Statement::Synchronous(f(SynchronousStatementId(id)))
         }))
+    }
     pub fn alloc_end_synchronous_statement(
         &mut self,
         f: impl FnOnce(EndSynchronousStatementId) -> EndSynchronousStatement,
     ) -> EndSynchronousStatementId {
         EndSynchronousStatementId(self.statements.alloc_with_id(|id| {
             Statement::EndSynchronous(f(EndSynchronousStatementId(id)))
         }))
+    }
     pub fn alloc_return_statement(
         &mut self,
         f: impl FnOnce(ReturnStatementId) -> ReturnStatement,
     ) -> ReturnStatementId {
         ReturnStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Return(f(ReturnStatementId(id)))),
+        )
+    }
     pub fn alloc_assert_statement(
         &mut self,
         f: impl FnOnce(AssertStatementId) -> AssertStatement,
     ) -> AssertStatementId {
         AssertStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Assert(f(AssertStatementId(id)))),
+        )
+    }
     pub fn alloc_goto_statement(
         &mut self,
         f: impl FnOnce(GotoStatementId) -> GotoStatement,
     ) -> GotoStatementId {
         GotoStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Goto(f(GotoStatementId(id)))),
+        )
+    }
     pub fn alloc_new_statement(
         &mut self,
         f: impl FnOnce(NewStatementId) -> NewStatement,
     ) -> NewStatementId {
         NewStatementId(
             self.statements.alloc_with_id(|id| Statement::New(f(NewStatementId(id)))),
+        )
+    }
     pub fn alloc_labeled_statement(
         &mut self,
         f: impl FnOnce(LabeledStatementId) -> LabeledStatement,
     ) -> LabeledStatementId {
         LabeledStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Labeled(f(LabeledStatementId(id)))),
+        )
+    }
     pub fn alloc_expression_statement(
         &mut self,
         f: impl FnOnce(ExpressionStatementId) -> ExpressionStatement,
     ) -> ExpressionStatementId {
         ExpressionStatementId(
             self.statements.alloc_with_id(|id| {
                 Statement::Expression(f(ExpressionStatementId(id)))
             }),
+        )
+    }
     pub fn alloc_struct_definition(&mut self, f: impl FnOnce(StructId) -> StructDefinition) -> StructId {
         StructId(self.definitions.alloc_with_id(|id| {
             Definition::Struct(f(StructId(id)))
         }))
+    }
     pub fn alloc_enum_definition(&mut self, f: impl FnOnce(EnumId) -> EnumDefinition) -> EnumId {
         EnumId(self.definitions.alloc_with_id(|id| {
             Definition::Enum(f(EnumId(id)))
         }))
+    }
     pub fn alloc_component(&mut self, f: impl FnOnce(ComponentId) -> Component) -> ComponentId {
         ComponentId(self.definitions.alloc_with_id(|id| {
             Definition::Component(f(ComponentId(id)))
         }))
+    }
     pub fn alloc_function(&mut self, f: impl FnOnce(FunctionId) -> Function) -> FunctionId {
         FunctionId(
             self.definitions
                 .alloc_with_id(|id| Definition::Function(f(FunctionId(id)))),
+        )
+    }
     pub fn alloc_pragma(&mut self, f: impl FnOnce(PragmaId) -> Pragma) -> PragmaId {
         self.pragmas.alloc_with_id(|id| f(id))
+    }
     pub fn alloc_import(&mut self, f: impl FnOnce(ImportId) -> Import) -> ImportId {
         self.imports.alloc_with_id(|id| f(id))
+    }
     pub fn alloc_protocol_description(&mut self, f: impl FnOnce(RootId) -> Root) -> RootId {
         self.protocol_descriptions.alloc_with_id(|id| f(id))
+    }
+}
 impl Index<MemoryStatementId> for Heap {
     type Output = MemoryStatement;
     fn index(&self, index: MemoryStatementId) -> &Self::Output {
         &self.statements[index.0.0].as_memory()
+    }
+}
 impl Index<ChannelStatementId> for Heap {
     type Output = ChannelStatement;
     fn index(&self, index: ChannelStatementId) -> &Self::Output {
         &self.statements[index.0.0].as_channel()
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Root {
     pub this: RootId,
     // Phase 1: parser
     pub position: InputPosition,
     pub pragmas: Vec<PragmaId>,
     pub imports: Vec<ImportId>,
     pub definitions: Vec<DefinitionId>,
+}
 impl Root {
     pub fn get_definition_ident(&self, h: &Heap, id: &[u8]) -> Option<DefinitionId> {
         for &def in self.definitions.iter() {
             if h[def].identifier().value == id {
                 return Some(def);
+            }
+        }
         None
+    }
+}
 impl SyntaxElement for Root {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Pragma {
     Version(PragmaVersion),
     Module(PragmaModule)
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PragmaVersion {
     pub this: PragmaId,
     // Phase 1: parser
     pub position: InputPosition,
     pub version: u64,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PragmaModule {
     pub this: PragmaId,
     // Phase 1: parser
     pub position: InputPosition,
     pub value: Vec<u8>,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PragmaOld {
     pub this: PragmaId,
     // Phase 1: parser
     pub position: InputPosition,
     pub value: Vec<u8>,
+}
 impl SyntaxElement for PragmaOld {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Import {
     Module(ImportModule),
     Symbols(ImportSymbols)
+}
 impl Import {
     pub(crate) fn as_module(&self) -> &ImportModule {
         match self {
             Import::Module(m) => m,
             _ => panic!("Unable to cast 'Import' to 'ImportModule'")
+        }
+    }
     pub(crate) fn as_symbols(&self) -> &ImportSymbols {
         match self {
             Import::Symbols(m) => m,
             _ => panic!("Unable to cast 'Import' to 'ImportSymbols'")
+        }
+    }
+}
 impl SyntaxElement for Import {
     fn position(&self) -> InputPosition {
         match self {
             Import::Module(m) => m.position,
             Import::Symbols(m) => m.position
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ImportModule {
     pub this: ImportId,
     // Phase 1: parser
     pub position: InputPosition,
     pub module_name: Vec<u8>,
     pub alias: Vec<u8>,
     // Phase 2: module resolving
     pub module_id: Option<RootId>,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct AliasedSymbol {
     // Phase 1: parser
     pub position: InputPosition,
     pub name: Vec<u8>,
     pub alias: Vec<u8>,
     // Phase 2: symbol resolving
     pub definition_id: Option<DefinitionId>,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ImportSymbols {
     pub this: ImportId,
     // Phase 1: parser
     pub position: InputPosition,
     pub module_name: Vec<u8>,
     // Phase 2: module resolving
     pub module_id: Option<RootId>,
     // Phase 1&2
     // if symbols is empty, then we implicitly import all symbols without any
     // aliases for them. If it is not empty, then symbols are explicitly
     // specified, and optionally given an alias.
     pub symbols: Vec<AliasedSymbol>,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Identifier {
     pub position: InputPosition,
     pub value: Vec<u8>
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct NamespacedIdentifier {
     pub position: InputPosition,
     pub num_namespaces: u8,
     pub value: Vec<u8>,
+}
 impl NamespacedIdentifier {
     pub(crate) fn iter(&self) -> NamespacedIdentifierIter {
         NamespacedIdentifierIter{
             value: &self.value,
             cur_offset: 0,
             num_returned: 0,
             num_total: self.num_namespaces
+        }
+    }
+}
 impl PartialEq for NamespacedIdentifier {
     fn eq(&self, other: &Self) -> bool {
         return self.value == other.value
+    }
+}
 impl Eq for NamespacedIdentifier{}
 // TODO: Just keep ref to NamespacedIdentifier
 pub(crate) struct NamespacedIdentifierIter<'a> {
     value: &'a Vec<u8>,
     cur_offset: usize,
     num_returned: u8,
     num_total: u8,
+}
 impl<'a> NamespacedIdentifierIter<'a> {
     pub(crate) fn num_returned(&self) -> u8 {
         return self.num_returned;
+    }
     pub(crate) fn num_remaining(&self) -> u8 {
         return self.num_total - self.num_returned
+    }
     pub(crate) fn returned_section(&self) -> &[u8] {
         // Offset always includes the two trailing ':' characters
         let end = if self.cur_offset >= 2 { self.cur_offset - 2 } else { self.cur_offset };
         return &self.value[..end]
+    }
+}
 impl<'a> Iterator for NamespacedIdentifierIter<'a> {
     type Item = &'a [u8];
     fn next(&mut self) -> Option<Self::Item> {
         if self.cur_offset >= self.value.len() {
             debug_assert_eq!(self.num_returned, self.num_total);
             None
         } else {
             debug_assert!(self.num_returned < self.num_total);
             let start = self.cur_offset;
             let mut end = start;
             while end < self.value.len() - 1 {
                 if self.value[end] == b':' && self.value[end + 1] == b':' {
                     self.cur_offset = end + 2;
                     self.num_returned += 1;
                     return Some(&self.value[start..end]);
+                }
                 end += 1;
+            }
             // If NamespacedIdentifier is constructed properly, then we cannot
             // end with "::" in the value, so
             debug_assert!(end == 0 || (self.value[end - 1] != b':' && self.value[end] != b':'));
             debug_assert_eq!(self.num_returned + 1, self.num_total);
             self.cur_offset = self.value.len();
             self.num_returned += 1;
             return Some(&self.value[start..]);
+        }
+    }
+}
 impl Display for Identifier {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         // A source identifier is in ASCII range.
         write!(f, "{}", String::from_utf8_lossy(&self.value))
+    }
+}
 /// TODO: @cleanup Maybe handle this differently, preallocate in heap? The
 ///     reason I'm handling it like this now is so we don't allocate types in
 ///     the `Arena` structure if they're the common types defined here.
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum ParserTypeVariant {
     // Basic builtin
     Message,
     Bool,
     Byte,
     Short,
     Int,
     Long,
     String,
     // Literals (need to get concrete builtin type during typechecking)
     IntegerLiteral,
     Inferred,
     // Complex builtins
     Array(ParserTypeId), // array of a type
     Input(ParserTypeId), // typed input endpoint of a channel
     Output(ParserTypeId), // typed output endpoint of a channel
     Symbolic(SymbolicParserType), // symbolic type (definition or polyarg)
+}
 impl ParserTypeVariant {
     pub(crate) fn supports_polymorphic_args(&self) -> bool {
         use ParserTypeVariant::*;
         match self {
             Message | Bool | Byte | Short | Int | Long | String | IntegerLiteral | Inferred => false,
             _ => true
+        }
+    }
+}
 /// ParserType is a specification of a type during the parsing phase and initial
 /// linker/validator phase of the compilation process. These types may be
 /// (partially) inferred or represent literals (e.g. a integer whose bytesize is
 /// not yet determined).
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ParserType {
     pub this: ParserTypeId,
     pub pos: InputPosition,
     pub variant: ParserTypeVariant,
+}
 /// SymbolicParserType is the specification of a symbolic type. During the
 /// parsing phase we will only store the identifier of the type. During the
 /// validation phase we will determine whether it refers to a user-defined type,
 /// or a polymorphic argument. After the validation phase it may still be the
 /// case that the resulting `variant` will not pass the typechecker.
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct SymbolicParserType {
     // Phase 1: parser
     pub identifier: NamespacedIdentifier,
     /// The user-specified polymorphic arguments. Zero-length implies that the
     /// user did not specify any of them, and they're either not needed or all
     /// need to be inferred. Otherwise the number of polymorphic arguments must
     /// match those of the corresponding definition
     pub poly_args: Vec<ParserTypeId>,
     // Phase 2: validation/linking (for types in function/component bodies) and
     //  type table construction (for embedded types of structs/unions)
     pub variant: Option<SymbolicParserTypeVariant>
+}
 /// Specifies whether the symbolic type points to an actual user-defined type,
 /// or whether it points to a polymorphic argument within the definition (e.g.
 /// a defined variable `T var` within a function `int func<T>()`
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum SymbolicParserTypeVariant {
     Definition(DefinitionId),
     // TODO: figure out if I need the DefinitionId here
     PolyArg(DefinitionId, usize), // index of polyarg in the definition
+}
 /// ConcreteType is the representation of a type after resolving symbolic types
 /// and performing type inference
 #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 pub enum ConcreteTypePart {
     // Special types (cannot be explicitly constructed by the programmer)
     Void,
     // Builtin types without nested types
     Message,
     Bool,
     Byte,
     Short,
     Int,
     Long,
     String,
     // Builtin types with one nested type
     Array,
     Slice,
     Input,
     Output,
     // User defined type with any number of nested types
     Instance(DefinitionId, usize),
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ConcreteType {
     pub(crate) parts: Vec<ConcreteTypePart>
+}
 impl Default for ConcreteType {
     fn default() -> Self {
         Self{ parts: Vec::new() }
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum PrimitiveType {
     Input,
     Output,
     Message,
     Boolean,
     Byte,
     Short,
     Int,
     Long,
     Symbolic(PrimitiveSymbolic)
+}
 // TODO: @cleanup, remove PartialEq implementations
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PrimitiveSymbolic {
     // Phase 1: parser
     pub(crate) identifier: NamespacedIdentifier,
     // Phase 2: typing
     pub(crate) definition: Option<DefinitionId>
+}
 impl PartialEq for PrimitiveSymbolic {
     fn eq(&self, other: &Self) -> bool {
         self.identifier == other.identifier
+    }
+}
 impl Eq for PrimitiveSymbolic{}
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct Type {
     pub primitive: PrimitiveType,
     pub array: bool,
+}
 #[allow(dead_code)]
 impl Type {
     pub const INPUT: Type = Type { primitive: PrimitiveType::Input, array: false };
     pub const OUTPUT: Type = Type { primitive: PrimitiveType::Output, array: false };
     pub const MESSAGE: Type = Type { primitive: PrimitiveType::Message, array: false };
     pub const BOOLEAN: Type = Type { primitive: PrimitiveType::Boolean, array: false };
     pub const BYTE: Type = Type { primitive: PrimitiveType::Byte, array: false };
     pub const SHORT: Type = Type { primitive: PrimitiveType::Short, array: false };
     pub const INT: Type = Type { primitive: PrimitiveType::Int, array: false };
     pub const LONG: Type = Type { primitive: PrimitiveType::Long, array: false };
     pub const INPUT_ARRAY: Type = Type { primitive: PrimitiveType::Input, array: true };
     pub const OUTPUT_ARRAY: Type = Type { primitive: PrimitiveType::Output, array: true };
     pub const MESSAGE_ARRAY: Type = Type { primitive: PrimitiveType::Message, array: true };
     pub const BOOLEAN_ARRAY: Type = Type { primitive: PrimitiveType::Boolean, array: true };
     pub const BYTE_ARRAY: Type = Type { primitive: PrimitiveType::Byte, array: true };
     pub const SHORT_ARRAY: Type = Type { primitive: PrimitiveType::Short, array: true };
     pub const INT_ARRAY: Type = Type { primitive: PrimitiveType::Int, array: true };
     pub const LONG_ARRAY: Type = Type { primitive: PrimitiveType::Long, array: true };
+}
 impl Display for Type {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match &self.primitive {
             PrimitiveType::Input => {
                 write!(f, "in")?;
+            }
             PrimitiveType::Output => {
                 write!(f, "out")?;
+            }
             PrimitiveType::Message => {
                 write!(f, "msg")?;
+            }
             PrimitiveType::Boolean => {
                 write!(f, "boolean")?;
+            }
             PrimitiveType::Byte => {
                 write!(f, "byte")?;
+            }
             PrimitiveType::Short => {
                 write!(f, "short")?;
+            }
             PrimitiveType::Int => {
                 write!(f, "int")?;
+            }
             PrimitiveType::Long => {
                 write!(f, "long")?;
+            }
             PrimitiveType::Symbolic(data) => {
                 // Type data is in ASCII range.
                 if let Some(id) = &data.definition {
                     write!(
                         f, "Symbolic({}, id: {})",
                         String::from_utf8_lossy(&data.identifier.value),
                         id.index
                     )?;
                 } else {
                     write!(
                         f, "Symbolic({}, id: Unresolved)",
                         String::from_utf8_lossy(&data.identifier.value)
                     )?;
+                }
+            }
+        }
         if self.array {
             write!(f, "[]")
         } else {
             Ok(())
+        }
+    }
+}
 type CharacterData = Vec<u8>;
 type IntegerData = i64;
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Constant {
     Null, // message
     True,
     False,
     Character(CharacterData),
     Integer(IntegerData),
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Method {
     Get,
     Put,
     Fires,
     Create,
     Symbolic(MethodSymbolic)
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct MethodSymbolic {
     pub(crate) identifier: NamespacedIdentifier,
     pub(crate) definition: Option<DefinitionId>
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Field {
     Length,
     Symbolic(Identifier),
+}
 impl Field {
     pub fn is_length(&self) -> bool {
         match self {
             Field::Length => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 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")
+        }
+    }
+}
 pub trait VariableScope {
     fn parent_scope(&self, h: &Heap) -> Option<Scope>;
     fn get_variable(&self, h: &Heap, id: &Identifier) -> Option<VariableId>;
+}
 impl VariableScope for Scope {
     fn parent_scope(&self, h: &Heap) -> Option<Scope> {
         match self {
             Scope::Definition(def) => h[*def].parent_scope(h),
             Scope::Regular(stmt) => h[*stmt].parent_scope(h),
             Scope::Synchronous((stmt, _)) => h[*stmt].parent_scope(h),
+        }
+    }
     fn get_variable(&self, h: &Heap, id: &Identifier) -> Option<VariableId> {
         match self {
             Scope::Definition(def) => h[*def].get_variable(h, id),
             Scope::Regular(stmt) => h[*stmt].get_variable(h, id),
             Scope::Synchronous((stmt, _)) => h[*stmt].get_variable(h, id),
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Variable {
     Parameter(Parameter),
     Local(Local),
+}
 impl Variable {
     pub fn identifier(&self) -> &Identifier {
         match self {
             Variable::Parameter(var) => &var.identifier,
             Variable::Local(var) => &var.identifier,
+        }
+    }
     pub fn is_parameter(&self) -> bool {
         match self {
             Variable::Parameter(_) => true,
             _ => false,
+        }
+    }
     pub fn as_parameter(&self) -> &Parameter {
         match self {
             Variable::Parameter(result) => result,
             _ => panic!("Unable to cast `Variable` to `Parameter`"),
+        }
+    }
     pub fn as_local(&self) -> &Local {
         match self {
             Variable::Local(result) => result,
             _ => panic!("Unable to cast `Variable` to `Local`"),
+        }
+    }
     pub fn as_local_mut(&mut self) -> &mut Local {
         match self {
             Variable::Local(result) => result,
             _ => panic!("Unable to cast 'Variable' to 'Local'"),
+        }
+    }
+}
 impl SyntaxElement for Variable {
     fn position(&self) -> InputPosition {
         match self {
             Variable::Parameter(decl) => decl.position(),
             Variable::Local(decl) => decl.position(),
+        }
+    }
+}
 /// TODO: Remove distinction between parameter/local and add an enum to indicate
 ///     the distinction between the two
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Parameter {
     pub this: ParameterId,
     // Phase 1: parser
     pub position: InputPosition,
     pub parser_type: ParserTypeId,
     pub identifier: Identifier,
+}
 impl SyntaxElement for Parameter {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Local {
     pub this: LocalId,
     // Phase 1: parser
     pub position: InputPosition,
     pub parser_type: ParserTypeId,
     pub identifier: Identifier,
     // Phase 2: linker
     pub relative_pos_in_block: u32,
+}
 impl SyntaxElement for Local {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Definition {
     Struct(StructDefinition),
     Enum(EnumDefinition),
     Component(Component),
     Function(Function),
+}
 impl Definition {
     pub fn is_struct(&self) -> bool {
         match self {
             Definition::Struct(_) => true,
             _ => false
+        }
+    }
     pub fn as_struct(&self) -> &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 fn as_enum(&self) -> &EnumDefinition {
         match self {
             Definition::Enum(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'EnumDefinition'"),
+        }
+    }
     pub fn is_component(&self) -> bool {
         match self {
             Definition::Component(_) => true,
             _ => false,
+        }
+    }
     pub fn as_component(&self) -> &Component {
         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 fn as_function(&self) -> &Function {
         match self {
             Definition::Function(result) => result,
             _ => panic!("Unable to cast `Definition` to `Function`"),
+        }
+    }
     pub fn identifier(&self) -> &Identifier {
         match self {
             Definition::Struct(def) => &def.identifier,
             Definition::Enum(def) => &def.identifier,
             Definition::Component(com) => &com.identifier,
             Definition::Function(fun) => &fun.identifier,
+        }
+    }
     pub fn parameters(&self) -> &Vec<ParameterId> {
         // TODO: Fix this
         static EMPTY_VEC: Vec<ParameterId> = Vec::new();
         match self {
             Definition::Component(com) => &com.parameters,
             Definition::Function(fun) => &fun.parameters,
             _ => &EMPTY_VEC,
+        }
+    }
     pub fn body(&self) -> StatementId {
         // TODO: Fix this
         match self {
             Definition::Component(com) => com.body,
             Definition::Function(fun) => fun.body,
             _ => panic!("cannot retrieve body (for EnumDefinition or StructDefinition)")
+        }
+    }
+}
 impl SyntaxElement for Definition {
     fn position(&self) -> InputPosition {
         match self {
             Definition::Struct(def) => def.position,
             Definition::Enum(def) => def.position,
             Definition::Component(def) => def.position(),
             Definition::Function(def) => def.position(),
+        }
+    }
+}
 impl VariableScope for Definition {
     fn parent_scope(&self, _h: &Heap) -> Option<Scope> {
         None
+    }
     fn get_variable(&self, h: &Heap, id: &Identifier) -> Option<VariableId> {
         for &parameter_id in self.parameters().iter() {
             let parameter = &h[parameter_id];
             if parameter.identifier.value == id.value {
                 return Some(parameter_id.0);
+            }
+        }
         None
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct StructFieldDefinition {
     pub position: InputPosition,
     pub field: Identifier,
     pub parser_type: ParserTypeId,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct StructDefinition {
     pub this: StructId,
     // Phase 1: parser
     pub position: InputPosition,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     pub fields: Vec<StructFieldDefinition>
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq)]
 pub enum EnumVariantValue {
     None,
     Integer(i64),
     Type(ParserTypeId),
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct EnumVariantDefinition {
     pub position: InputPosition,
     pub identifier: Identifier,
     pub value: EnumVariantValue,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct EnumDefinition {
     pub this: EnumId,
     // Phase 1: parser
     pub position: InputPosition,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     pub variants: Vec<EnumVariantDefinition>,
+}
 #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 pub enum ComponentVariant {
     Primitive,
     Composite,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Component {
     pub this: ComponentId,
     // Phase 1: parser
     pub position: InputPosition,
     pub variant: ComponentVariant,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     pub parameters: Vec<ParameterId>,
     pub body: StatementId,
+}
 impl SyntaxElement for Component {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Function {
     pub this: FunctionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub return_type: ParserTypeId,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     pub parameters: Vec<ParameterId>,
     pub body: StatementId,
+}
 impl SyntaxElement for Function {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Statement {
     Block(BlockStatement),
     Local(LocalStatement),
     Skip(SkipStatement),
     Labeled(LabeledStatement),
     If(IfStatement),
     EndIf(EndIfStatement),
     While(WhileStatement),
     EndWhile(EndWhileStatement),
     Break(BreakStatement),
     Continue(ContinueStatement),
     Synchronous(SynchronousStatement),
     EndSynchronous(EndSynchronousStatement),
     Return(ReturnStatement),
     Assert(AssertStatement),
     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_block_mut(&mut self) -> &mut 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_skip(&self) -> &SkipStatement {
         match self {
             Statement::Skip(result) => result,
             _ => panic!("Unable to cast `Statement` to `SkipStatement`"),
+        }
+    }
     pub fn as_labeled(&self) -> &LabeledStatement {
         match self {
             Statement::Labeled(result) => result,
             _ => panic!("Unable to cast `Statement` to `LabeledStatement`"),
+        }
+    }
     pub fn as_labeled_mut(&mut self) -> &mut LabeledStatement {
         match self {
             Statement::Labeled(result) => result,
             _ => panic!("Unable to cast `Statement` to `LabeledStatement`"),
+        }
+    }
     pub fn as_if(&self) -> &IfStatement {
         match self {
             Statement::If(result) => result,
             _ => panic!("Unable to cast `Statement` to `IfStatement`"),
+        }
+    }
     pub fn as_if_mut(&mut self) -> &mut IfStatement {
         match self {
             Statement::If(result) => result,
             _ => panic!("Unable to cast 'Statement' to 'IfStatement'"),
+        }
+    }
     pub fn as_end_if(&self) -> &EndIfStatement {
         match self {
             Statement::EndIf(result) => result,
             _ => panic!("Unable to cast `Statement` to `EndIfStatement`"),
+        }
+    }
     pub fn is_while(&self) -> bool {
         match self {
             Statement::While(_) => true,
             _ => false,
+        }
+    }
     pub fn as_while(&self) -> &WhileStatement {
         match self {
             Statement::While(result) => result,
             _ => panic!("Unable to cast `Statement` to `WhileStatement`"),
+        }
+    }
     pub fn as_while_mut(&mut self) -> &mut WhileStatement {
         match self {
             Statement::While(result) => result,
             _ => panic!("Unable to cast `Statement` to `WhileStatement`"),
+        }
+    }
     pub fn as_end_while(&self) -> &EndWhileStatement {
         match self {
             Statement::EndWhile(result) => result,
             _ => panic!("Unable to cast `Statement` to `EndWhileStatement`"),
+        }
+    }
     pub fn as_break(&self) -> &BreakStatement {
         match self {
             Statement::Break(result) => result,
             _ => panic!("Unable to cast `Statement` to `BreakStatement`"),
+        }
+    }
     pub fn as_break_mut(&mut self) -> &mut BreakStatement {
         match self {
             Statement::Break(result) => result,
             _ => panic!("Unable to cast `Statement` to `BreakStatement`"),
+        }
+    }
     pub fn as_continue(&self) -> &ContinueStatement {
         match self {
             Statement::Continue(result) => result,
             _ => panic!("Unable to cast `Statement` to `ContinueStatement`"),
+        }
+    }
     pub fn as_continue_mut(&mut self) -> &mut ContinueStatement {
         match self {
             Statement::Continue(result) => result,
             _ => panic!("Unable to cast `Statement` to `ContinueStatement`"),
+        }
+    }
     pub fn as_synchronous(&self) -> &SynchronousStatement {
         match self {
             Statement::Synchronous(result) => result,
             _ => panic!("Unable to cast `Statement` to `SynchronousStatement`"),
+        }
+    }
     pub fn as_synchronous_mut(&mut self) -> &mut SynchronousStatement {
         match self {
             Statement::Synchronous(result) => result,
             _ => panic!("Unable to cast `Statement` to `SynchronousStatement`"),
+        }
+    }
     pub fn as_end_synchronous(&self) -> &EndSynchronousStatement {
         match self {
             Statement::EndSynchronous(result) => result,
             _ => panic!("Unable to cast `Statement` to `EndSynchronousStatement`"),
+        }
+    }
     pub fn as_return(&self) -> &ReturnStatement {
         match self {
             Statement::Return(result) => result,
             _ => panic!("Unable to cast `Statement` to `ReturnStatement`"),
+        }
+    }
     pub fn as_assert(&self) -> &AssertStatement {
         match self {
             Statement::Assert(result) => result,
             _ => panic!("Unable to cast `Statement` to `AssertStatement`"),
+        }
+    }
     pub fn as_goto(&self) -> &GotoStatement {
         match self {
             Statement::Goto(result) => result,
             _ => panic!("Unable to cast `Statement` to `GotoStatement`"),
+        }
+    }
     pub fn as_goto_mut(&mut self) -> &mut GotoStatement {
         match self {
             Statement::Goto(result) => result,
             _ => panic!("Unable to cast `Statement` to `GotoStatement`"),
+        }
+    }
     pub fn as_new(&self) -> &NewStatement {
         match self {
             Statement::New(result) => result,
             _ => panic!("Unable to cast `Statement` to `NewStatement`"),
+        }
+    }
     pub fn as_expression(&self) -> &ExpressionStatement {
         match self {
             Statement::Expression(result) => result,
             _ => panic!("Unable to cast `Statement` to `ExpressionStatement`"),
+        }
+    }
     pub fn link_next(&mut self, next: StatementId) {
         match self {
             Statement::Block(_) => todo!(),
             Statement::Local(stmt) => match stmt {
                 LocalStatement::Channel(stmt) => stmt.next = Some(next),
                 LocalStatement::Memory(stmt) => stmt.next = Some(next),
             },
             Statement::Skip(stmt) => stmt.next = Some(next),
             Statement::EndIf(stmt) => stmt.next = Some(next),
             Statement::EndWhile(stmt) => stmt.next = Some(next),
             Statement::EndSynchronous(stmt) => stmt.next = Some(next),
             Statement::Assert(stmt) => stmt.next = Some(next),
             Statement::New(stmt) => stmt.next = Some(next),
             Statement::Expression(stmt) => stmt.next = Some(next),
             Statement::Return(_)
             | Statement::Break(_)
             | Statement::Continue(_)
             | Statement::Synchronous(_)
             | Statement::Goto(_)
             | Statement::While(_)
             | Statement::Labeled(_)
             | Statement::If(_) => unreachable!(),
+        }
+    }
+}
 impl SyntaxElement for Statement {
     fn position(&self) -> InputPosition {
         match self {
             Statement::Block(stmt) => stmt.position(),
             Statement::Local(stmt) => stmt.position(),
             Statement::Skip(stmt) => stmt.position(),
             Statement::Labeled(stmt) => stmt.position(),
             Statement::If(stmt) => stmt.position(),
             Statement::EndIf(stmt) => stmt.position(),
             Statement::While(stmt) => stmt.position(),
             Statement::EndWhile(stmt) => stmt.position(),
             Statement::Break(stmt) => stmt.position(),
             Statement::Continue(stmt) => stmt.position(),
             Statement::Synchronous(stmt) => stmt.position(),
             Statement::EndSynchronous(stmt) => stmt.position(),
             Statement::Return(stmt) => stmt.position(),
             Statement::Assert(stmt) => stmt.position(),
             Statement::Goto(stmt) => stmt.position(),
             Statement::New(stmt) => stmt.position(),
             Statement::Expression(stmt) => stmt.position(),
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct BlockStatement {
     pub this: BlockStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub statements: Vec<StatementId>,
     // Phase 2: linker
     pub parent_scope: Option<Scope>,
     pub relative_pos_in_parent: u32,
     pub locals: Vec<LocalId>,
     pub labels: Vec<LabeledStatementId>,
+}
 impl BlockStatement {
     pub fn parent_block(&self, h: &Heap) -> Option<BlockStatementId> {
         let parent = self.parent_scope.unwrap();
         match parent {
             Scope::Definition(_) => {
                 // If the parent scope is a definition, then there is no
                 // parent block.
                 None
+            }
             Scope::Synchronous((parent, _)) => {
                 // It is always the case that when this function is called,
                 // the parent of a synchronous statement is a block statement:
                 // nested synchronous statements are flagged illegal,
                 // and that happens before resolving variables that
                 // creates the parent_scope references in the first place.
                 Some(h[parent].parent_scope(h).unwrap().to_block())
+            }
             Scope::Regular(parent) => {
                 // A variable scope is either a definition, sync, or block.
                 Some(parent)
+            }
+        }
+    }
     pub fn first(&self) -> StatementId {
         // It is an invariant (guaranteed by the lexer) that block statements have at least one stmt
         *self.statements.first().unwrap()
+    }
+}
 impl SyntaxElement for BlockStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 impl VariableScope for BlockStatement {
     fn parent_scope(&self, _h: &Heap) -> Option<Scope> {
         self.parent_scope.clone()
+    }
     fn get_variable(&self, h: &Heap, id: &Identifier) -> Option<VariableId> {
         for local_id in self.locals.iter() {
             let local = &h[*local_id];
             if local.identifier.value == id.value {
                 return Some(local_id.0);
+            }
+        }
         None
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum LocalStatement {
     Memory(MemoryStatement),
     Channel(ChannelStatement),
+}
 impl LocalStatement {
     pub fn this(&self) -> LocalStatementId {
         match self {
             LocalStatement::Memory(stmt) => stmt.this.upcast(),
             LocalStatement::Channel(stmt) => stmt.this.upcast(),
+        }
+    }
     pub fn as_memory(&self) -> &MemoryStatement {
         match self {
             LocalStatement::Memory(result) => result,
             _ => panic!("Unable to cast `LocalStatement` to `MemoryStatement`"),
+        }
+    }
     pub fn as_channel(&self) -> &ChannelStatement {
         match self {
             LocalStatement::Channel(result) => result,
             _ => panic!("Unable to cast `LocalStatement` to `ChannelStatement`"),
+        }
+    }
     pub fn next(&self) -> Option<StatementId> {
         match self {
             LocalStatement::Memory(stmt) => stmt.next,
             LocalStatement::Channel(stmt) => stmt.next,
+        }
+    }
+}
 impl SyntaxElement for LocalStatement {
     fn position(&self) -> InputPosition {
         match self {
             LocalStatement::Memory(stmt) => stmt.position(),
             LocalStatement::Channel(stmt) => stmt.position(),
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct MemoryStatement {
     pub this: MemoryStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub variable: LocalId,
     pub initial: ExpressionId,
     // Phase 2: linker
     pub next: Option<StatementId>,
+}
 impl SyntaxElement for MemoryStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 /// ChannelStatement is the declaration of an input and output port associated
 /// with the same channel. Note that the polarity of the ports are from the
 /// point of view of the component. So an output port is something that a
 /// component uses to send data over (i.e. it is the "input end" of the
 /// channel), and vice versa.
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ChannelStatement {
     pub this: ChannelStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub from: LocalId, // output
     pub to: LocalId,   // input
     // Phase 2: linker
     pub relative_pos_in_block: u32,
     pub next: Option<StatementId>,
+}
 impl SyntaxElement for ChannelStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct SkipStatement {
     pub this: SkipStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     // Phase 2: linker
     pub next: Option<StatementId>,
+}
 impl SyntaxElement for SkipStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct LabeledStatement {
     pub this: LabeledStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub label: Identifier,
     pub body: StatementId,
     // Phase 2: linker
     pub relative_pos_in_block: u32,
     pub in_sync: Option<SynchronousStatementId>,
+}
 impl SyntaxElement for LabeledStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct IfStatement {
     pub this: IfStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub test: ExpressionId,
     pub true_body: StatementId,
     pub false_body: StatementId,
     // Phase 2: linker
     pub end_if: Option<EndIfStatementId>,
+}
 impl SyntaxElement for IfStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct EndIfStatement {
     pub this: EndIfStatementId,
     // Phase 2: linker
     pub start_if: IfStatementId,
     pub position: InputPosition, // of corresponding if statement
     pub next: Option<StatementId>,
+}
 impl SyntaxElement for EndIfStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct WhileStatement {
     pub this: WhileStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub test: ExpressionId,
     pub body: StatementId,
     // Phase 2: linker
     pub end_while: Option<EndWhileStatementId>,
     pub in_sync: Option<SynchronousStatementId>,
+}
 impl SyntaxElement for WhileStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct EndWhileStatement {
     pub this: EndWhileStatementId,
     // Phase 2: linker
     pub start_while: WhileStatementId,
     pub position: InputPosition, // of corresponding while
     pub next: Option<StatementId>,
+}
 impl SyntaxElement for EndWhileStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct BreakStatement {
     pub this: BreakStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub label: Option<Identifier>,
     // Phase 2: linker
     pub target: Option<EndWhileStatementId>,
+}
 impl SyntaxElement for BreakStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ContinueStatement {
     pub this: ContinueStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub label: Option<Identifier>,
     // Phase 2: linker
     pub target: Option<WhileStatementId>,
+}
 impl SyntaxElement for ContinueStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct SynchronousStatement {
     pub this: SynchronousStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     // pub parameters: Vec<ParameterId>,
     pub body: StatementId,
     // Phase 2: linker
     pub end_sync: Option<EndSynchronousStatementId>,
     pub parent_scope: Option<Scope>,
+}
 impl SyntaxElement for SynchronousStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 impl VariableScope for SynchronousStatement {
     fn parent_scope(&self, _h: &Heap) -> Option<Scope> {
         self.parent_scope.clone()
+    }
     fn get_variable(&self, _h: &Heap, _id: &Identifier) -> Option<VariableId> {
         // TODO: Another case of "where was this used for?"
         // for parameter_id in self.parameters.iter() {
         //     let parameter = &h[*parameter_id];
         //     if parameter.identifier.value == id.value {
         //         return Some(parameter_id.0);
         //     }
         // }
         None
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct EndSynchronousStatement {
     pub this: EndSynchronousStatementId,
     // Phase 2: linker
     pub position: InputPosition, // of corresponding sync statement
     pub start_sync: SynchronousStatementId,
     pub next: Option<StatementId>,
+}
 impl SyntaxElement for EndSynchronousStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ReturnStatement {
     pub this: ReturnStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub expression: ExpressionId,
+}
 impl SyntaxElement for ReturnStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct AssertStatement {
     pub this: AssertStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub expression: ExpressionId,
     // Phase 2: linker
     pub next: Option<StatementId>,
+}
 impl SyntaxElement for AssertStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct GotoStatement {
     pub this: GotoStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub label: Identifier,
     // Phase 2: linker
     pub target: Option<LabeledStatementId>,
+}
 impl SyntaxElement for GotoStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct NewStatement {
     pub this: NewStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub expression: CallExpressionId,
     // Phase 2: linker
     pub next: Option<StatementId>,
+}
 impl SyntaxElement for NewStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ExpressionStatement {
     pub this: ExpressionStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub expression: ExpressionId,
     // Phase 2: linker
     pub next: Option<StatementId>,
+}
 impl SyntaxElement for ExpressionStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, PartialEq, Eq, Clone, Copy, serde::Serialize, serde::Deserialize)]
 pub enum ExpressionParent {
     None, // only set during initial parsing
     Memory(MemoryStatementId),
     If(IfStatementId),
     While(WhileStatementId),
     Return(ReturnStatementId),
     Assert(AssertStatementId),
     New(NewStatementId),
     ExpressionStmt(ExpressionStatementId),
     Expression(ExpressionId, u32) // index within expression (e.g LHS or RHS of expression)
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Expression {
     Assignment(AssignmentExpression),
     Conditional(ConditionalExpression),
     Binary(BinaryExpression),
     Unary(UnaryExpression),
     Indexing(IndexingExpression),
     Slicing(SlicingExpression),
     Select(SelectExpression),
     Array(ArrayExpression),
     Constant(ConstantExpression),
     Call(CallExpression),
     Variable(VariableExpression),
+}
 impl Expression {
     pub fn as_assignment(&self) -> &AssignmentExpression {
         match self {
             Expression::Assignment(result) => result,
             _ => panic!("Unable to cast `Expression` to `AssignmentExpression`"),
+        }
+    }
     pub fn as_conditional(&self) -> &ConditionalExpression {
         match self {
             Expression::Conditional(result) => result,
             _ => panic!("Unable to cast `Expression` to `ConditionalExpression`"),
+        }
+    }
     pub fn as_binary(&self) -> &BinaryExpression {
         match self {
             Expression::Binary(result) => result,
             _ => panic!("Unable to cast `Expression` to `BinaryExpression`"),
+        }
+    }
     pub fn as_unary(&self) -> &UnaryExpression {
         match self {
             Expression::Unary(result) => result,
             _ => panic!("Unable to cast `Expression` to `UnaryExpression`"),
+        }
+    }
     pub fn as_indexing(&self) -> &IndexingExpression {
         match self {
             Expression::Indexing(result) => result,
             _ => panic!("Unable to cast `Expression` to `IndexingExpression`"),
+        }
+    }
     pub fn as_slicing(&self) -> &SlicingExpression {
         match self {
             Expression::Slicing(result) => result,
             _ => panic!("Unable to cast `Expression` to `SlicingExpression`"),
+        }
+    }
     pub fn as_select(&self) -> &SelectExpression {
         match self {
             Expression::Select(result) => result,
             _ => panic!("Unable to cast `Expression` to `SelectExpression`"),
+        }
+    }
     pub fn as_array(&self) -> &ArrayExpression {
         match self {
             Expression::Array(result) => result,
             _ => panic!("Unable to cast `Expression` to `ArrayExpression`"),
+        }
+    }
     pub fn as_constant(&self) -> &ConstantExpression {
         match self {
             Expression::Constant(result) => result,
             _ => panic!("Unable to cast `Expression` to `ConstantExpression`"),
+        }
+    }
     pub fn as_call(&self) -> &CallExpression {
         match self {
             Expression::Call(result) => result,
             _ => panic!("Unable to cast `Expression` to `CallExpression`"),
+        }
+    }
     pub fn as_call_mut(&mut self) -> &mut CallExpression {
         match self {
             Expression::Call(result) => result,
             _ => panic!("Unable to cast `Expression` to `CallExpression`"),
+        }
+    }
     pub fn as_variable(&self) -> &VariableExpression {
         match self {
             Expression::Variable(result) => result,
             _ => panic!("Unable to cast `Expression` to `VariableExpression`"),
+        }
+    }
     pub fn as_variable_mut(&mut self) -> &mut VariableExpression {
         match self {
             Expression::Variable(result) => result,
             _ => panic!("Unable to cast `Expression` to `VariableExpression`"),
+        }
+    }
     // TODO: @cleanup
     pub fn parent(&self) -> &ExpressionParent {
         match self {
             Expression::Assignment(expr) => &expr.parent,
             Expression::Conditional(expr) => &expr.parent,
             Expression::Binary(expr) => &expr.parent,
             Expression::Unary(expr) => &expr.parent,
             Expression::Indexing(expr) => &expr.parent,
             Expression::Slicing(expr) => &expr.parent,
             Expression::Select(expr) => &expr.parent,
             Expression::Array(expr) => &expr.parent,
             Expression::Constant(expr) => &expr.parent,
             Expression::Call(expr) => &expr.parent,
             Expression::Variable(expr) => &expr.parent,
+        }
+    }
     // TODO: @cleanup
     pub fn parent_expr_id(&self) -> Option<ExpressionId> {
         if let ExpressionParent::Expression(id, _) = self.parent() {
             Some(*id)
         } else {
             None
+        }
+    }
     // TODO: @cleanup
     pub fn set_parent(&mut self, parent: ExpressionParent) {
         match self {
             Expression::Assignment(expr) => expr.parent = parent,
             Expression::Conditional(expr) => expr.parent = parent,
             Expression::Binary(expr) => expr.parent = parent,
             Expression::Unary(expr) => expr.parent = parent,
             Expression::Indexing(expr) => expr.parent = parent,
             Expression::Slicing(expr) => expr.parent = parent,
             Expression::Select(expr) => expr.parent = parent,
             Expression::Array(expr) => expr.parent = parent,
             Expression::Constant(expr) => expr.parent = parent,
             Expression::Call(expr) => expr.parent = parent,
             Expression::Variable(expr) => expr.parent = parent,
+        }
+    }
     // TODO: @cleanup
     pub fn get_type_mut(&mut self) -> &mut ConcreteType {
         match self {
             Expression::Assignment(expr) => &mut expr.concrete_type,
             Expression::Conditional(expr) => &mut expr.concrete_type,
             Expression::Binary(expr) => &mut expr.concrete_type,
             Expression::Unary(expr) => &mut expr.concrete_type,
             Expression::Indexing(expr) => &mut expr.concrete_type,
             Expression::Slicing(expr) => &mut expr.concrete_type,
             Expression::Select(expr) => &mut expr.concrete_type,
             Expression::Array(expr) => &mut expr.concrete_type,
             Expression::Constant(expr) => &mut expr.concrete_type,
             Expression::Call(expr) => &mut expr.concrete_type,
             Expression::Variable(expr) => &mut expr.concrete_type,
+        }
+    }
+}
 impl SyntaxElement for Expression {
     fn position(&self) -> InputPosition {
         match self {
             Expression::Assignment(expr) => expr.position(),
             Expression::Conditional(expr) => expr.position(),
             Expression::Binary(expr) => expr.position(),
             Expression::Unary(expr) => expr.position(),
             Expression::Indexing(expr) => expr.position(),
             Expression::Slicing(expr) => expr.position(),
             Expression::Select(expr) => expr.position(),
             Expression::Array(expr) => expr.position(),
             Expression::Constant(expr) => expr.position(),
             Expression::Call(expr) => expr.position(),
             Expression::Variable(expr) => expr.position(),
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum AssignmentOperator {
     Set,
     Multiplied,
     Divided,
     Remained,
     Added,
     Subtracted,
     ShiftedLeft,
     ShiftedRight,
     BitwiseAnded,
     BitwiseXored,
     BitwiseOred,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct AssignmentExpression {
     pub this: AssignmentExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub left: ExpressionId,
     pub operation: AssignmentOperator,
     pub right: ExpressionId,
     // Phase 2: linker
     pub parent: ExpressionParent,
     // Phase 3: type checking
     pub concrete_type: ConcreteType,
+}
 impl SyntaxElement for AssignmentExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ConditionalExpression {
     pub this: ConditionalExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub test: ExpressionId,
     pub true_expression: ExpressionId,
     pub false_expression: ExpressionId,
     // Phase 2: linker
     pub parent: ExpressionParent,
     // Phase 3: type checking
     pub concrete_type: ConcreteType,
+}
 impl SyntaxElement for ConditionalExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum BinaryOperator {
     Concatenate,
     LogicalOr,
     LogicalAnd,
     BitwiseOr,
     BitwiseXor,
     BitwiseAnd,
     Equality,
     Inequality,
     LessThan,
     GreaterThan,
     LessThanEqual,
     GreaterThanEqual,
     ShiftLeft,
     ShiftRight,
     Add,
     Subtract,
     Multiply,
     Divide,
     Remainder,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct BinaryExpression {
     pub this: BinaryExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub left: ExpressionId,
     pub operation: BinaryOperator,
     pub right: ExpressionId,
     // Phase 2: linker
     pub parent: ExpressionParent,
     // Phase 3: type checking
     pub concrete_type: ConcreteType,
+}
 impl SyntaxElement for BinaryExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum UnaryOperation {
     Positive,
     Negative,
     BitwiseNot,
     LogicalNot,
     PreIncrement,
     PreDecrement,
     PostIncrement,
     PostDecrement,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct UnaryExpression {
     pub this: UnaryExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub operation: UnaryOperation,
     pub expression: ExpressionId,
     // Phase 2: linker
     pub parent: ExpressionParent,
     // Phase 3: type checking
     pub concrete_type: ConcreteType,
+}
 impl SyntaxElement for UnaryExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct IndexingExpression {
     pub this: IndexingExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub subject: ExpressionId,
     pub index: ExpressionId,
     // Phase 2: linker
     pub parent: ExpressionParent,
     // Phase 3: type checking
     pub concrete_type: ConcreteType,
+}
 impl SyntaxElement for IndexingExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct SlicingExpression {
     pub this: SlicingExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub subject: ExpressionId,
     pub from_index: ExpressionId,
     pub to_index: ExpressionId,
     // Phase 2: linker
     pub parent: ExpressionParent,
     // Phase 3: type checking
     pub concrete_type: ConcreteType,
+}
 impl SyntaxElement for SlicingExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct SelectExpression {
     pub this: SelectExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub subject: ExpressionId,
     pub field: Field,
     // Phase 2: linker
     pub parent: ExpressionParent,
     // Phase 3: type checking
     pub concrete_type: ConcreteType,
+}
 impl SyntaxElement for SelectExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ArrayExpression {
     pub this: ArrayExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub elements: Vec<ExpressionId>,
     // Phase 2: linker
     pub parent: ExpressionParent,
     // Phase 3: type checking
     pub concrete_type: ConcreteType,
+}
 impl SyntaxElement for ArrayExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct CallExpression {
     pub this: CallExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub method: Method,
     pub arguments: Vec<ExpressionId>,
     pub poly_args: Vec<ParserTypeId>,
     // Phase 2: linker
     pub parent: ExpressionParent,
     // Phase 3: type checking
     pub concrete_type: ConcreteType,
+}
 impl SyntaxElement for CallExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ConstantExpression {
     pub this: ConstantExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub value: Constant,
     // Phase 2: linker
     pub parent: ExpressionParent,
     // Phase 3: type checking
     pub concrete_type: ConcreteType,
+}
 impl SyntaxElement for ConstantExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct VariableExpression {
     pub this: VariableExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub identifier: NamespacedIdentifier,
     // Phase 2: linker
     pub declaration: Option<VariableId>,
     pub parent: ExpressionParent,
     // Phase 3: type checking
     pub concrete_type: ConcreteType,
+}
 impl SyntaxElement for VariableExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}

src/protocol/ast_printer.rs

➞

Show inline comments

 use std::fmt::{Debug, Display, Write};
 use std::io::Write as IOWrite;
 use super::ast::*;
 const INDENT: usize = 2;
 const PREFIX_EMPTY: &'static str = "    ";
 const PREFIX_ROOT_ID: &'static str = "Root";
 const PREFIX_PRAGMA_ID: &'static str = "Prag";
 const PREFIX_IMPORT_ID: &'static str = "Imp ";
 const PREFIX_TYPE_ANNOT_ID: &'static str = "TyAn";
 const PREFIX_VARIABLE_ID: &'static str = "Var ";
 const PREFIX_PARAMETER_ID: &'static str = "Par ";
 const PREFIX_LOCAL_ID: &'static str = "Loc ";
 const PREFIX_DEFINITION_ID: &'static str = "Def ";
 const PREFIX_STRUCT_ID: &'static str = "DefS";
 const PREFIX_ENUM_ID: &'static str = "DefE";
 const PREFIX_COMPONENT_ID: &'static str = "DefC";
 const PREFIX_FUNCTION_ID: &'static str = "DefF";
 const PREFIX_STMT_ID: &'static str = "Stmt";
 const PREFIX_BLOCK_STMT_ID: &'static str = "SBl ";
 const PREFIX_LOCAL_STMT_ID: &'static str = "SLoc";
 const PREFIX_MEM_STMT_ID: &'static str = "SMem";
 const PREFIX_CHANNEL_STMT_ID: &'static str = "SCha";
 const PREFIX_SKIP_STMT_ID: &'static str = "SSki";
 const PREFIX_LABELED_STMT_ID: &'static str = "SLab";
 const PREFIX_IF_STMT_ID: &'static str = "SIf ";
 const PREFIX_ENDIF_STMT_ID: &'static str = "SEIf";
 const PREFIX_WHILE_STMT_ID: &'static str = "SWhi";
 const PREFIX_ENDWHILE_STMT_ID: &'static str = "SEWh";
 const PREFIX_BREAK_STMT_ID: &'static str = "SBre";
 const PREFIX_CONTINUE_STMT_ID: &'static str = "SCon";
 const PREFIX_SYNC_STMT_ID: &'static str = "SSyn";
 const PREFIX_ENDSYNC_STMT_ID: &'static str = "SESy";
 const PREFIX_RETURN_STMT_ID: &'static str = "SRet";
 const PREFIX_ASSERT_STMT_ID: &'static str = "SAsr";
 const PREFIX_GOTO_STMT_ID: &'static str = "SGot";
 const PREFIX_NEW_STMT_ID: &'static str = "SNew";
 const PREFIX_PUT_STMT_ID: &'static str = "SPut";
 const PREFIX_EXPR_STMT_ID: &'static str = "SExp";
 const PREFIX_ASSIGNMENT_EXPR_ID: &'static str = "EAsi";
 const PREFIX_CONDITIONAL_EXPR_ID: &'static str = "ECnd";
 const PREFIX_BINARY_EXPR_ID: &'static str = "EBin";
 const PREFIX_UNARY_EXPR_ID: &'static str = "EUna";
 const PREFIX_INDEXING_EXPR_ID: &'static str = "EIdx";
 const PREFIX_SLICING_EXPR_ID: &'static str = "ESli";
 const PREFIX_SELECT_EXPR_ID: &'static str = "ESel";
 const PREFIX_ARRAY_EXPR_ID: &'static str = "EArr";
 const PREFIX_CONST_EXPR_ID: &'static str = "ECns";
 const PREFIX_CALL_EXPR_ID: &'static str = "ECll";
 const PREFIX_VARIABLE_EXPR_ID: &'static str = "EVar";
 struct KV<'a> {
     buffer: &'a mut String,
     prefix: Option<(&'static str, u32)>,
     indent: usize,
     temp_key: &'a mut String,
     temp_val: &'a mut String,
+}
 impl<'a> KV<'a> {
     fn new(buffer: &'a mut String, temp_key: &'a mut String, temp_val: &'a mut String, indent: usize) -> Self {
         temp_key.clear();
         temp_val.clear();
         KV{
             buffer,
             prefix: None,
             indent,
             temp_key,
             temp_val
+        }
+    }
     fn with_id(mut self, prefix: &'static str, id: u32) -> Self {
         self.prefix = Some((prefix, id));
         self
+    }
     fn with_s_key(self, key: &str) -> Self {
         self.temp_key.push_str(key);
         self
+    }
     fn with_d_key<D: Display>(mut self, key: &D) -> Self {
-        write!(&mut self.temp_key, "{}", key);
+        self.temp_key.push_str(&key.to_string());
         self
+    }
     fn with_s_val(self, val: &str) -> Self {
         self.temp_val.push_str(val);
         self
+    }
     fn with_disp_val<D: Display>(mut self, val: &D) -> Self {
-        write!(&mut self.temp_val, "{}", val);
+        self.temp_val.push_str(&format!("{}", val));
         self
+    }
     fn with_debug_val<D: Debug>(mut self, val: &D) -> Self {
-        write!(&mut self.temp_val, "{:?}", val);
+        self.temp_val.push_str(&format!("{:?}", val));
         self
+    }
     fn with_ascii_val(self, val: &[u8]) -> Self {
-        self.temp_val.write_str(&*String::from_utf8_lossy(val));
+        self.temp_val.push_str(&*String::from_utf8_lossy(val));
         self
+    }
     fn with_opt_disp_val<D: Display>(mut self, val: Option<&D>) -> Self {
         match val {
             Some(v) => { write!(&mut self.temp_val, "Some({})", v); },
             None => { self.temp_val.write_str("None"); }
             Some(v) => { self.temp_val.push_str(&format!("Some({})", v)); },
             None => { self.temp_val.push_str("None"); }
+        }
         self
+    }
     fn with_opt_ascii_val(self, val: Option<&[u8]>) -> Self {
         match val {
             Some(v) => {
                 self.temp_val.write_str("Some(");
                 self.temp_val.write_str(&*String::from_utf8_lossy(v));
                 self.temp_val.write_char(')');
                 self.temp_val.push_str("Some(");
                 self.temp_val.push_str(&*String::from_utf8_lossy(v));
                 self.temp_val.push(')');
             },
             None => {
-                self.temp_val.write_str("None");
+                self.temp_val.push_str("None");
+            }
+        }
         self
+    }
     fn with_custom_val<F: Fn(&mut String)>(mut self, val_fn: F) -> Self {
         val_fn(&mut self.temp_val);
         self
+    }
+}
 impl<'a> Drop for KV<'a> {
     fn drop(&mut self) {
         // Prefix and indent
         if let Some((prefix, id)) = &self.prefix {
-            write!(&mut self.buffer, "{}[{:04}] ", prefix, id);
+            self.buffer.push_str(&format!("{}[{:04}]", prefix, id));
         } else {
-            write!(&mut self.buffer, "           ");
+            self.buffer.push_str("           ");
+        }
         for _ in 0..self.indent * INDENT {
             self.buffer.push(' ');
+        }
         // Leading dash
-        self.buffer.write_str("- ");
+        self.buffer.push_str("- ");
         // Key and value
-        self.buffer.write_str(self.temp_key);
+        self.buffer.push_str(self.temp_key);
         if self.temp_val.is_empty() {
             self.buffer.push(':');
         } else {
             self.buffer.push_str(": ");
             self.buffer.push_str(&self.temp_val);
+        }
         self.buffer.push('\n');
+    }
+}
 pub(crate) struct ASTWriter {
     buffer: String,
     temp1: String,
     temp2: String,
+}
 impl ASTWriter {
     pub(crate) fn new() -> Self {
         Self{
             buffer: String::with_capacity(4096),
             temp1: String::with_capacity(256),
             temp2: String::with_capacity(256),
+        }
+    }
     pub(crate) fn write_ast<W: IOWrite>(&mut self, w: &mut W, heap: &Heap) {
         for root_id in heap.protocol_descriptions.iter().map(|v| v.this) {
             self.write_module(heap, root_id);
             w.write_all(self.buffer.as_bytes()).expect("flush buffer");
             self.buffer.clear();
+        }
+    }
     //--------------------------------------------------------------------------
     // Top-level module writing
     //--------------------------------------------------------------------------
     fn write_module(&mut self, heap: &Heap, root_id: RootId) {
         self.kv(0).with_id(PREFIX_ROOT_ID, root_id.index)
             .with_s_key("Module");
         let root = &heap[root_id];
         self.kv(1).with_s_key("Pragmas");
         for pragma_id in &root.pragmas {
             self.write_pragma(heap, *pragma_id, 2);
+        }
         self.kv(1).with_s_key("Imports");
         for import_id in &root.imports {
             self.write_import(heap, *import_id, 2);
+        }
         self.kv(1).with_s_key("Definitions");
         for def_id in &root.definitions {
             self.write_definition(heap, *def_id, 2);
+        }
+    }
     fn write_pragma(&mut self, heap: &Heap, pragma_id: PragmaId, indent: usize) {
         match &heap[pragma_id] {
             Pragma::Version(pragma) => {
                 self.kv(indent).with_id(PREFIX_PRAGMA_ID, pragma.this.index)
                     .with_s_key("PragmaVersion")
                     .with_disp_val(&pragma.version);
             },
             Pragma::Module(pragma) => {
                 self.kv(indent).with_id(PREFIX_PRAGMA_ID, pragma.this.index)
                     .with_s_key("PragmaModule")
                     .with_ascii_val(&pragma.value);
+            }
+        }
+    }
     fn write_import(&mut self, heap: &Heap, import_id: ImportId, indent: usize) {
         let import = &heap[import_id];
         let indent2 = indent + 1;
         match import {
             Import::Module(import) => {
                 self.kv(indent).with_id(PREFIX_IMPORT_ID, import.this.index)
                     .with_s_key("ImportModule");
                 self.kv(indent2).with_s_key("Name").with_ascii_val(&import.module_name);
                 self.kv(indent2).with_s_key("Alias").with_ascii_val(&import.alias);
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(import.module_id.as_ref().map(|v| &v.index));
             },
             Import::Symbols(import) => {
                 self.kv(indent).with_id(PREFIX_IMPORT_ID, import.this.index)
                     .with_s_key("ImportSymbol");
                 self.kv(indent2).with_s_key("Name").with_ascii_val(&import.module_name);
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(import.module_id.as_ref().map(|v| &v.index));
                 self.kv(indent2).with_s_key("Symbols");
                 let indent3 = indent2 + 1;
                 let indent4 = indent3 + 1;
                 for symbol in &import.symbols {
                     self.kv(indent3).with_s_key("AliasedSymbol");
                     self.kv(indent4).with_s_key("Name").with_ascii_val(&symbol.name);
                     self.kv(indent4).with_s_key("Alias").with_ascii_val(&symbol.alias);
                     self.kv(indent4).with_s_key("Definition")
                         .with_opt_disp_val(symbol.definition_id.as_ref().map(|v| &v.index));
+                }
+            }
+        }
+    }
     //--------------------------------------------------------------------------
     // Top-level definition writing
     //--------------------------------------------------------------------------
     fn write_definition(&mut self, heap: &Heap, def_id: DefinitionId, indent: usize) {
         let indent2 = indent + 1;
         let indent3 = indent2 + 1;
         let indent4 = indent3 + 1;
         match &heap[def_id] {
             Definition::Struct(_) => todo!("implement Definition::Struct"),
             Definition::Enum(_) => todo!("implement Definition::Enum"),
             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_ascii_val(&def.identifier.value);
                 for poly_var_id in &def.poly_vars {
                     self.kv(indent3).with_s_key("PolyVar");
                     self.kv(indent4).with_s_key("Name").with_ascii_val(&poly_var_id.value);
+                }
-                self.kv(indent2).with_s_key("ReturnType").with_custom_val(|s| write_type(s, heap, &heap[def.return_type]));
+                self.kv(indent2).with_s_key("ReturnParserType").with_custom_val(|s| write_parser_type(s, heap, &heap[def.return_type]));
                 self.kv(indent2).with_s_key("Parameters");
                 for param_id in &def.parameters {
                     self.write_parameter(heap, *param_id, indent3);
+                }
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, def.body, 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_ascii_val(&def.identifier.value);
                 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");
                     self.kv(indent4).with_s_key("Name").with_ascii_val(&poly_var_id.value);
+                }
                 self.kv(indent2).with_s_key("Parameters");
                 for param_id in &def.parameters {
                     self.write_parameter(heap, *param_id, indent3)
+                }
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, def.body, indent3);
+            }
+        }
+    }
     fn write_parameter(&mut self, heap: &Heap, param_id: ParameterId, indent: usize) {
         let indent2 = indent + 1;
         let param = &heap[param_id];
         self.kv(indent).with_id(PREFIX_PARAMETER_ID, param_id.0.index)
             .with_s_key("Parameter");
         self.kv(indent2).with_s_key("Name").with_ascii_val(&param.identifier.value);
-        self.kv(indent2).with_s_key("Type").with_custom_val(|w| write_type(w, heap, &heap[param.parser_type]));
+        self.kv(indent2).with_s_key("ParserType").with_custom_val(|w| write_parser_type(w, heap, &heap[param.parser_type]));
+    }
     fn write_stmt(&mut self, heap: &Heap, stmt_id: StatementId, indent: usize) {
         let stmt = &heap[stmt_id];
         let indent2 = indent + 1;
         let indent3 = indent2 + 1;
         match stmt {
             Statement::Block(stmt) => {
                 self.kv(indent).with_id(PREFIX_BLOCK_STMT_ID, stmt.this.0.index)
                     .with_s_key("Block");
                 for stmt_id in &stmt.statements {
                     self.write_stmt(heap, *stmt_id, indent2);
+                }
             },
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Channel(stmt) => {
                         self.kv(indent).with_id(PREFIX_CHANNEL_STMT_ID, stmt.this.0.0.index)
                             .with_s_key("LocalChannel");
                         self.kv(indent2).with_s_key("From");
                         self.write_local(heap, stmt.from, indent3);
                         self.kv(indent2).with_s_key("To");
                         self.write_local(heap, stmt.to, indent3);
                         self.kv(indent2).with_s_key("Next")
                             .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
                     },
                     LocalStatement::Memory(stmt) => {
                         self.kv(indent).with_id(PREFIX_MEM_STMT_ID, stmt.this.0.0.index)
                             .with_s_key("LocalMemory");
                         self.kv(indent2).with_s_key("Variable");
                         self.write_local(heap, stmt.variable, indent3);
                         self.kv(indent2).with_s_key("initial");
                         self.write_expr(heap, stmt.initial, indent3);
                         self.kv(indent2).with_s_key("Next")
                             .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
+                    }
+                }
             },
             Statement::Skip(stmt) => {
                 self.kv(indent).with_id(PREFIX_SKIP_STMT_ID, stmt.this.0.index)
                     .with_s_key("Skip");
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Labeled(stmt) => {
                 self.kv(indent).with_id(PREFIX_LABELED_STMT_ID, stmt.this.0.index)
                     .with_s_key("Labeled");
                 self.kv(indent2).with_s_key("Label").with_ascii_val(&stmt.label.value);
                 self.kv(indent2).with_s_key("Statement");
                 self.write_stmt(heap, stmt.body, indent3);
             },
             Statement::If(stmt) => {
                 self.kv(indent).with_id(PREFIX_IF_STMT_ID, stmt.this.0.index)
                     .with_s_key("If");
                 self.kv(indent2).with_s_key("EndIf")
                     .with_opt_disp_val(stmt.end_if.as_ref().map(|v| &v.0.index));
                 self.kv(indent2).with_s_key("Condition");
                 self.write_expr(heap, stmt.test, indent3);
                 self.kv(indent2).with_s_key("TrueBody");
                 self.write_stmt(heap, stmt.true_body, indent3);
                 self.kv(indent2).with_s_key("FalseBody");
                 self.write_stmt(heap, stmt.false_body, indent3);
             },
             Statement::EndIf(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDIF_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndIf");
                 self.kv(indent2).with_s_key("StartIf").with_disp_val(&stmt.start_if.0.index);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::While(stmt) => {
                 self.kv(indent).with_id(PREFIX_WHILE_STMT_ID, stmt.this.0.index)
                     .with_s_key("While");
                 self.kv(indent2).with_s_key("EndWhile")
                     .with_opt_disp_val(stmt.end_while.as_ref().map(|v| &v.0.index));
                 self.kv(indent2).with_s_key("InSync")
                     .with_opt_disp_val(stmt.in_sync.as_ref().map(|v| &v.0.index));
                 self.kv(indent2).with_s_key("Condition");
                 self.write_expr(heap, stmt.test, indent3);
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, stmt.body, indent3);
             },
             Statement::EndWhile(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDWHILE_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndWhile");
                 self.kv(indent2).with_s_key("StartWhile").with_disp_val(&stmt.start_while.0.index);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Break(stmt) => {
                 self.kv(indent).with_id(PREFIX_BREAK_STMT_ID, stmt.this.0.index)
                     .with_s_key("Break");
                 self.kv(indent2).with_s_key("Label")
                     .with_opt_ascii_val(stmt.label.as_ref().map(|v| v.value.as_slice()));
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.index));
             },
             Statement::Continue(stmt) => {
                 self.kv(indent).with_id(PREFIX_CONTINUE_STMT_ID, stmt.this.0.index)
                     .with_s_key("Continue");
                 self.kv(indent2).with_s_key("Label")
                     .with_opt_ascii_val(stmt.label.as_ref().map(|v| v.value.as_slice()));
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.index));
             },
             Statement::Synchronous(stmt) => {
                 self.kv(indent).with_id(PREFIX_SYNC_STMT_ID, stmt.this.0.index)
                     .with_s_key("Synchronous");
                 self.kv(indent2).with_s_key("EndSync")
                     .with_opt_disp_val(stmt.end_sync.as_ref().map(|v| &v.0.index));
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, stmt.body, indent3);
             },
             Statement::EndSynchronous(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDSYNC_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndSynchronous");
                 self.kv(indent2).with_s_key("StartSync").with_disp_val(&stmt.start_sync.0.index);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Return(stmt) => {
                 self.kv(indent).with_id(PREFIX_RETURN_STMT_ID, stmt.this.0.index)
                     .with_s_key("Return");
                 self.kv(indent2).with_s_key("Expression");
                 self.write_expr(heap, stmt.expression, indent3);
             },
             Statement::Assert(stmt) => {
                 self.kv(indent).with_id(PREFIX_ASSERT_STMT_ID, stmt.this.0.index)
                     .with_s_key("Assert");
                 self.kv(indent2).with_s_key("Expression");
                 self.write_expr(heap, stmt.expression, indent3);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Goto(stmt) => {
                 self.kv(indent).with_id(PREFIX_GOTO_STMT_ID, stmt.this.0.index)
                     .with_s_key("Goto");
                 self.kv(indent2).with_s_key("Label").with_ascii_val(&stmt.label.value);
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.index));
             },
             Statement::New(stmt) => {
                 self.kv(indent).with_id(PREFIX_NEW_STMT_ID, stmt.this.0.index)
                     .with_s_key("New");
                 self.kv(indent2).with_s_key("Expression");
                 self.write_expr(heap, stmt.expression.upcast(), indent3);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Expression(stmt) => {
                 self.kv(indent).with_id(PREFIX_EXPR_STMT_ID, stmt.this.0.index)
                     .with_s_key("ExpressionStatement");
                 self.write_expr(heap, stmt.expression, indent2);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
+            }
+        }
+    }
     fn write_expr(&mut self, heap: &Heap, expr_id: ExpressionId, indent: usize) {
         let expr = &heap[expr_id];
         let indent2 = indent + 1;
         let indent3 = indent2 + 1;
         match expr {
             Expression::Assignment(expr) => {
                 self.kv(indent).with_id(PREFIX_ASSIGNMENT_EXPR_ID, expr.this.0.index)
                     .with_s_key("AssignmentExpr");
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Left");
                 self.write_expr(heap, expr.left, indent3);
                 self.kv(indent2).with_s_key("Right");
                 self.write_expr(heap, expr.right, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
                 self.kv(indent2).with_s_key("ConcreteType")
                     .with_custom_val(|v| write_concrete_type(v, heap, &expr.concrete_type));
             },
             Expression::Conditional(expr) => {
                 self.kv(indent).with_id(PREFIX_CONDITIONAL_EXPR_ID, expr.this.0.index)
                     .with_s_key("ConditionalExpr");
                 self.kv(indent2).with_s_key("Condition");
                 self.write_expr(heap, expr.test, indent3);
                 self.kv(indent2).with_s_key("TrueExpression");
                 self.write_expr(heap, expr.true_expression, indent3);
                 self.kv(indent2).with_s_key("FalseExpression");
                 self.write_expr(heap, expr.false_expression, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
                 self.kv(indent2).with_s_key("ConcreteType")
                     .with_custom_val(|v| write_concrete_type(v, heap, &expr.concrete_type));
             },
             Expression::Binary(expr) => {
                 self.kv(indent).with_id(PREFIX_BINARY_EXPR_ID, expr.this.0.index)
                     .with_s_key("BinaryExpr");
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Left");
                 self.write_expr(heap, expr.left, indent3);
                 self.kv(indent2).with_s_key("Right");
                 self.write_expr(heap, expr.right, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
                 self.kv(indent2).with_s_key("ConcreteType")
                     .with_custom_val(|v| write_concrete_type(v, heap, &expr.concrete_type));
             },
             Expression::Unary(expr) => {
                 self.kv(indent).with_id(PREFIX_UNARY_EXPR_ID, expr.this.0.index)
                     .with_s_key("UnaryExpr");
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Argument");
                 self.write_expr(heap, expr.expression, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
                 self.kv(indent2).with_s_key("ConcreteType")
                     .with_custom_val(|v| write_concrete_type(v, heap, &expr.concrete_type));
             },
             Expression::Indexing(expr) => {
                 self.kv(indent).with_id(PREFIX_INDEXING_EXPR_ID, expr.this.0.index)
                     .with_s_key("IndexingExpr");
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("Index");
                 self.write_expr(heap, expr.index, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
                 self.kv(indent2).with_s_key("ConcreteType")
                     .with_custom_val(|v| write_concrete_type(v, heap, &expr.concrete_type));
             },
             Expression::Slicing(expr) => {
                 self.kv(indent).with_id(PREFIX_SLICING_EXPR_ID, expr.this.0.index)
                     .with_s_key("SlicingExpr");
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("FromIndex");
                 self.write_expr(heap, expr.from_index, indent3);
                 self.kv(indent2).with_s_key("ToIndex");
                 self.write_expr(heap, expr.to_index, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
                 self.kv(indent2).with_s_key("ConcreteType")
                     .with_custom_val(|v| write_concrete_type(v, heap, &expr.concrete_type));
             },
             Expression::Select(expr) => {
                 self.kv(indent).with_id(PREFIX_SELECT_EXPR_ID, expr.this.0.index)
                     .with_s_key("SelectExpr");
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 match &expr.field {
                     Field::Length => {
                         self.kv(indent2).with_s_key("Field").with_s_val("length");
                     },
                     Field::Symbolic(field) => {
                         self.kv(indent2).with_s_key("Field").with_ascii_val(&field.value);
+                    }
+                }
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
                 self.kv(indent2).with_s_key("ConcreteType")
                     .with_custom_val(|v| write_concrete_type(v, heap, &expr.concrete_type));
             },
             Expression::Array(expr) => {
                 self.kv(indent).with_id(PREFIX_ARRAY_EXPR_ID, expr.this.0.index)
                     .with_s_key("ArrayExpr");
                 self.kv(indent2).with_s_key("Elements");
                 for expr_id in &expr.elements {
                     self.write_expr(heap, *expr_id, indent3);
+                }
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
                 self.kv(indent2).with_s_key("ConcreteType")
                     .with_custom_val(|v| write_concrete_type(v, heap, &expr.concrete_type));
             },
             Expression::Constant(expr) => {
                 self.kv(indent).with_id(PREFIX_CONST_EXPR_ID, expr.this.0.index)
                     .with_s_key("ConstantExpr");
                 let val = self.kv(indent2).with_s_key("Value");
                 match &expr.value {
                     Constant::Null => { val.with_s_val("null"); },
                     Constant::True => { val.with_s_val("true"); },
                     Constant::False => { val.with_s_val("false"); },
                     Constant::Character(char) => { val.with_ascii_val(char); },
                     Constant::Integer(int) => { val.with_disp_val(int); },
+                }
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
                 self.kv(indent2).with_s_key("ConcreteType")
                     .with_custom_val(|v| write_concrete_type(v, heap, &expr.concrete_type));
             },
             Expression::Call(expr) => {
                 self.kv(indent).with_id(PREFIX_CALL_EXPR_ID, expr.this.0.index)
                     .with_s_key("CallExpr");
                 // Method
                 let method = self.kv(indent2).with_s_key("Method");
                 match &expr.method {
                     Method::Get => { method.with_s_val("get"); },
                     Method::Put => { method.with_s_val("put"); },
                     Method::Fires => { method.with_s_val("fires"); },
                     Method::Create => { method.with_s_val("create"); },
                     Method::Symbolic(symbolic) => {
                         method.with_s_val("symbolic");
                         self.kv(indent3).with_s_key("Name").with_ascii_val(&symbolic.identifier.value);
                         self.kv(indent3).with_s_key("Definition")
                             .with_opt_disp_val(symbolic.definition.as_ref().map(|v| &v.index));
+                    }
+                }
                 // Arguments
                 self.kv(indent2).with_s_key("Arguments");
                 for arg_id in &expr.arguments {
                     self.write_expr(heap, *arg_id, indent3);
+                }
                 // Parent
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
                 self.kv(indent2).with_s_key("ConcreteType")
                     .with_custom_val(|v| write_concrete_type(v, heap, &expr.concrete_type));
             },
             Expression::Variable(expr) => {
                 self.kv(indent).with_id(PREFIX_VARIABLE_EXPR_ID, expr.this.0.index)
                     .with_s_key("VariableExpr");
                 self.kv(indent2).with_s_key("Name").with_ascii_val(&expr.identifier.value);
                 self.kv(indent2).with_s_key("Definition")
                     .with_opt_disp_val(expr.declaration.as_ref().map(|v| &v.index));
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
                 self.kv(indent2).with_s_key("ConcreteType")
                     .with_custom_val(|v| write_concrete_type(v, heap, &expr.concrete_type));
+            }
+        }
+    }
     fn write_local(&mut self, heap: &Heap, local_id: LocalId, indent: usize) {
         let local = &heap[local_id];
         let indent2 = indent + 1;
         self.kv(indent).with_id(PREFIX_LOCAL_ID, local_id.0.index)
             .with_s_key("Local");
         self.kv(indent2).with_s_key("Name").with_ascii_val(&local.identifier.value);
         self.kv(indent2).with_s_key("Type")
             .with_custom_val(|w| write_type(w, heap, &heap[local.parser_type]));
         self.kv(indent2).with_s_key("ParserType")
             .with_custom_val(|w| write_parser_type(w, heap, &heap[local.parser_type]));
+    }
     //--------------------------------------------------------------------------
     // Printing Utilities
     //--------------------------------------------------------------------------
     fn kv(&mut self, indent: usize) -> KV {
         KV::new(&mut self.buffer, &mut self.temp1, &mut self.temp2, indent)
+    }
     fn flush<W: IOWrite>(&mut self, w: &mut W) {
         w.write(self.buffer.as_bytes()).unwrap();
         self.buffer.clear()
+    }
+}
 fn write_option<V: Display>(target: &mut String, value: Option<V>) {
     target.clear();
     match &value {
         Some(v) => write!(target, "Some({})", v),
         None => target.write_str("None")
         Some(v) => target.push_str(&format!("Some({})", v)),
         None => target.push_str("None")
     };
+}
-fn write_type(target: &mut String, heap: &Heap, t: &ParserType) {
+fn write_parser_type(target: &mut String, heap: &Heap, t: &ParserType) {
     use ParserTypeVariant as PTV;
     let mut embedded = Vec::new();
     match &t.variant {
         PTV::Input(id) => { target.write_str("in"); embedded.push(*id); }
         PTV::Output(id) => { target.write_str("out"); embedded.push(*id) }
         PTV::Array(id) => { target.write_str("array"); embedded.push(*id) }
         PTV::Message => { target.write_str("msg"); }
         PTV::Bool => { target.write_str("bool"); }
         PTV::Byte => { target.write_str("byte"); }
         PTV::Short => { target.write_str("short"); }
         PTV::Int => { target.write_str("int"); }
         PTV::Long => { target.write_str("long"); }
         PTV::String => { target.write_str("str"); }
         PTV::IntegerLiteral => { target.write_str("int_lit"); }
         PTV::Inferred => { target.write_str("auto"); }
         PTV::Input(id) => { target.push_str("in"); embedded.push(*id); }
         PTV::Output(id) => { target.push_str("out"); embedded.push(*id) }
         PTV::Array(id) => { target.push_str("array"); embedded.push(*id) }
         PTV::Message => { target.push_str("msg"); }
         PTV::Bool => { target.push_str("bool"); }
         PTV::Byte => { target.push_str("byte"); }
         PTV::Short => { target.push_str("short"); }
         PTV::Int => { target.push_str("int"); }
         PTV::Long => { target.push_str("long"); }
         PTV::String => { target.push_str("str"); }
         PTV::IntegerLiteral => { target.push_str("int_lit"); }
         PTV::Inferred => { target.push_str("auto"); }
         PTV::Symbolic(symbolic) => {
-            target.write_str(&String::from_utf8_lossy(&symbolic.identifier.value));
+            target.push_str(&String::from_utf8_lossy(&symbolic.identifier.value));
             match symbolic.variant {
                 Some(SymbolicParserTypeVariant::PolyArg(def_id, idx)) => {
-                    target.write_str(&format!("{{def: {}, idx: {}}}", def_id.index, idx));
+                    target.push_str(&format!("{{def: {}, idx: {}}}", def_id.index, idx));
                 },
                 Some(SymbolicParserTypeVariant::Definition(def_id)) => {
-                    target.write_str(&format!("{{def: {}}}", def_id.index));
+                    target.push_str(&format!("{{def: {}}}", def_id.index));
                 },
                 None => {
-                    target.write_str("{None}");
+                    target.push_str("{None}");
+                }
+            }
             embedded.extend(&symbolic.poly_args);
+        }
     };
     if !embedded.is_empty() {
-        target.write_str("<");
+        target.push_str("<");
         for (idx, embedded_id) in embedded.into_iter().enumerate() {
             if idx != 0 { target.write_str(", "); }
             write_type(target, heap, &heap[embedded_id]);
             if idx != 0 { target.push_str(", "); }
             write_parser_type(target, heap, &heap[embedded_id]);
+        }
-        target.write_str(">");
+        target.push_str(">");
+    }
+}
 fn write_concrete_type(target: &mut String, heap: &Heap, t: &ConcreteType) {
     use ConcreteTypePart as CTP;
     fn write_concrete_part(target: &mut String, heap: &Heap, t: &ConcreteType, mut idx: usize) -> usize {
         if idx >= t.parts.len() {
             target.push_str("Programmer error: invalid concrete type tree");
             return idx;
+        }
         match &t.parts[idx] {
             CTP::Void => target.push_str("void"),
             CTP::Message => target.push_str("msg"),
             CTP::Bool => target.push_str("bool"),
             CTP::Byte => target.push_str("byte"),
             CTP::Short => target.push_str("short"),
             CTP::Int => target.push_str("int"),
             CTP::Long => target.push_str("long"),
             CTP::String => target.push_str("string"),
             CTP::Array => {
                 idx = write_concrete_part(target, heap, t, idx + 1);
                 target.push_str("[]");
             },
             CTP::Slice => {
                 idx = write_concrete_part(target, heap, t, idx + 1);
                 target.push_str("[..]");
+            }
             CTP::Input => {
                 target.push_str("in<");
                 idx = write_concrete_part(target, heap, t, idx + 1);
                 target.push('>');
             },
             CTP::Output => {
                 target.push_str("out<");
                 idx = write_concrete_part(target, heap, t, idx + 1);
                 target.push('>')
             },
             CTP::Instance(definition_id, num_embedded) => {
                 let identifier = heap[*definition_id].identifier();
                 target.push_str(&String::from_utf8_lossy(&identifier.value));
                 target.push('<');
                 for idx_embedded in 0..*num_embedded {
                     if idx_embedded != 0 {
                         target.push_str(", ");
+                    }
                     idx = write_concrete_part(target, heap, t, idx + 1);
+                }
                 target.push('>');
+            }
+        }
         idx + 1
+    }
     write_concrete_part(target, heap, t, 0);
+}
 fn write_expression_parent(target: &mut String, parent: &ExpressionParent) {
     use ExpressionParent as EP;
     *target = match parent {
         EP::None => String::from("None"),
         EP::Memory(id) => format!("MemoryStmt({})", id.0.0.index),
         EP::If(id) => format!("IfStmt({})", id.0.index),
         EP::While(id) => format!("WhileStmt({})", id.0.index),
         EP::Return(id) => format!("ReturnStmt({})", id.0.index),
         EP::Assert(id) => format!("AssertStmt({})", id.0.index),
         EP::New(id) => format!("NewStmt({})", id.0.index),
         EP::ExpressionStmt(id) => format!("ExprStmt({})", id.0.index),
         EP::Expression(id, idx) => format!("Expr({}, {})", id.index, idx)
     };
+}
@@ \ No newline at end of file @@

src/protocol/eval.rs

➞

Show inline comments

 use std::collections::HashMap;
 use std::fmt;
 use std::fmt::{Debug, Display, Formatter};
 use std::{i16, i32, i64, i8};
 use crate::common::*;
 use crate::protocol::ast::*;
 use crate::protocol::EvalContext;
 // const MAX_RECURSION: usize = 1024;
 const BYTE_MIN: i64 = i8::MIN as i64;
 const BYTE_MAX: i64 = i8::MAX as i64;
 const SHORT_MIN: i64 = i16::MIN as i64;
 const SHORT_MAX: i64 = i16::MAX as i64;
 const INT_MIN: i64 = i32::MIN as i64;
 const INT_MAX: i64 = i32::MAX as i64;
 const MESSAGE_MAX_LENGTH: i64 = SHORT_MAX;
 const ONE: Value = Value::Byte(ByteValue(1));
 // TODO: All goes one day anyway, so dirty typechecking hack
 trait ValueImpl {
     fn exact_type(&self) -> Type;
     fn is_type_compatible(&self, h: &Heap, t: &ParserType) -> bool {
         Self::is_type_compatible_hack(h, t)
+    }
     fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool;
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Value {
     Input(InputValue),
     Output(OutputValue),
     Message(MessageValue),
     Boolean(BooleanValue),
     Byte(ByteValue),
     Short(ShortValue),
     Int(IntValue),
     Long(LongValue),
     InputArray(InputArrayValue),
     OutputArray(OutputArrayValue),
     MessageArray(MessageArrayValue),
     BooleanArray(BooleanArrayValue),
     ByteArray(ByteArrayValue),
     ShortArray(ShortArrayValue),
     IntArray(IntArrayValue),
     LongArray(LongArrayValue),
+}
 impl Value {
     pub fn receive_message(buffer: &Payload) -> Value {
         Value::Message(MessageValue(Some(buffer.clone())))
+    }
     fn create_message(length: Value) -> Value {
         match length {
             Value::Byte(_) | Value::Short(_) | Value::Int(_) | Value::Long(_) => {
                 let length: i64 = i64::from(length);
                 if length < 0 || length > MESSAGE_MAX_LENGTH {
                     // Only messages within the expected length are allowed
                     Value::Message(MessageValue(None))
                 } else {
                     Value::Message(MessageValue(Some(Payload::new(length as usize))))
+                }
+            }
             _ => unimplemented!(),
+        }
+    }
     fn from_constant(constant: &Constant) -> Value {
         match constant {
             Constant::Null => Value::Message(MessageValue(None)),
             Constant::True => Value::Boolean(BooleanValue(true)),
             Constant::False => Value::Boolean(BooleanValue(false)),
             Constant::Integer(val) => {
                 // Convert raw ASCII data to UTF-8 string
                 let val = *val;
                 if val >= BYTE_MIN && val <= BYTE_MAX {
                     Value::Byte(ByteValue(val as i8))
                 } else if val >= SHORT_MIN && val <= SHORT_MAX {
                     Value::Short(ShortValue(val as i16))
                 } else if val >= INT_MIN && val <= INT_MAX {
                     Value::Int(IntValue(val as i32))
                 } else {
                     Value::Long(LongValue(val))
+                }
+            }
             Constant::Character(_data) => unimplemented!(),
+        }
+    }
     fn set(&mut self, index: &Value, value: &Value) -> Option<Value> {
         // The index must be of integer type, and non-negative
         let the_index: usize;
         match index {
             Value::Byte(_) | Value::Short(_) | Value::Int(_) | Value::Long(_) => {
                 let index = i64::from(index);
                 if index < 0 || index >= MESSAGE_MAX_LENGTH {
                     // It is inconsistent to update out of bounds
                     return None;
+                }
                 the_index = index.try_into().unwrap();
+            }
             _ => unreachable!(),
+        }
         // The subject must be either a message or an array
         // And the value and the subject must be compatible
         match (self, value) {
             (Value::Message(MessageValue(None)), _) => {
                 // It is inconsistent to update the null message
                 None
+            }
             (Value::Message(MessageValue(Some(payload))), Value::Byte(ByteValue(b))) => {
                 if *b < 0 {
                     // It is inconsistent to update with a negative value
                     return None;
+                }
                 if let Some(slot) = payload.as_mut_vec().get_mut(the_index) {
                     *slot = (*b).try_into().unwrap();
                     Some(value.clone())
                 } else {
                     // It is inconsistent to update out of bounds
                     None
+                }
+            }
             (Value::Message(MessageValue(Some(payload))), Value::Short(ShortValue(b))) => {
                 if *b < 0 || *b > BYTE_MAX as i16 {
                     // It is inconsistent to update with a negative value or a too large value
                     return None;
+                }
                 if let Some(slot) = payload.as_mut_vec().get_mut(the_index) {
                     *slot = (*b).try_into().unwrap();
                     Some(value.clone())
                 } else {
                     // It is inconsistent to update out of bounds
                     None
+                }
+            }
             (Value::InputArray(_), Value::Input(_)) => todo!(),
             (Value::OutputArray(_), Value::Output(_)) => todo!(),
             (Value::MessageArray(_), Value::Message(_)) => todo!(),
             (Value::BooleanArray(_), Value::Boolean(_)) => todo!(),
             (Value::ByteArray(_), Value::Byte(_)) => todo!(),
             (Value::ShortArray(_), Value::Short(_)) => todo!(),
             (Value::IntArray(_), Value::Int(_)) => todo!(),
             (Value::LongArray(_), Value::Long(_)) => todo!(),
             _ => unreachable!(),
+        }
+    }
     fn get(&self, index: &Value) -> Option<Value> {
         // The index must be of integer type, and non-negative
         let the_index: usize;
         match index {
             Value::Byte(_) | Value::Short(_) | Value::Int(_) | Value::Long(_) => {
                 let index = i64::from(index);
                 if index < 0 || index >= MESSAGE_MAX_LENGTH {
                     // It is inconsistent to update out of bounds
                     return None;
+                }
                 the_index = index.try_into().unwrap();
+            }
             _ => unreachable!(),
+        }
         // The subject must be either a message or an array
         match self {
             Value::Message(MessageValue(None)) => {
                 // It is inconsistent to read from the null message
                 None
+            }
             Value::Message(MessageValue(Some(payload))) => {
                 if let Some(slot) = payload.as_slice().get(the_index) {
                     Some(Value::Short(ShortValue((*slot).try_into().unwrap())))
                 } else {
                     // It is inconsistent to update out of bounds
                     None
+                }
+            }
             _ => panic!("Can only get from port value"),
+        }
+    }
     fn length(&self) -> Option<Value> {
         // The subject must be either a message or an array
         match self {
             Value::Message(MessageValue(None)) => {
                 // It is inconsistent to get length from the null message
                 None
+            }
             Value::Message(MessageValue(Some(buffer))) => {
                 Some(Value::Int(IntValue((buffer.len()).try_into().unwrap())))
+            }
             Value::InputArray(InputArrayValue(vec)) => {
                 Some(Value::Int(IntValue((vec.len()).try_into().unwrap())))
+            }
             Value::OutputArray(OutputArrayValue(vec)) => {
                 Some(Value::Int(IntValue((vec.len()).try_into().unwrap())))
+            }
             Value::MessageArray(MessageArrayValue(vec)) => {
                 Some(Value::Int(IntValue((vec.len()).try_into().unwrap())))
+            }
             Value::BooleanArray(BooleanArrayValue(vec)) => {
                 Some(Value::Int(IntValue((vec.len()).try_into().unwrap())))
+            }
             Value::ByteArray(ByteArrayValue(vec)) => {
                 Some(Value::Int(IntValue((vec.len()).try_into().unwrap())))
+            }
             Value::ShortArray(ShortArrayValue(vec)) => {
                 Some(Value::Int(IntValue((vec.len()).try_into().unwrap())))
+            }
             Value::IntArray(IntArrayValue(vec)) => {
                 Some(Value::Int(IntValue((vec.len()).try_into().unwrap())))
+            }
             Value::LongArray(LongArrayValue(vec)) => {
                 Some(Value::Int(IntValue((vec.len()).try_into().unwrap())))
+            }
             _ => unreachable!(),
+        }
+    }
     fn plus(&self, other: &Value) -> Value {
         match (self, other) {
             (Value::Byte(ByteValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Byte(ByteValue(*s + *o))
+            }
             (Value::Byte(ByteValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Short(ShortValue(*s as i16 + *o))
+            }
             (Value::Byte(ByteValue(s)), Value::Int(IntValue(o))) => {
                 Value::Int(IntValue(*s as i32 + *o))
+            }
             (Value::Byte(ByteValue(s)), Value::Long(LongValue(o))) => {
                 Value::Long(LongValue(*s as i64 + *o))
+            }
             (Value::Short(ShortValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Short(ShortValue(*s + *o as i16))
+            }
             (Value::Short(ShortValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Short(ShortValue(*s + *o))
+            }
             (Value::Short(ShortValue(s)), Value::Int(IntValue(o))) => {
                 Value::Int(IntValue(*s as i32 + *o))
+            }
             (Value::Short(ShortValue(s)), Value::Long(LongValue(o))) => {
                 Value::Long(LongValue(*s as i64 + *o))
+            }
             (Value::Int(IntValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Int(IntValue(*s + *o as i32))
+            }
             (Value::Int(IntValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Int(IntValue(*s + *o as i32))
+            }
             (Value::Int(IntValue(s)), Value::Int(IntValue(o))) => Value::Int(IntValue(*s + *o)),
             (Value::Int(IntValue(s)), Value::Long(LongValue(o))) => {
                 Value::Long(LongValue(*s as i64 + *o))
+            }
             (Value::Long(LongValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Long(LongValue(*s + *o as i64))
+            }
             (Value::Long(LongValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Long(LongValue(*s + *o as i64))
+            }
             (Value::Long(LongValue(s)), Value::Int(IntValue(o))) => {
                 Value::Long(LongValue(*s + *o as i64))
+            }
             (Value::Long(LongValue(s)), Value::Long(LongValue(o))) => {
                 Value::Long(LongValue(*s + *o))
+            }
             (Value::Message(MessageValue(s)), Value::Message(MessageValue(o))) => {
                 let payload = if let [Some(s), Some(o)] = [s, o] {
                     let mut payload = s.clone();
                     payload.concatenate_with(o);
                     Some(payload)
                 } else {
                     None
                 };
                 Value::Message(MessageValue(payload))
+            }
             _ => unimplemented!(),
+        }
+    }
     fn minus(&self, other: &Value) -> Value {
         match (self, other) {
             (Value::Byte(ByteValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Byte(ByteValue(*s - *o))
+            }
             (Value::Byte(ByteValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Short(ShortValue(*s as i16 - *o))
+            }
             (Value::Byte(ByteValue(s)), Value::Int(IntValue(o))) => {
                 Value::Int(IntValue(*s as i32 - *o))
+            }
             (Value::Byte(ByteValue(s)), Value::Long(LongValue(o))) => {
                 Value::Long(LongValue(*s as i64 - *o))
+            }
             (Value::Short(ShortValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Short(ShortValue(*s - *o as i16))
+            }
             (Value::Short(ShortValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Short(ShortValue(*s - *o))
+            }
             (Value::Short(ShortValue(s)), Value::Int(IntValue(o))) => {
                 Value::Int(IntValue(*s as i32 - *o))
+            }
             (Value::Short(ShortValue(s)), Value::Long(LongValue(o))) => {
                 Value::Long(LongValue(*s as i64 - *o))
+            }
             (Value::Int(IntValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Int(IntValue(*s - *o as i32))
+            }
             (Value::Int(IntValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Int(IntValue(*s - *o as i32))
+            }
             (Value::Int(IntValue(s)), Value::Int(IntValue(o))) => Value::Int(IntValue(*s - *o)),
             (Value::Int(IntValue(s)), Value::Long(LongValue(o))) => {
                 Value::Long(LongValue(*s as i64 - *o))
+            }
             (Value::Long(LongValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Long(LongValue(*s - *o as i64))
+            }
             (Value::Long(LongValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Long(LongValue(*s - *o as i64))
+            }
             (Value::Long(LongValue(s)), Value::Int(IntValue(o))) => {
                 Value::Long(LongValue(*s - *o as i64))
+            }
             (Value::Long(LongValue(s)), Value::Long(LongValue(o))) => {
                 Value::Long(LongValue(*s - *o))
+            }
             _ => unimplemented!(),
+        }
+    }
     fn modulus(&self, other: &Value) -> Value {
         match (self, other) {
             (Value::Byte(ByteValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Byte(ByteValue(*s % *o))
+            }
             (Value::Byte(ByteValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Short(ShortValue(*s as i16 % *o))
+            }
             (Value::Byte(ByteValue(s)), Value::Int(IntValue(o))) => {
                 Value::Int(IntValue(*s as i32 % *o))
+            }
             (Value::Byte(ByteValue(s)), Value::Long(LongValue(o))) => {
                 Value::Long(LongValue(*s as i64 % *o))
+            }
             (Value::Short(ShortValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Short(ShortValue(*s % *o as i16))
+            }
             (Value::Short(ShortValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Short(ShortValue(*s % *o))
+            }
             (Value::Short(ShortValue(s)), Value::Int(IntValue(o))) => {
                 Value::Int(IntValue(*s as i32 % *o))
+            }
             (Value::Short(ShortValue(s)), Value::Long(LongValue(o))) => {
                 Value::Long(LongValue(*s as i64 % *o))
+            }
             (Value::Int(IntValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Int(IntValue(*s % *o as i32))
+            }
             (Value::Int(IntValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Int(IntValue(*s % *o as i32))
+            }
             (Value::Int(IntValue(s)), Value::Int(IntValue(o))) => Value::Int(IntValue(*s % *o)),
             (Value::Int(IntValue(s)), Value::Long(LongValue(o))) => {
                 Value::Long(LongValue(*s as i64 % *o))
+            }
             (Value::Long(LongValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Long(LongValue(*s % *o as i64))
+            }
             (Value::Long(LongValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Long(LongValue(*s % *o as i64))
+            }
             (Value::Long(LongValue(s)), Value::Int(IntValue(o))) => {
                 Value::Long(LongValue(*s % *o as i64))
+            }
             (Value::Long(LongValue(s)), Value::Long(LongValue(o))) => {
                 Value::Long(LongValue(*s % *o))
+            }
             _ => unimplemented!(),
+        }
+    }
     fn eq(&self, other: &Value) -> Value {
         match (self, other) {
             (Value::Byte(ByteValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Boolean(BooleanValue(*s == *o))
+            }
             (Value::Byte(ByteValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Boolean(BooleanValue(*s as i16 == *o))
+            }
             (Value::Byte(ByteValue(s)), Value::Int(IntValue(o))) => {
                 Value::Boolean(BooleanValue(*s as i32 == *o))
+            }
             (Value::Byte(ByteValue(s)), Value::Long(LongValue(o))) => {
                 Value::Boolean(BooleanValue(*s as i64 == *o))
+            }
             (Value::Short(ShortValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Boolean(BooleanValue(*s == *o as i16))
+            }
             (Value::Short(ShortValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Boolean(BooleanValue(*s == *o))
+            }
             (Value::Short(ShortValue(s)), Value::Int(IntValue(o))) => {
                 Value::Boolean(BooleanValue(*s as i32 == *o))
+            }
             (Value::Short(ShortValue(s)), Value::Long(LongValue(o))) => {
                 Value::Boolean(BooleanValue(*s as i64 == *o))
+            }
             (Value::Int(IntValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Boolean(BooleanValue(*s == *o as i32))
+            }
             (Value::Int(IntValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Boolean(BooleanValue(*s == *o as i32))
+            }
             (Value::Int(IntValue(s)), Value::Int(IntValue(o))) => {
                 Value::Boolean(BooleanValue(*s == *o))
+            }
             (Value::Int(IntValue(s)), Value::Long(LongValue(o))) => {
                 Value::Boolean(BooleanValue(*s as i64 == *o))
+            }
             (Value::Long(LongValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Boolean(BooleanValue(*s == *o as i64))
+            }
             (Value::Long(LongValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Boolean(BooleanValue(*s == *o as i64))
+            }
             (Value::Long(LongValue(s)), Value::Int(IntValue(o))) => {
                 Value::Boolean(BooleanValue(*s == *o as i64))
+            }
             (Value::Long(LongValue(s)), Value::Long(LongValue(o))) => {
                 Value::Boolean(BooleanValue(*s == *o))
+            }
             (Value::Message(MessageValue(s)), Value::Message(MessageValue(o))) => {
                 Value::Boolean(BooleanValue(*s == *o))
+            }
             _ => unimplemented!(),
+        }
+    }
     fn neq(&self, other: &Value) -> Value {
         match (self, other) {
             (Value::Byte(ByteValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Boolean(BooleanValue(*s != *o))
+            }
             (Value::Byte(ByteValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Boolean(BooleanValue(*s as i16 != *o))
+            }
             (Value::Byte(ByteValue(s)), Value::Int(IntValue(o))) => {
                 Value::Boolean(BooleanValue(*s as i32 != *o))
+            }
             (Value::Byte(ByteValue(s)), Value::Long(LongValue(o))) => {
                 Value::Boolean(BooleanValue(*s as i64 != *o))
+            }
             (Value::Short(ShortValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Boolean(BooleanValue(*s != *o as i16))
+            }
             (Value::Short(ShortValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Boolean(BooleanValue(*s != *o))
+            }
             (Value::Short(ShortValue(s)), Value::Int(IntValue(o))) => {
                 Value::Boolean(BooleanValue(*s as i32 != *o))
+            }
             (Value::Short(ShortValue(s)), Value::Long(LongValue(o))) => {
                 Value::Boolean(BooleanValue(*s as i64 != *o))
+            }
             (Value::Int(IntValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Boolean(BooleanValue(*s != *o as i32))
+            }
             (Value::Int(IntValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Boolean(BooleanValue(*s != *o as i32))
+            }
             (Value::Int(IntValue(s)), Value::Int(IntValue(o))) => {
                 Value::Boolean(BooleanValue(*s != *o))
+            }
             (Value::Int(IntValue(s)), Value::Long(LongValue(o))) => {
                 Value::Boolean(BooleanValue(*s as i64 != *o))
+            }
             (Value::Long(LongValue(s)), Value::Byte(ByteValue(o))) => {
                 Value::Boolean(BooleanValue(*s != *o as i64))
+            }
             (Value::Long(LongValue(s)), Value::Short(ShortValue(o))) => {
                 Value::Boolean(BooleanValue(*s != *o as i64))
+            }
             (Value::Long(LongValue(s)), Value::Int(IntValue(o))) => {
                 Value::Boolean(BooleanValue(*s != *o as i64))
+            }
             (Value::Long(LongValue(s)), Value::Long(LongValue(o))) => {
                 Value::Boolean(BooleanValue(*s != *o))
+            }
             (Value::Message(MessageValue(s)), Value::Message(MessageValue(o))) => {
                 Value::Boolean(BooleanValue(*s != *o))
+            }
             _ => unimplemented!(),
+        }
+    }
     fn lt(&self, other: &Value) -> Value {
         // TODO: match value directly (as done above)
         assert!(!self.exact_type().array);
         assert!(!other.exact_type().array);
         match (self.exact_type().primitive, other.exact_type().primitive) {
             (PrimitiveType::Byte, PrimitiveType::Byte) => {
                 Value::Boolean(BooleanValue(i8::from(self) < i8::from(other)))
+            }
             (PrimitiveType::Byte, PrimitiveType::Short) => {
                 Value::Boolean(BooleanValue(i16::from(self) < i16::from(other)))
+            }
             (PrimitiveType::Byte, PrimitiveType::Int) => {
                 Value::Boolean(BooleanValue(i32::from(self) < i32::from(other)))
+            }
             (PrimitiveType::Byte, PrimitiveType::Long) => {
                 Value::Boolean(BooleanValue(i64::from(self) < i64::from(other)))
+            }
             (PrimitiveType::Short, PrimitiveType::Byte) => {
                 Value::Boolean(BooleanValue(i16::from(self) < i16::from(other)))
+            }
             (PrimitiveType::Short, PrimitiveType::Short) => {
                 Value::Boolean(BooleanValue(i16::from(self) < i16::from(other)))
+            }
             (PrimitiveType::Short, PrimitiveType::Int) => {
                 Value::Boolean(BooleanValue(i32::from(self) < i32::from(other)))
+            }
             (PrimitiveType::Short, PrimitiveType::Long) => {
                 Value::Boolean(BooleanValue(i64::from(self) < i64::from(other)))
+            }
             (PrimitiveType::Int, PrimitiveType::Byte) => {
                 Value::Boolean(BooleanValue(i32::from(self) < i32::from(other)))
+            }
             (PrimitiveType::Int, PrimitiveType::Short) => {
                 Value::Boolean(BooleanValue(i32::from(self) < i32::from(other)))
+            }
             (PrimitiveType::Int, PrimitiveType::Int) => {
                 Value::Boolean(BooleanValue(i32::from(self) < i32::from(other)))
+            }
             (PrimitiveType::Int, PrimitiveType::Long) => {
                 Value::Boolean(BooleanValue(i64::from(self) < i64::from(other)))
+            }
             (PrimitiveType::Long, PrimitiveType::Byte) => {
                 Value::Boolean(BooleanValue(i64::from(self) < i64::from(other)))
+            }
             (PrimitiveType::Long, PrimitiveType::Short) => {
                 Value::Boolean(BooleanValue(i64::from(self) < i64::from(other)))
+            }
             (PrimitiveType::Long, PrimitiveType::Int) => {
                 Value::Boolean(BooleanValue(i64::from(self) < i64::from(other)))
+            }
             (PrimitiveType::Long, PrimitiveType::Long) => {
                 Value::Boolean(BooleanValue(i64::from(self) < i64::from(other)))
+            }
             _ => unimplemented!(),
+        }
+    }
     fn lte(&self, other: &Value) -> Value {
         assert!(!self.exact_type().array);
         assert!(!other.exact_type().array);
         match (self.exact_type().primitive, other.exact_type().primitive) {
             (PrimitiveType::Byte, PrimitiveType::Byte) => {
                 Value::Boolean(BooleanValue(i8::from(self) <= i8::from(other)))
+            }
             (PrimitiveType::Byte, PrimitiveType::Short) => {
                 Value::Boolean(BooleanValue(i16::from(self) <= i16::from(other)))
+            }
             (PrimitiveType::Byte, PrimitiveType::Int) => {
                 Value::Boolean(BooleanValue(i32::from(self) <= i32::from(other)))
+            }
             (PrimitiveType::Byte, PrimitiveType::Long) => {
                 Value::Boolean(BooleanValue(i64::from(self) <= i64::from(other)))
+            }
             (PrimitiveType::Short, PrimitiveType::Byte) => {
                 Value::Boolean(BooleanValue(i16::from(self) <= i16::from(other)))
+            }
             (PrimitiveType::Short, PrimitiveType::Short) => {
                 Value::Boolean(BooleanValue(i16::from(self) <= i16::from(other)))
+            }
             (PrimitiveType::Short, PrimitiveType::Int) => {
                 Value::Boolean(BooleanValue(i32::from(self) <= i32::from(other)))
+            }
             (PrimitiveType::Short, PrimitiveType::Long) => {
                 Value::Boolean(BooleanValue(i64::from(self) <= i64::from(other)))
+            }
             (PrimitiveType::Int, PrimitiveType::Byte) => {
                 Value::Boolean(BooleanValue(i32::from(self) <= i32::from(other)))
+            }
             (PrimitiveType::Int, PrimitiveType::Short) => {
                 Value::Boolean(BooleanValue(i32::from(self) <= i32::from(other)))
+            }
             (PrimitiveType::Int, PrimitiveType::Int) => {
                 Value::Boolean(BooleanValue(i32::from(self) <= i32::from(other)))
+            }
             (PrimitiveType::Int, PrimitiveType::Long) => {
                 Value::Boolean(BooleanValue(i64::from(self) <= i64::from(other)))
+            }
             (PrimitiveType::Long, PrimitiveType::Byte) => {
                 Value::Boolean(BooleanValue(i64::from(self) <= i64::from(other)))
+            }
             (PrimitiveType::Long, PrimitiveType::Short) => {
                 Value::Boolean(BooleanValue(i64::from(self) <= i64::from(other)))
+            }
             (PrimitiveType::Long, PrimitiveType::Int) => {
                 Value::Boolean(BooleanValue(i64::from(self) <= i64::from(other)))
+            }
             (PrimitiveType::Long, PrimitiveType::Long) => {
                 Value::Boolean(BooleanValue(i64::from(self) <= i64::from(other)))
+            }
             _ => unimplemented!(),
+        }
+    }
     fn gt(&self, other: &Value) -> Value {
         assert!(!self.exact_type().array);
         assert!(!other.exact_type().array);
         match (self.exact_type().primitive, other.exact_type().primitive) {
             (PrimitiveType::Byte, PrimitiveType::Byte) => {
                 Value::Boolean(BooleanValue(i8::from(self) > i8::from(other)))
+            }
             (PrimitiveType::Byte, PrimitiveType::Short) => {
                 Value::Boolean(BooleanValue(i16::from(self) > i16::from(other)))
+            }
             (PrimitiveType::Byte, PrimitiveType::Int) => {
                 Value::Boolean(BooleanValue(i32::from(self) > i32::from(other)))
+            }
             (PrimitiveType::Byte, PrimitiveType::Long) => {
                 Value::Boolean(BooleanValue(i64::from(self) > i64::from(other)))
+            }
             (PrimitiveType::Short, PrimitiveType::Byte) => {
                 Value::Boolean(BooleanValue(i16::from(self) > i16::from(other)))
+            }
             (PrimitiveType::Short, PrimitiveType::Short) => {
                 Value::Boolean(BooleanValue(i16::from(self) > i16::from(other)))
+            }
             (PrimitiveType::Short, PrimitiveType::Int) => {
                 Value::Boolean(BooleanValue(i32::from(self) > i32::from(other)))
+            }
             (PrimitiveType::Short, PrimitiveType::Long) => {
                 Value::Boolean(BooleanValue(i64::from(self) > i64::from(other)))
+            }
             (PrimitiveType::Int, PrimitiveType::Byte) => {
                 Value::Boolean(BooleanValue(i32::from(self) > i32::from(other)))
+            }
             (PrimitiveType::Int, PrimitiveType::Short) => {
                 Value::Boolean(BooleanValue(i32::from(self) > i32::from(other)))
+            }
             (PrimitiveType::Int, PrimitiveType::Int) => {
                 Value::Boolean(BooleanValue(i32::from(self) > i32::from(other)))
+            }
             (PrimitiveType::Int, PrimitiveType::Long) => {
                 Value::Boolean(BooleanValue(i64::from(self) > i64::from(other)))
+            }
             (PrimitiveType::Long, PrimitiveType::Byte) => {
                 Value::Boolean(BooleanValue(i64::from(self) > i64::from(other)))
+            }
             (PrimitiveType::Long, PrimitiveType::Short) => {
                 Value::Boolean(BooleanValue(i64::from(self) > i64::from(other)))
+            }
             (PrimitiveType::Long, PrimitiveType::Int) => {
                 Value::Boolean(BooleanValue(i64::from(self) > i64::from(other)))
+            }
             (PrimitiveType::Long, PrimitiveType::Long) => {
                 Value::Boolean(BooleanValue(i64::from(self) > i64::from(other)))
+            }
             _ => unimplemented!(),
+        }
+    }
     fn gte(&self, other: &Value) -> Value {
         assert!(!self.exact_type().array);
         assert!(!other.exact_type().array);
         match (self.exact_type().primitive, other.exact_type().primitive) {
             (PrimitiveType::Byte, PrimitiveType::Byte) => {
                 Value::Boolean(BooleanValue(i8::from(self) >= i8::from(other)))
+            }
             (PrimitiveType::Byte, PrimitiveType::Short) => {
                 Value::Boolean(BooleanValue(i16::from(self) >= i16::from(other)))
+            }
             (PrimitiveType::Byte, PrimitiveType::Int) => {
                 Value::Boolean(BooleanValue(i32::from(self) >= i32::from(other)))
+            }
             (PrimitiveType::Byte, PrimitiveType::Long) => {
                 Value::Boolean(BooleanValue(i64::from(self) >= i64::from(other)))
+            }
             (PrimitiveType::Short, PrimitiveType::Byte) => {
                 Value::Boolean(BooleanValue(i16::from(self) >= i16::from(other)))
+            }
             (PrimitiveType::Short, PrimitiveType::Short) => {
                 Value::Boolean(BooleanValue(i16::from(self) >= i16::from(other)))
+            }
             (PrimitiveType::Short, PrimitiveType::Int) => {
                 Value::Boolean(BooleanValue(i32::from(self) >= i32::from(other)))
+            }
             (PrimitiveType::Short, PrimitiveType::Long) => {
                 Value::Boolean(BooleanValue(i64::from(self) >= i64::from(other)))
+            }
             (PrimitiveType::Int, PrimitiveType::Byte) => {
                 Value::Boolean(BooleanValue(i32::from(self) >= i32::from(other)))
+            }
             (PrimitiveType::Int, PrimitiveType::Short) => {
                 Value::Boolean(BooleanValue(i32::from(self) >= i32::from(other)))
+            }
             (PrimitiveType::Int, PrimitiveType::Int) => {
                 Value::Boolean(BooleanValue(i32::from(self) >= i32::from(other)))
+            }
             (PrimitiveType::Int, PrimitiveType::Long) => {
                 Value::Boolean(BooleanValue(i64::from(self) >= i64::from(other)))
+            }
             (PrimitiveType::Long, PrimitiveType::Byte) => {
                 Value::Boolean(BooleanValue(i64::from(self) >= i64::from(other)))
+            }
             (PrimitiveType::Long, PrimitiveType::Short) => {
                 Value::Boolean(BooleanValue(i64::from(self) >= i64::from(other)))
+            }
             (PrimitiveType::Long, PrimitiveType::Int) => {
                 Value::Boolean(BooleanValue(i64::from(self) >= i64::from(other)))
+            }
             (PrimitiveType::Long, PrimitiveType::Long) => {
                 Value::Boolean(BooleanValue(i64::from(self) >= i64::from(other)))
+            }
             _ => unimplemented!(),
+        }
+    }
     fn as_boolean(&self) -> &BooleanValue {
         match self {
             Value::Boolean(result) => result,
             _ => panic!("Unable to cast `Value` to `BooleanValue`"),
+        }
+    }
+}
 impl From<bool> for Value {
     fn from(b: bool) -> Self {
         Value::Boolean(BooleanValue(b))
+    }
+}
 impl From<Value> for bool {
     fn from(val: Value) -> Self {
         match val {
             Value::Boolean(BooleanValue(b)) => b,
             _ => unimplemented!(),
+        }
+    }
+}
 impl From<&Value> for bool {
     fn from(val: &Value) -> Self {
         match val {
             Value::Boolean(BooleanValue(b)) => *b,
             _ => unimplemented!(),
+        }
+    }
+}
 impl From<Value> for i8 {
     fn from(val: Value) -> Self {
         match val {
             Value::Byte(ByteValue(b)) => b,
             _ => unimplemented!(),
+        }
+    }
+}
 impl From<&Value> for i8 {
     fn from(val: &Value) -> Self {
         match val {
             Value::Byte(ByteValue(b)) => *b,
             _ => unimplemented!(),
+        }
+    }
+}
 impl From<Value> for i16 {
     fn from(val: Value) -> Self {
         match val {
             Value::Byte(ByteValue(b)) => i16::from(b),
             Value::Short(ShortValue(s)) => s,
             _ => unimplemented!(),
+        }
+    }
+}
 impl From<&Value> for i16 {
     fn from(val: &Value) -> Self {
         match val {
             Value::Byte(ByteValue(b)) => i16::from(*b),
             Value::Short(ShortValue(s)) => *s,
             _ => unimplemented!(),
+        }
+    }
+}
 impl From<Value> for i32 {
     fn from(val: Value) -> Self {
         match val {
             Value::Byte(ByteValue(b)) => i32::from(b),
             Value::Short(ShortValue(s)) => i32::from(s),
             Value::Int(IntValue(i)) => i,
             _ => unimplemented!(),
+        }
+    }
+}
 impl From<&Value> for i32 {
     fn from(val: &Value) -> Self {
         match val {
             Value::Byte(ByteValue(b)) => i32::from(*b),
             Value::Short(ShortValue(s)) => i32::from(*s),
             Value::Int(IntValue(i)) => *i,
             _ => unimplemented!(),
+        }
+    }
+}
 impl From<Value> for i64 {
     fn from(val: Value) -> Self {
         match val {
             Value::Byte(ByteValue(b)) => i64::from(b),
             Value::Short(ShortValue(s)) => i64::from(s),
             Value::Int(IntValue(i)) => i64::from(i),
             Value::Long(LongValue(l)) => l,
             _ => unimplemented!(),
+        }
+    }
+}
 impl From<&Value> for i64 {
     fn from(val: &Value) -> Self {
         match val {
             Value::Byte(ByteValue(b)) => i64::from(*b),
             Value::Short(ShortValue(s)) => i64::from(*s),
             Value::Int(IntValue(i)) => i64::from(*i),
             Value::Long(LongValue(l)) => *l,
             _ => unimplemented!(),
+        }
+    }
+}
 impl ValueImpl for Value {
     fn exact_type(&self) -> Type {
         match self {
             Value::Input(val) => val.exact_type(),
             Value::Output(val) => val.exact_type(),
             Value::Message(val) => val.exact_type(),
             Value::Boolean(val) => val.exact_type(),
             Value::Byte(val) => val.exact_type(),
             Value::Short(val) => val.exact_type(),
             Value::Int(val) => val.exact_type(),
             Value::Long(val) => val.exact_type(),
             Value::InputArray(val) => val.exact_type(),
             Value::OutputArray(val) => val.exact_type(),
             Value::MessageArray(val) => val.exact_type(),
             Value::BooleanArray(val) => val.exact_type(),
             Value::ByteArray(val) => val.exact_type(),
             Value::ShortArray(val) => val.exact_type(),
             Value::IntArray(val) => val.exact_type(),
             Value::LongArray(val) => val.exact_type(),
+        }
+    }
     fn is_type_compatible(&self, h: &Heap, t: &ParserType) -> bool {
         match self {
             Value::Input(_) => InputValue::is_type_compatible_hack(h, t),
             Value::Output(_) => OutputValue::is_type_compatible_hack(h, t),
             Value::Message(_) => MessageValue::is_type_compatible_hack(h, t),
             Value::Boolean(_) => BooleanValue::is_type_compatible_hack(h, t),
             Value::Byte(_) => ByteValue::is_type_compatible_hack(h, t),
             Value::Short(_) => ShortValue::is_type_compatible_hack(h, t),
             Value::Int(_) => IntValue::is_type_compatible_hack(h, t),
             Value::Long(_) => LongValue::is_type_compatible_hack(h, t),
             Value::InputArray(_) => InputArrayValue::is_type_compatible_hack(h, t),
             Value::OutputArray(_) => OutputArrayValue::is_type_compatible_hack(h, t),
             Value::MessageArray(_) => MessageArrayValue::is_type_compatible_hack(h, t),
             Value::BooleanArray(_) => BooleanArrayValue::is_type_compatible_hack(h, t),
             Value::ByteArray(_) => ByteArrayValue::is_type_compatible_hack(h, t),
             Value::ShortArray(_) => ShortArrayValue::is_type_compatible_hack(h, t),
             Value::IntArray(_) => InputArrayValue::is_type_compatible_hack(h, t),
             Value::LongArray(_) => LongArrayValue::is_type_compatible_hack(h, t),
+        }
+    }
     fn is_type_compatible_hack(_h: &Heap, _t: &ParserType) -> bool { false }
+}
 impl Display for Value {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         let disp: &dyn Display;
         match self {
             Value::Input(val) => disp = val,
             Value::Output(val) => disp = val,
             Value::Message(val) => disp = val,
             Value::Boolean(val) => disp = val,
             Value::Byte(val) => disp = val,
             Value::Short(val) => disp = val,
             Value::Int(val) => disp = val,
             Value::Long(val) => disp = val,
             Value::InputArray(val) => disp = val,
             Value::OutputArray(val) => disp = val,
             Value::MessageArray(val) => disp = val,
             Value::BooleanArray(val) => disp = val,
             Value::ByteArray(val) => disp = val,
             Value::ShortArray(val) => disp = val,
             Value::IntArray(val) => disp = val,
             Value::LongArray(val) => disp = val,
+        }
         disp.fmt(f)
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct InputValue(pub PortId);
 impl Display for InputValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "#in")
+    }
+}
 impl ValueImpl for InputValue {
     fn exact_type(&self) -> Type {
         Type::INPUT
+    }
     fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
         return if let ParserTypeVariant::Input(_) = t.variant { true } else { false }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct OutputValue(pub PortId);
 impl Display for OutputValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "#out")
+    }
+}
 impl ValueImpl for OutputValue {
     fn exact_type(&self) -> Type {
         Type::OUTPUT
+    }
     fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
         return if let ParserTypeVariant::Output(_) = t.variant { true } else { false }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct MessageValue(pub Option<Payload>);
 impl Display for MessageValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match &self.0 {
             None => write!(f, "null"),
             Some(payload) => {
                 // format print up to 10 bytes
                 let mut slice = payload.as_slice();
                 if slice.len() > 10 {
                     slice = &slice[..10];
+                }
                 f.debug_list().entries(slice.iter().copied()).finish()
+            }
+        }
+    }
+}
 impl ValueImpl for MessageValue {
     fn exact_type(&self) -> Type {
         Type::MESSAGE
+    }
     fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
         return if let ParserTypeVariant::Message = t.variant { true } else { false };
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct BooleanValue(bool);
 impl Display for BooleanValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
+    }
+}
 impl ValueImpl for BooleanValue {
     fn exact_type(&self) -> Type {
         Type::BOOLEAN
+    }
     fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
         use ParserTypeVariant::*;
         match t.variant {
             Bool | Byte | Short | Int | Long => true,
             _ => false
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ByteValue(i8);
 impl Display for ByteValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
+    }
+}
 impl ValueImpl for ByteValue {
     fn exact_type(&self) -> Type {
         Type::BYTE
+    }
     fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
         use ParserTypeVariant::*;
         match t.variant {
             Byte | Short | Int | Long => true,
             _ => false
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ShortValue(i16);
 impl Display for ShortValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
+    }
+}
 impl ValueImpl for ShortValue {
     fn exact_type(&self) -> Type {
         Type::SHORT
+    }
     fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
         use ParserTypeVariant::*;
         match t.variant {
             Short | Int | Long => true,
             _ => false
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct IntValue(i32);
 impl Display for IntValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
+    }
+}
 impl ValueImpl for IntValue {
     fn exact_type(&self) -> Type {
         Type::INT
+    }
     fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
         use ParserTypeVariant::*;
         match t.variant {
             Int | Long => true,
             _ => false
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct LongValue(i64);
 impl Display for LongValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.0)
+    }
+}
 impl ValueImpl for LongValue {
     fn exact_type(&self) -> Type {
         Type::LONG
+    }
     fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
         return if let ParserTypeVariant::Long = t.variant { true } else { false }
+    }
+}
 fn get_array_inner(t: &ParserType) -> Option<ParserTypeId> {
     match t.variant {
         ParserTypeVariant::Array(inner) => Some(inner),
         _ => None
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct InputArrayValue(Vec<InputValue>);
 impl Display for InputArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
                 write!(f, ",")?;
+            }
             write!(f, "{}", v)?;
             first = false;
+        }
         write!(f, "}}")
+    }
+}
 impl ValueImpl for InputArrayValue {
     fn exact_type(&self) -> Type {
         Type::INPUT_ARRAY
+    }
     fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool {
         get_array_inner(t)
             .map(|v| InputValue::is_type_compatible_hack(h, &h[v]))
             .unwrap_or(false)
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct OutputArrayValue(Vec<OutputValue>);
 impl Display for OutputArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
                 write!(f, ",")?;
+            }
             write!(f, "{}", v)?;
             first = false;
+        }
         write!(f, "}}")
+    }
+}
 impl ValueImpl for OutputArrayValue {
     fn exact_type(&self) -> Type {
         Type::OUTPUT_ARRAY
+    }
     fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool {
         get_array_inner(t)
             .map(|v| OutputValue::is_type_compatible_hack(h, &h[v]))
             .unwrap_or(false)
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct MessageArrayValue(Vec<MessageValue>);
 impl Display for MessageArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
                 write!(f, ",")?;
+            }
             write!(f, "{}", v)?;
             first = false;
+        }
         write!(f, "}}")
+    }
+}
 impl ValueImpl for MessageArrayValue {
     fn exact_type(&self) -> Type {
         Type::MESSAGE_ARRAY
+    }
     fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool {
         get_array_inner(t)
             .map(|v| MessageValue::is_type_compatible_hack(h, &h[v]))
             .unwrap_or(false)
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct BooleanArrayValue(Vec<BooleanValue>);
 impl Display for BooleanArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
                 write!(f, ",")?;
+            }
             write!(f, "{}", v)?;
             first = false;
+        }
         write!(f, "}}")
+    }
+}
 impl ValueImpl for BooleanArrayValue {
     fn exact_type(&self) -> Type {
         Type::BOOLEAN_ARRAY
+    }
     fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool {
         get_array_inner(t)
             .map(|v| BooleanValue::is_type_compatible_hack(h, &h[v]))
             .unwrap_or(false)
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ByteArrayValue(Vec<ByteValue>);
 impl Display for ByteArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
                 write!(f, ",")?;
+            }
             write!(f, "{}", v)?;
             first = false;
+        }
         write!(f, "}}")
+    }
+}
 impl ValueImpl for ByteArrayValue {
     fn exact_type(&self) -> Type {
         Type::BYTE_ARRAY
+    }
     fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool {
         get_array_inner(t)
             .map(|v| ByteValue::is_type_compatible_hack(h, &h[v]))
             .unwrap_or(false)
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ShortArrayValue(Vec<ShortValue>);
 impl Display for ShortArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
                 write!(f, ",")?;
+            }
             write!(f, "{}", v)?;
             first = false;
+        }
         write!(f, "}}")
+    }
+}
 impl ValueImpl for ShortArrayValue {
     fn exact_type(&self) -> Type {
         Type::SHORT_ARRAY
+    }
     fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool {
         get_array_inner(t)
             .map(|v| ShortValue::is_type_compatible_hack(h, &h[v]))
             .unwrap_or(false)
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct IntArrayValue(Vec<IntValue>);
 impl Display for IntArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
                 write!(f, ",")?;
+            }
             write!(f, "{}", v)?;
             first = false;
+        }
         write!(f, "}}")
+    }
+}
 impl ValueImpl for IntArrayValue {
     fn exact_type(&self) -> Type {
         Type::INT_ARRAY
+    }
     fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool {
         get_array_inner(t)
             .map(|v| IntValue::is_type_compatible_hack(h, &h[v]))
             .unwrap_or(false)
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct LongArrayValue(Vec<LongValue>);
 impl Display for LongArrayValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for v in self.0.iter() {
             if !first {
                 write!(f, ",")?;
+            }
             write!(f, "{}", v)?;
             first = false;
+        }
         write!(f, "}}")
+    }
+}
 impl ValueImpl for LongArrayValue {
     fn exact_type(&self) -> Type {
         Type::LONG_ARRAY
+    }
     fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool {
         get_array_inner(t)
             .map(|v| LongValue::is_type_compatible_hack(h, &h[v]))
             .unwrap_or(false)
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 struct Store {
     map: HashMap<VariableId, Value>,
+}
 impl Store {
     fn new() -> Self {
         Store { map: HashMap::new() }
+    }
     fn initialize(&mut self, h: &Heap, var: VariableId, value: Value) {
         // Ensure value is compatible with type of variable
         let parser_type = match &h[var] {
             Variable::Local(v) => v.parser_type,
             Variable::Parameter(v) => v.parser_type,
         };
         assert!(value.is_type_compatible(h, &h[parser_type]));
         // Overwrite mapping
         self.map.insert(var, value.clone());
+    }
     fn update(
         &mut self,
         h: &Heap,
         ctx: &mut EvalContext,
         lexpr: ExpressionId,
         value: Value,
     ) -> EvalResult {
         match &h[lexpr] {
             Expression::Variable(var) => {
                 let var = var.declaration.unwrap();
                 // Ensure value is compatible with type of variable
                 let parser_type_id = match &h[var] {
                     Variable::Local(v) => v.parser_type,
                     Variable::Parameter(v) => v.parser_type
                 };
                 let parser_type = &h[parser_type_id];
                 assert!(value.is_type_compatible(h, parser_type));
                 // Overwrite mapping
                 self.map.insert(var, value.clone());
                 Ok(value)
+            }
             Expression::Indexing(indexing) => {
                 // Evaluate index expression, which must be some integral type
                 let index = self.eval(h, ctx, indexing.index)?;
                 // Mutable reference to the subject
                 let subject;
                 match &h[indexing.subject] {
                     Expression::Variable(var) => {
                         let var = var.declaration.unwrap();
                         subject = self.map.get_mut(&var).unwrap();
+                    }
                     _ => unreachable!(),
+                }
                 match subject.set(&index, &value) {
                     Some(value) => Ok(value),
                     None => Err(EvalContinuation::Inconsistent),
+                }
+            }
             _ => unimplemented!("{:?}", h[lexpr]),
+        }
+    }
     fn get(&mut self, h: &Heap, ctx: &mut EvalContext, rexpr: ExpressionId) -> EvalResult {
         match &h[rexpr] {
             Expression::Variable(var) => {
                 let var_id = var.declaration.unwrap();
                 let value = self
                     .map
                     .get(&var_id)
                     .expect(&format!("Uninitialized variable {:?}", String::from_utf8_lossy(&var.identifier.value)));
                 Ok(value.clone())
+            }
             Expression::Indexing(indexing) => {
                 // Evaluate index expression, which must be some integral type
                 let index = self.eval(h, ctx, indexing.index)?;
                 // Reference to subject
                 let subject;
                 match &h[indexing.subject] {
                     Expression::Variable(var) => {
                         let var = var.declaration.unwrap();
                         subject = self.map.get(&var).unwrap();
+                    }
                     q => unreachable!("Reached {:?}", q),
+                }
                 match subject.get(&index) {
                     Some(value) => Ok(value),
                     None => Err(EvalContinuation::Inconsistent),
+                }
+            }
             Expression::Select(selecting) => {
                 // Reference to subject
                 let subject;
                 match &h[selecting.subject] {
                     Expression::Variable(var) => {
                         let var = var.declaration.unwrap();
                         subject = self.map.get(&var).unwrap();
+                    }
                     q => unreachable!("Reached {:?}", q),
+                }
                 match subject.length() {
                     Some(value) => Ok(value),
                     None => Err(EvalContinuation::Inconsistent),
+                }
+            }
             _ => unimplemented!("{:?}", h[rexpr]),
+        }
+    }
     fn eval(&mut self, h: &Heap, ctx: &mut EvalContext, expr: ExpressionId) -> EvalResult {
         match &h[expr] {
             Expression::Assignment(expr) => {
                 let value = self.eval(h, ctx, expr.right)?;
                 match expr.operation {
                     AssignmentOperator::Set => {
                         self.update(h, ctx, expr.left, value.clone())?;
+                    }
                     AssignmentOperator::Added => {
                         let old = self.get(h, ctx, expr.left)?;
                         self.update(h, ctx, expr.left, old.plus(&value))?;
+                    }
                     AssignmentOperator::Subtracted => {
                         let old = self.get(h, ctx, expr.left)?;
                         self.update(h, ctx, expr.left, old.minus(&value))?;
+                    }
                     _ => unimplemented!("{:?}", expr),
+                }
                 Ok(value)
+            }
             Expression::Conditional(expr) => {
                 let test = self.eval(h, ctx, expr.test)?;
                 if test.as_boolean().0 {
                     self.eval(h, ctx, expr.true_expression)
                 } else {
                     self.eval(h, ctx, expr.false_expression)
+                }
+            }
             Expression::Binary(expr) => {
                 let left = self.eval(h, ctx, expr.left)?;
                 let right;
                 match expr.operation {
                     BinaryOperator::LogicalAnd => {
                         if left.as_boolean().0 == false {
                             return Ok(left);
+                        }
                         right = self.eval(h, ctx, expr.right)?;
                         right.as_boolean(); // panics if not a boolean
                         return Ok(right);
+                    }
                     BinaryOperator::LogicalOr => {
                         if left.as_boolean().0 == true {
                             return Ok(left);
+                        }
                         right = self.eval(h, ctx, expr.right)?;
                         right.as_boolean(); // panics if not a boolean
                         return Ok(right);
+                    }
                     _ => {}
+                }
                 right = self.eval(h, ctx, expr.right)?;
                 match expr.operation {
                     BinaryOperator::Equality => Ok(left.eq(&right)),
                     BinaryOperator::Inequality => Ok(left.neq(&right)),
                     BinaryOperator::LessThan => Ok(left.lt(&right)),
                     BinaryOperator::LessThanEqual => Ok(left.lte(&right)),
                     BinaryOperator::GreaterThan => Ok(left.gt(&right)),
                     BinaryOperator::GreaterThanEqual => Ok(left.gte(&right)),
                     BinaryOperator::Remainder => Ok(left.modulus(&right)),
                     BinaryOperator::Add => Ok(left.plus(&right)),
                     _ => unimplemented!("{:?}", expr.operation),
+                }
+            }
             Expression::Unary(expr) => {
                 let mut value = self.eval(h, ctx, expr.expression)?;
                 match expr.operation {
                     UnaryOperation::PostIncrement => {
                         self.update(h, ctx, expr.expression, value.plus(&ONE))?;
+                    }
                     UnaryOperation::PreIncrement => {
                         value = value.plus(&ONE);
                         self.update(h, ctx, expr.expression, value.clone())?;
+                    }
                     UnaryOperation::PostDecrement => {
                         self.update(h, ctx, expr.expression, value.minus(&ONE))?;
+                    }
                     UnaryOperation::PreDecrement => {
                         value = value.minus(&ONE);
                         self.update(h, ctx, expr.expression, value.clone())?;
+                    }
                     _ => unimplemented!(),
+                }
                 Ok(value)
+            }
             Expression::Indexing(expr) => self.get(h, ctx, expr.this.upcast()),
             Expression::Slicing(_expr) => unimplemented!(),
             Expression::Select(expr) => self.get(h, ctx, expr.this.upcast()),
             Expression::Array(expr) => {
                 let mut elements = Vec::new();
                 for &elem in expr.elements.iter() {
                     elements.push(self.eval(h, ctx, elem)?);
+                }
                 todo!()
+            }
             Expression::Constant(expr) => Ok(Value::from_constant(&expr.value)),
             Expression::Call(expr) => match &expr.method {
                 Method::Get => {
                     assert_eq!(1, expr.arguments.len());
                     let value = self.eval(h, ctx, expr.arguments[0])?;
                     match ctx.get(value.clone()) {
                         None => Err(EvalContinuation::BlockGet(value)),
                         Some(result) => Ok(result),
+                    }
+                }
                 Method::Put => {
                     assert_eq!(2, expr.arguments.len());
                     let port_value = self.eval(h, ctx, expr.arguments[0])?;
                     let msg_value = self.eval(h, ctx, expr.arguments[1])?;
                     println!("DEBUG: Handiling put({:?}, {:?})", port_value, msg_value);
                     if ctx.did_put(port_value.clone()) {
                         println!("DEBUG: Already put...");
                         // Return bogus, replacing this at some point anyway
                         Ok(Value::Message(MessageValue(None)))
                     } else {
                         println!("DEBUG: Did not yet put...");
                         Err(EvalContinuation::Put(port_value, msg_value))
+                    }
+                }
                 Method::Fires => {
                     assert_eq!(1, expr.arguments.len());
                     let value = self.eval(h, ctx, expr.arguments[0])?;
                     match ctx.fires(value.clone()) {
                         None => Err(EvalContinuation::BlockFires(value)),
                         Some(result) => Ok(result),
+                    }
+                }
                 Method::Create => {
                     assert_eq!(1, expr.arguments.len());
                     let length = self.eval(h, ctx, expr.arguments[0])?;
                     Ok(Value::create_message(length))
+                }
                 Method::Symbolic(_symbol) => unimplemented!(),
             },
             Expression::Variable(expr) => self.get(h, ctx, expr.this.upcast()),
+        }
+    }
+}
 type EvalResult = Result<Value, EvalContinuation>;
 pub enum EvalContinuation {
     Stepping,
     Inconsistent,
     Terminal,
     SyncBlockStart,
     SyncBlockEnd,
     NewComponent(DefinitionId, Vec<Value>),
     BlockFires(Value),
     BlockGet(Value),
     Put(Value, Value),
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub(crate) struct Prompt {
     definition: DefinitionId,
     store: Store,
     position: Option<StatementId>,
+}
 impl Prompt {
     pub fn new(h: &Heap, def: DefinitionId, args: &Vec<Value>) -> Self {
         let mut prompt =
             Prompt { definition: def, store: Store::new(), position: Some((&h[def]).body()) };
         prompt.set_arguments(h, args);
         prompt
+    }
     fn set_arguments(&mut self, h: &Heap, args: &Vec<Value>) {
         let def = &h[self.definition];
         let params = def.parameters();
         assert_eq!(params.len(), args.len());
         for (param, value) in params.iter().zip(args.iter()) {
             let hparam = &h[*param];
             let parser_type = &h[hparam.parser_type];
             assert!(value.is_type_compatible(h, parser_type));
             self.store.initialize(h, param.upcast(), value.clone());
+        }
+    }
     pub fn step(&mut self, h: &Heap, ctx: &mut EvalContext) -> EvalResult {
         if self.position.is_none() {
             return Err(EvalContinuation::Terminal);
+        }
         let stmt = &h[self.position.unwrap()];
         match stmt {
             Statement::Block(stmt) => {
                 // Continue to first statement
                 self.position = Some(stmt.first());
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Memory(stmt) => {
                         // Evaluate initial expression
                         let value = self.store.eval(h, ctx, stmt.initial)?;
                         // Update store
                         self.store.initialize(h, stmt.variable.upcast(), value);
+                    }
                     LocalStatement::Channel(stmt) => {
                         let [from, to] = ctx.new_channel();
                         // Store the values in the declared variables
                         self.store.initialize(h, stmt.from.upcast(), from);
                         self.store.initialize(h, stmt.to.upcast(), to);
+                    }
+                }
                 // Continue to next statement
                 self.position = stmt.next();
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Skip(stmt) => {
                 // Continue to next statement
                 self.position = stmt.next;
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Labeled(stmt) => {
                 // Continue to next statement
                 self.position = Some(stmt.body);
                 Err(EvalContinuation::Stepping)
+            }
             Statement::If(stmt) => {
                 // Evaluate test
                 let value = self.store.eval(h, ctx, stmt.test)?;
                 // Continue with either branch
                 if value.as_boolean().0 {
                     self.position = Some(stmt.true_body);
                 } else {
                     self.position = Some(stmt.false_body);
+                }
                 Err(EvalContinuation::Stepping)
+            }
             Statement::EndIf(stmt) => {
                 // Continue to next statement
                 self.position = stmt.next;
                 Err(EvalContinuation::Stepping)
+            }
             Statement::While(stmt) => {
                 // Evaluate test
                 let value = self.store.eval(h, ctx, stmt.test)?;
                 // Either continue with body, or go to next
                 if value.as_boolean().0 {
                     self.position = Some(stmt.body);
                 } else {
                     self.position = stmt.end_while.map(|x| x.upcast());
+                }
                 Err(EvalContinuation::Stepping)
+            }
             Statement::EndWhile(stmt) => {
                 // Continue to next statement
                 self.position = stmt.next;
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Synchronous(stmt) => {
                 // Continue to next statement, and signal upward
                 self.position = Some(stmt.body);
                 Err(EvalContinuation::SyncBlockStart)
+            }
             Statement::EndSynchronous(stmt) => {
                 // Continue to next statement, and signal upward
                 self.position = stmt.next;
                 Err(EvalContinuation::SyncBlockEnd)
+            }
             Statement::Break(stmt) => {
                 // Continue to end of while
                 self.position = stmt.target.map(EndWhileStatementId::upcast);
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Continue(stmt) => {
                 // Continue to beginning of while
                 self.position = stmt.target.map(WhileStatementId::upcast);
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Assert(stmt) => {
                 // Evaluate expression
                 let value = self.store.eval(h, ctx, stmt.expression)?;
                 if value.as_boolean().0 {
                     // Continue to next statement
                     self.position = stmt.next;
                     Err(EvalContinuation::Stepping)
                 } else {
                     // Assertion failed: inconsistent
                     Err(EvalContinuation::Inconsistent)
+                }
+            }
             Statement::Return(stmt) => {
                 // Evaluate expression
                 let value = self.store.eval(h, ctx, stmt.expression)?;
                 // Done with evaluation
                 Ok(value)
+            }
             Statement::Goto(stmt) => {
                 // Continue to target
                 self.position = stmt.target.map(|x| x.upcast());
                 Err(EvalContinuation::Stepping)
+            }
             Statement::New(stmt) => {
                 let expr = &h[stmt.expression];
                 let mut args = Vec::new();
                 for &arg in expr.arguments.iter() {
                     let value = self.store.eval(h, ctx, arg)?;
                     args.push(value);
+                }
                 self.position = stmt.next;
                 match &expr.method {
                     Method::Symbolic(symbolic) => {
                          Err(EvalContinuation::NewComponent(symbolic.definition.unwrap(), args))
                     },
                     _ => unreachable!("not a symbolic call expression")
+                }
+            }
             Statement::Expression(stmt) => {
                 // Evaluate expression
                 let _value = self.store.eval(h, ctx, stmt.expression)?;
                 // Continue to next statement
                 self.position = stmt.next;
                 Err(EvalContinuation::Stepping)
+            }
+        }
+    }
     // fn compute_function(_h: &Heap, _fun: FunctionId, _args: &Vec<Value>) -> Option<Value> {
     // let mut prompt = Self::new(h, fun.upcast(), args);
     // let mut context = EvalContext::None;
     // loop {
     //     let result = prompt.step(h, &mut context);
     //     match result {
     //         Ok(val) => return Some(val),
     //         Err(cont) => match cont {
     //             EvalContinuation::Stepping => continue,
     //             EvalContinuation::Inconsistent => return None,
     //             // Functions never terminate without returning
     //             EvalContinuation::Terminal => unreachable!(),
     //             // Functions never encounter any blocking behavior
     //             EvalContinuation::SyncBlockStart => unreachable!(),
     //             EvalContinuation::SyncBlockEnd => unreachable!(),
     //             EvalContinuation::NewComponent(_, _) => unreachable!(),
     //             EvalContinuation::BlockFires(val) => unreachable!(),
     //             EvalContinuation::BlockGet(val) => unreachable!(),
     //             EvalContinuation::Put(port, msg) => unreachable!(),
     //         },
     //     }
     // }
     // }
+}
 // #[cfg(test)]
 // mod tests {
 //     extern crate test_generator;
 //     use std::fs::File;
 //     use std::io::Read;
 //     use std::path::Path;
 //     use test_generator::test_resources;
 //     use super::*;
 //     #[test_resources("testdata/eval/positive/*.pdl")]
 //     fn batch1(resource: &str) {
 //         let path = Path::new(resource);
 //         let expect = path.with_extension("txt");
 //         let mut heap = Heap::new();
 //         let mut source = InputSource::from_file(&path).unwrap();
 //         let mut parser = Parser::new(&mut source);
 //         let pd = parser.parse(&mut heap).unwrap();
 //         let def = heap[pd].get_definition_ident(&heap, b"test").unwrap();
 //         let fun = heap[def].as_function().this;
 //         let args = Vec::new();
 //         let result = Prompt::compute_function(&heap, fun, &args).unwrap();
 //         let valstr: String = format!("{}", result);
 //         println!("{}", valstr);
 //         let mut cev: Vec<u8> = Vec::new();
 //         let mut f = File::open(expect).unwrap();
 //         f.read_to_end(&mut cev).unwrap();
 //         let lavstr = String::from_utf8_lossy(&cev);
 //         println!("{}", lavstr);
 //         assert_eq!(valstr, lavstr);
 //     }
 // }

src/protocol/inputsource.rs

➞

Show inline comments

 use std::fmt;
 use std::fs::File;
 use std::io;
 use std::path::Path;
 use backtrace::Backtrace;
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct InputSource {
     pub(crate) filename: String,
     pub(crate) input: Vec<u8>,
     line: usize,
     column: usize,
     offset: usize,
+}
 static STD_LIB_PDL: &'static [u8] = b"
 primitive forward(in<msg> i, out<msg> o) {
     while(true) synchronous put(o, get(i));
+}
 primitive sync(in<msg> i, out<msg> o) {
     while(true) synchronous if(fires(i)) put(o, get(i));
+}
 primitive alternator(in<msg> i, out<msg> l, out<msg> r) {
     while(true) {
         synchronous if(fires(i)) put(l, get(i));
         synchronous if(fires(i)) put(r, get(i));
+    }
+}
 primitive replicator(in<msg> i, out<msg> l, out<msg> r) {
     while(true) synchronous {
         if(fires(i)) {
             msg m = get(i);
             put(l, m);
             put(r, m);
+        }
+    }
+}
 primitive merger(in<msg> l, in<msg> r, out<msg> o) {
     while(true) synchronous {
         if(fires(l))      put(o, get(l));
         else if(fires(r)) put(o, get(r));
+    }
+}
 ";
 impl InputSource {
     // Constructors
     pub fn new<R: io::Read, S: ToString>(filename: S, reader: &mut R) -> io::Result<InputSource> {
         let mut vec = Vec::new();
         reader.read_to_end(&mut vec)?;
         vec.extend(STD_LIB_PDL.to_vec());
         Ok(InputSource {
             filename: filename.to_string(),
             input: vec,
             line: 1,
             column: 1,
             offset: 0,
         })
+    }
     // Constructor helpers
     pub fn from_file(path: &Path) -> io::Result<InputSource> {
         let filename = path.file_name();
         match filename {
             Some(filename) => {
                 let mut f = File::open(path)?;
                 InputSource::new(filename.to_string_lossy(), &mut f)
+            }
             None => Err(io::Error::new(io::ErrorKind::NotFound, "Invalid path")),
+        }
+    }
     pub fn from_string(string: &str) -> io::Result<InputSource> {
         let buffer = Box::new(string);
         let mut bytes = buffer.as_bytes();
         InputSource::new(String::new(), &mut bytes)
+    }
     pub fn from_buffer(buffer: &[u8]) -> io::Result<InputSource> {
         InputSource::new(String::new(), &mut Box::new(buffer))
+    }
     // Internal methods
     pub fn pos(&self) -> InputPosition {
         InputPosition { line: self.line, column: self.column, offset: self.offset }
+    }
     pub fn seek(&mut self, pos: InputPosition) {
         debug_assert!(pos.offset < self.input.len());
         self.line = pos.line;
         self.column = pos.column;
         self.offset = pos.offset;
+    }
     // pub fn error<S: ToString>(&self, message: S) -> ParseError {
     //     self.pos().parse_error(message)
     // }
     pub fn is_eof(&self) -> bool {
         self.next() == None
+    }
     pub fn next(&self) -> Option<u8> {
         if self.offset < self.input.len() {
             Some(self.input[self.offset])
         } else {
             None
+        }
+    }
     pub fn lookahead(&self, pos: usize) -> Option<u8> {
         let offset_pos = self.offset + pos;
         if offset_pos < self.input.len() {
             Some(self.input[offset_pos])
         } else {
             None
+        }
+    }
     pub fn has(&self, to_compare: &[u8]) -> bool {
         if self.offset + to_compare.len() <= self.input.len() {
             for idx in 0..to_compare.len() {
                 if to_compare[idx] != self.input[self.offset + idx] {
                     return false;
+                }
+            }
             true
         } else {
             false
+        }
+    }
     pub fn consume(&mut self) {
         match self.next() {
             Some(x) if x == b'\r' && self.lookahead(1) != Some(b'\n') || x == b'\n' => {
                 self.line += 1;
                 self.offset += 1;
                 self.column = 1;
+            }
             Some(_) => {
                 self.offset += 1;
                 self.column += 1;
+            }
             None => {}
+        }
+    }
+}
 impl fmt::Display for InputSource {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.pos().fmt(f)
+    }
+}
 #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 pub struct InputPosition {
     line: usize,
     column: usize,
     offset: usize,
+}
 impl InputPosition {
     fn context<'a>(&self, source: &'a InputSource) -> &'a [u8] {
         let start = self.offset - (self.column - 1);
         let mut end = self.offset;
         while end < source.input.len() {
             let cur = (*source.input)[end];
             if cur == b'\n' || cur == b'\r' {
                 break;
+            }
             end += 1;
+        }
         &source.input[start..end]
+    }
     // fn parse_error<S: ToString>(&self, message: S) -> ParseError {
     //     ParseError { position: *self, message: message.to_string(), backtrace: Backtrace::new() }
     // }
     fn eval_error<S: ToString>(&self, message: S) -> EvalError {
         EvalError { position: *self, message: message.to_string(), backtrace: Backtrace::new() }
+    }
+}
 impl Default for InputPosition {
     fn default() -> Self {
         Self{ line: 1, column: 1, offset: 0 }
+    }
+}
 impl fmt::Display for InputPosition {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}:{}", self.line, self.column)
+    }
+}
 pub trait SyntaxElement {
     fn position(&self) -> InputPosition;
     fn error<S: ToString>(&self, message: S) -> EvalError {
         self.position().eval_error(message)
+    }
+}
 #[derive(Debug)]
 pub enum ParseErrorType {
     Info,
     Error
+}
 #[derive(Debug)]
 pub struct ParseErrorStatement {
     error_type: ParseErrorType,
     position: InputPosition,
     filename: String,
     context: String,
     message: String,
+}
 impl ParseErrorStatement {
     fn from_source(error_type: ParseErrorType, source: &InputSource, position: InputPosition, msg: &str) -> Self {
         // Seek line start and end
         debug_assert!(position.column < position.offset);
         let line_start = position.offset - (position.column - 1);
         let mut line_end = position.offset;
         while line_end < source.input.len() && source.input[line_end] != b'\n' {
             line_end += 1;
+        }
         // Compensate for '\r\n'
         if line_end > line_start && source.input[line_end - 1] == b'\r' {
             line_end -= 1;
+        }
         Self{
             error_type,
             position,
             filename: source.filename.clone(),
             context: String::from_utf8_lossy(&source.input[line_start..line_end]).to_string(),
             message: msg.to_string()
+        }
+    }
+}
 impl fmt::Display for ParseErrorStatement {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Write message
         match self.error_type {
             ParseErrorType::Info => write!(f, " INFO: ")?,
             ParseErrorType::Error => write!(f, "ERROR: ")?,
+        }
         writeln!(f, "{}", &self.message);
+        writeln!(f, "{}", &self.message)?;
         // Write originating file/line/column
         if self.filename.is_empty() {
             writeln!(f, " +- at {}:{}", self.position.line, self.position.column)?;
         } else {
             writeln!(f, " +- at {}:{}:{}", self.filename, self.position.line, self.position.column)?;
+        }
         // Write source context
         writeln!(f, " | ")?;
         writeln!(f, " | {}", self.context)?;
         // Write underline indicating where the error ocurred
         debug_assert!(self.position.column <= self.context.chars().count());
         let mut arrow = String::with_capacity(self.context.len() + 3);
         arrow.push_str(" | ");
         let mut char_col = 1;
         for char in self.context.chars() {
             if char_col == self.position.column { break; }
             if char == '\t' {
                 arrow.push('\t');
             } else {
                 arrow.push(' ');
+            }
             char_col += 1;
+        }
         arrow.push('^');
         writeln!(f, "{}", arrow)?;
         Ok(())
+    }
+}
 #[derive(Debug)]
 pub struct ParseError2 {
     statements: Vec<ParseErrorStatement>
+}
 impl fmt::Display for ParseError2 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if self.statements.is_empty() {
             return Ok(())
+        }
         self.statements[0].fmt(f)?;
         for statement in self.statements.iter().skip(1) {
             writeln!(f)?;
             statement.fmt(f)?;
+        }
         Ok(())
+    }
+}
 impl ParseError2 {
     pub fn empty() -> Self {
         Self{ statements: Vec::new() }
+    }
     pub fn new_error(source: &InputSource, position: InputPosition, msg: &str) -> Self {
         Self{ statements: vec!(ParseErrorStatement::from_source(ParseErrorType::Error, source, position, msg))}
+    }
     pub fn with_prefixed(mut self, error_type: ParseErrorType, source: &InputSource, position: InputPosition, msg: &str) -> Self {
         self.statements.insert(0, ParseErrorStatement::from_source(error_type, source, position, msg));
         self
+    }
     pub fn with_postfixed(mut self, error_type: ParseErrorType, source: &InputSource, position: InputPosition, msg: &str) -> Self {
         self.statements.push(ParseErrorStatement::from_source(error_type, source, position, msg));
         self
+    }
     pub fn with_postfixed_info(self, source: &InputSource, position: InputPosition, msg: &str) -> Self {
         self.with_postfixed(ParseErrorType::Info, source, position, msg)
+    }
+}
 #[derive(Debug, Clone)]
 pub struct EvalError {
     position: InputPosition,
     message: String,
     backtrace: Backtrace,
+}
 impl EvalError {
     pub fn new<S: ToString>(position: InputPosition, message: S) -> EvalError {
         EvalError { position, message: message.to_string(), backtrace: Backtrace::new() }
+    }
     // Diagnostic methods
     pub fn write<A: io::Write>(&self, source: &InputSource, writer: &mut A) -> io::Result<()> {
         if !source.filename.is_empty() {
             writeln!(
                 writer,
                 "Evaluation error at {}:{}: {}",
                 source.filename, self.position, self.message
             )?;
         } else {
             writeln!(writer, "Evaluation error at {}: {}", self.position, self.message)?;
+        }
         let line = self.position.context(source);
         writeln!(writer, "{}", String::from_utf8_lossy(line))?;
         let mut arrow: Vec<u8> = Vec::new();
         for pos in 1..self.position.column {
             let c = line[pos - 1];
             if c == b'\t' {
                 arrow.push(b'\t')
             } else {
                 arrow.push(b' ')
+            }
+        }
         arrow.push(b'^');
         writeln!(writer, "{}", String::from_utf8_lossy(&arrow))
+    }
     pub fn print(&self, source: &InputSource) {
         self.write(source, &mut std::io::stdout()).unwrap()
+    }
     pub fn display<'a>(&'a self, source: &'a InputSource) -> DisplayEvalError<'a> {
         DisplayEvalError::new(self, source)
+    }
+}
 impl From<EvalError> for io::Error {
     fn from(_: EvalError) -> io::Error {
         io::Error::new(io::ErrorKind::InvalidInput, "eval error")
+    }
+}
 #[derive(Clone, Copy)]
 pub struct DisplayEvalError<'a> {
     error: &'a EvalError,
     source: &'a InputSource,
+}
 impl DisplayEvalError<'_> {
     fn new<'a>(error: &'a EvalError, source: &'a InputSource) -> DisplayEvalError<'a> {
         DisplayEvalError { error, source }
+    }
+}
 impl fmt::Display for DisplayEvalError<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut vec: Vec<u8> = Vec::new();
         match self.error.write(self.source, &mut vec) {
             Err(_) => {
                 return fmt::Result::Err(fmt::Error);
+            }
             Ok(_) => {}
+        }
         write!(f, "{}", String::from_utf8_lossy(&vec))
+    }
+}
 // #[cfg(test)]
 // mod tests {
 //     use super::*;
 //     #[test]
 //     fn test_from_string() {
 //         let mut is = InputSource::from_string("#version 100\n").unwrap();
 //         assert!(is.input.len() == 13);
 //         assert!(is.line == 1);
 //         assert!(is.column == 1);
 //         assert!(is.offset == 0);
 //         let ps = is.pos();
 //         assert!(ps.line == 1);
 //         assert!(ps.column == 1);
 //         assert!(ps.offset == 0);
 //         assert!(is.next() == Some(b'#'));
 //         is.consume();
 //         assert!(is.next() == Some(b'v'));
 //         assert!(is.lookahead(1) == Some(b'e'));
 //         is.consume();
 //         assert!(is.next() == Some(b'e'));
 //         is.consume();
 //         assert!(is.next() == Some(b'r'));
 //         is.consume();
 //         assert!(is.next() == Some(b's'));
 //         is.consume();
 //         assert!(is.next() == Some(b'i'));
 //         is.consume();
 //         {
 //             let ps = is.pos();
 //             assert_eq!(b"#version 100", ps.context(&is));
 //             let er = is.error("hello world!");
 //             let mut vec: Vec<u8> = Vec::new();
 //             er.write(&is, &mut vec).unwrap();
 //             assert_eq!(
 //                 "Parse error at 1:7: hello world!\n#version 100\n      ^\n",
 //                 String::from_utf8_lossy(&vec)
 //             );
 //         }
 //         assert!(is.next() == Some(b'o'));
 //         is.consume();
 //         assert!(is.next() == Some(b'n'));
 //         is.consume();
 //         assert!(is.input.len() == 13);
 //         assert!(is.line == 1);
 //         assert!(is.column == 9);
 //         assert!(is.offset == 8);
 //         assert!(is.next() == Some(b' '));
 //         is.consume();
 //         assert!(is.next() == Some(b'1'));
 //         is.consume();
 //         assert!(is.next() == Some(b'0'));
 //         is.consume();
 //         assert!(is.next() == Some(b'0'));
 //         is.consume();
 //         assert!(is.input.len() == 13);
 //         assert!(is.line == 1);
 //         assert!(is.column == 13);
 //         assert!(is.offset == 12);
 //         assert!(is.next() == Some(b'\n'));
 //         is.consume();
 //         assert!(is.input.len() == 13);
 //         assert!(is.line == 2);
 //         assert!(is.column == 1);
 //         assert!(is.offset == 13);
 //         {
 //             let ps = is.pos();
 //             assert_eq!(b"", ps.context(&is));
 //         }
 //         assert!(is.next() == None);
 //         is.consume();
 //         assert!(is.next() == None);
 //     }
 //     #[test]
 //     fn test_split() {
 //         let mut is = InputSource::from_string("#version 100\n").unwrap();
 //         let backup = is.clone();
 //         assert!(is.next() == Some(b'#'));
 //         is.consume();
 //         assert!(is.next() == Some(b'v'));
 //         is.consume();
 //         assert!(is.next() == Some(b'e'));
 //         is.consume();
 //         is = backup;
 //         assert!(is.next() == Some(b'#'));
 //         is.consume();
 //         assert!(is.next() == Some(b'v'));
 //         is.consume();
 //         assert!(is.next() == Some(b'e'));
 //         is.consume();
 //     }
 // }

src/protocol/lexer.rs

➞

Show inline comments

 use crate::protocol::ast::*;
 use crate::protocol::inputsource::*;
 const MAX_LEVEL: usize = 128;
 const MAX_NAMESPACES: u8 = 8; // only three levels are supported at the moment
 fn is_vchar(x: Option<u8>) -> bool {
     if let Some(c) = x {
         c >= 0x21 && c <= 0x7E
     } else {
         false
+    }
+}
 fn is_wsp(x: Option<u8>) -> bool {
     if let Some(c) = x {
         c == b' ' || c == b'\t'
     } else {
         false
+    }
+}
 fn is_ident_start(x: Option<u8>) -> bool {
     if let Some(c) = x {
         c >= b'A' && c <= b'Z' || c >= b'a' && c <= b'z'
     } else {
         false
+    }
+}
 fn is_ident_rest(x: Option<u8>) -> bool {
     if let Some(c) = x {
         c >= b'A' && c <= b'Z' || c >= b'a' && c <= b'z' || c >= b'0' && c <= b'9' || c == b'_'
     } else {
         false
+    }
+}
 fn is_constant(x: Option<u8>) -> bool {
     if let Some(c) = x {
         c >= b'0' && c <= b'9' || c == b'\''
     } else {
         false
+    }
+}
 fn is_integer_start(x: Option<u8>) -> bool {
     if let Some(c) = x {
         c >= b'0' && c <= b'9'
     } else {
         false
+    }
+}
 fn is_integer_rest(x: Option<u8>) -> bool {
     if let Some(c) = x {
         c >= b'0' && c <= b'9'
             || c >= b'a' && c <= b'f'
             || c >= b'A' && c <= b'F'
             || c == b'x'
             || c == b'o'
     } else {
         false
+    }
+}
 fn lowercase(x: u8) -> u8 {
     if x >= b'A' && x <= b'Z' {
         x - b'A' + b'a'
     } else {
+        x
+    }
+}
 pub struct Lexer<'a> {
     source: &'a mut InputSource,
     level: usize,
+}
 impl Lexer<'_> {
     pub fn new(source: &mut InputSource) -> Lexer {
         Lexer { source, level: 0 }
+    }
     fn error_at_pos(&self, msg: &str) -> ParseError2 {
         ParseError2::new_error(self.source, self.source.pos(), msg)
+    }
     fn consume_line(&mut self) -> Result<Vec<u8>, ParseError2> {
         let mut result: Vec<u8> = Vec::new();
         let mut next = self.source.next();
         while next.is_some() && next != Some(b'\n') && next != Some(b'\r') {
             if !(is_vchar(next) || is_wsp(next)) {
                 return Err(self.error_at_pos("Expected visible character or whitespace"));
+            }
             result.push(next.unwrap());
             self.source.consume();
             next = self.source.next();
+        }
         if next.is_some() {
             self.source.consume();
+        }
         if next == Some(b'\r') && self.source.next() == Some(b'\n') {
             self.source.consume();
+        }
         Ok(result)
+    }
     fn consume_whitespace(&mut self, expected: bool) -> Result<(), ParseError2> {
         let mut found = false;
         let mut next = self.source.next();
         while next.is_some() {
             if next == Some(b' ')
                 || next == Some(b'\t')
                 || next == Some(b'\r')
                 || next == Some(b'\n')
+            {
                 self.source.consume();
                 next = self.source.next();
                 found = true;
                 continue;
+            }
             if next == Some(b'/') {
                 next = self.source.lookahead(1);
                 if next == Some(b'/') {
                     self.source.consume(); // slash
                     self.source.consume(); // slash
                     self.consume_line()?;
                     next = self.source.next();
                     found = true;
                     continue;
+                }
                 if next == Some(b'*') {
                     self.source.consume(); // slash
                     self.source.consume(); // star
                     next = self.source.next();
                     while next.is_some() {
                         if next == Some(b'*') {
                             next = self.source.lookahead(1);
                             if next == Some(b'/') {
                                 self.source.consume(); // star
                                 self.source.consume(); // slash
                                 break;
+                            }
+                        }
                         self.source.consume();
                         next = self.source.next();
+                    }
                     next = self.source.next();
                     found = true;
                     continue;
+                }
+            }
             break;
+        }
         if expected && !found {
             Err(self.error_at_pos("Expected whitespace"))
         } else {
             Ok(())
+        }
+    }
     fn consume_any_chars(&mut self) {
         if !is_ident_start(self.source.next()) { return }
         self.source.consume();
         while is_ident_rest(self.source.next()) {
             self.source.consume()
+        }
+    }
     fn has_keyword(&self, keyword: &[u8]) -> bool {
         if !self.source.has(keyword) {
             return false;
+        }
         // Word boundary
         if let Some(next) = self.source.lookahead(keyword.len()) {
             !(next >= b'A' && next <= b'Z' || next >= b'a' && next <= b'z')
         } else {
             true
+        }
+    }
     fn consume_keyword(&mut self, keyword: &[u8]) -> Result<(), ParseError2> {
         let len = keyword.len();
         for i in 0..len {
             let expected = Some(lowercase(keyword[i]));
             let next = self.source.next();
             if next != expected {
                 return Err(self.error_at_pos(&format!("Expected keyword '{}'", String::from_utf8_lossy(keyword))));
+            }
             self.source.consume();
+        }
         if let Some(next) = self.source.next() {
             if next >= b'A' && next <= b'Z' || next >= b'a' && next <= b'z' || next >= b'0' && next <= b'9' {
                 return Err(self.error_at_pos(&format!("Expected word boundary after '{}'", String::from_utf8_lossy(keyword))));
+            }
+        }
         Ok(())
+    }
     fn has_string(&self, string: &[u8]) -> bool {
         self.source.has(string)
+    }
     fn consume_string(&mut self, string: &[u8]) -> Result<(), ParseError2> {
         let len = string.len();
         for i in 0..len {
             let expected = Some(string[i]);
             let next = self.source.next();
             if next != expected {
                 return Err(self.error_at_pos(&format!("Expected {}", String::from_utf8_lossy(string))));
+            }
             self.source.consume();
+        }
         Ok(())
+    }
     fn consume_ident(&mut self) -> Result<Vec<u8>, ParseError2> {
         if !self.has_identifier() {
             return Err(self.error_at_pos("Expected identifier"));
+        }
         let mut result = Vec::new();
         let mut next = self.source.next();
         result.push(next.unwrap());
         self.source.consume();
         next = self.source.next();
         while is_ident_rest(next) {
             result.push(next.unwrap());
             self.source.consume();
             next = self.source.next();
+        }
         Ok(result)
+    }
     fn has_integer(&mut self) -> bool {
         is_integer_start(self.source.next())
+    }
     fn consume_integer(&mut self) -> Result<i64, ParseError2> {
         let position = self.source.pos();
         let mut data = Vec::new();
         let mut next = self.source.next();
         while is_integer_rest(next) {
             data.push(next.unwrap());
             self.source.consume();
             next = self.source.next();
+        }
         let data_len = data.len();
         debug_assert_ne!(data_len, 0);
         if data_len == 1 {
             debug_assert!(data[0] >= b'0' && data[0] <= b'9');
             return Ok((data[0] - b'0') as i64);
         } else {
             // TODO: Fix, u64 should be supported as well
             let parsed = if data[1] == b'b' {
                 let data = String::from_utf8_lossy(&data[2..]);
                 i64::from_str_radix(&data, 2)
             } else if data[1] == b'o' {
                 let data = String::from_utf8_lossy(&data[2..]);
                 i64::from_str_radix(&data, 8)
             } else if data[1] == b'x' {
                 let data = String::from_utf8_lossy(&data[2..]);
                 i64::from_str_radix(&data, 16)
             } else {
                 // Assume decimal
                 let data = String::from_utf8_lossy(&data);
                 i64::from_str_radix(&data, 10)
             };
             if let Err(_err) = parsed {
                 return Err(ParseError2::new_error(&self.source, position, "Invalid integer constant"));
+            }
             Ok(parsed.unwrap())
+        }
+    }
     // Statement keywords
     // TODO: Clean up these functions
     fn has_statement_keyword(&self) -> bool {
         self.has_keyword(b"channel")
             || self.has_keyword(b"skip")
             || self.has_keyword(b"if")
             || self.has_keyword(b"while")
             || self.has_keyword(b"break")
             || self.has_keyword(b"continue")
             || self.has_keyword(b"synchronous")
             || self.has_keyword(b"return")
             || self.has_keyword(b"assert")
             || self.has_keyword(b"goto")
             || self.has_keyword(b"new")
             || self.has_keyword(b"put") // TODO: @fix, should be a function, even though it has sideeffects
+    }
     fn has_type_keyword(&self) -> bool {
         self.has_keyword(b"in")
             || self.has_keyword(b"out")
             || self.has_keyword(b"msg")
             || self.has_keyword(b"boolean")
             || self.has_keyword(b"byte")
             || self.has_keyword(b"short")
             || self.has_keyword(b"int")
             || self.has_keyword(b"long")
             || self.has_keyword(b"auto")
+    }
     fn has_builtin_keyword(&self) -> bool {
         self.has_keyword(b"get")
             || self.has_keyword(b"fires")
             || self.has_keyword(b"create")
             || self.has_keyword(b"length")
+    }
     fn has_reserved(&self) -> bool {
         self.has_statement_keyword()
             || self.has_type_keyword()
             || self.has_builtin_keyword()
             || self.has_keyword(b"let")
             || self.has_keyword(b"struct")
             || self.has_keyword(b"enum")
             || self.has_keyword(b"true")
             || self.has_keyword(b"false")
             || self.has_keyword(b"null")
+    }
     // Identifiers
     fn has_identifier(&self) -> bool {
         if self.has_statement_keyword() || self.has_type_keyword() || self.has_builtin_keyword() {
             return false;
+        }
         let next = self.source.next();
         is_ident_start(next)
+    }
     fn consume_identifier(&mut self) -> Result<Identifier, ParseError2> {
         if self.has_statement_keyword() || self.has_type_keyword() || self.has_builtin_keyword() {
             return Err(self.error_at_pos("Expected identifier"));
+        }
         let position = self.source.pos();
         let value = self.consume_ident()?;
         Ok(Identifier{ position, value })
+    }
     fn consume_identifier_spilled(&mut self) -> Result<(), ParseError2> {
         if self.has_statement_keyword() || self.has_type_keyword() || self.has_builtin_keyword() {
             return Err(self.error_at_pos("Expected identifier"));
+        }
         self.consume_ident()?;
         Ok(())
+    }
     fn has_namespaced_identifier(&self) -> bool {
         self.has_identifier()
+    }
     fn consume_namespaced_identifier(&mut self) -> Result<NamespacedIdentifier, ParseError2> {
         if self.has_reserved() {
             return Err(self.error_at_pos("Encountered reserved keyword"));
+        }
         let position = self.source.pos();
         let mut ns_ident = self.consume_ident()?;
         let mut num_namespaces = 1;
         while self.has_string(b"::") {
             self.consume_string(b"::");
             if num_namespaces >= MAX_NAMESPACES {
                 return Err(self.error_at_pos("Too many namespaces in identifier"));
+            }
             let new_ident = self.consume_ident()?;
             ns_ident.extend(b"::");
             ns_ident.extend(new_ident);
             num_namespaces += 1;
+        }
         Ok(NamespacedIdentifier{
             position,
             value: ns_ident,
             num_namespaces,
         })
+    }
     fn consume_namespaced_identifier_spilled(&mut self) -> Result<(), ParseError2> {
         // TODO: @performance
         if self.has_reserved() {
             return Err(self.error_at_pos("Encountered reserved keyword"));
+        }
         self.consume_ident()?;
         while self.has_string(b"::") {
             self.consume_string(b"::")?;
             self.consume_ident()?;
+        }
         Ok(())
+    }
     // Types and type annotations
     /// Consumes a type definition. When called the input position should be at
     /// the type specification. When done the input position will be at the end
     /// of the type specifications (hence may be at whitespace).
     fn consume_type2(&mut self, h: &mut Heap, allow_inference: bool) -> Result<ParserTypeId, ParseError2> {
         // Small helper function to convert in/out polymorphic arguments. Not
         // pretty, but return boolean is true if the error is due to inference
         // not being allowed
         let reduce_port_poly_args = |
             heap: &mut Heap,
             port_pos: &InputPosition,
             args: Vec<ParserTypeId>,
         | -> Result<ParserTypeId, bool> {
             match args.len() {
 => if allow_inference {
                     Ok(heap.alloc_parser_type(|this| ParserType{
                         this,
                         pos: port_pos.clone(),
                         variant: ParserTypeVariant::Inferred
                     }))
                 } else {
                     Err(true)
                 },
 => Ok(args[0]),
                 _ => Err(false)
+            }
         };
         // Consume the type
         let pos = self.source.pos();
         let parser_type_variant = if self.has_keyword(b"msg") {
             self.consume_keyword(b"msg")?;
             ParserTypeVariant::Message
         } else if self.has_keyword(b"boolean") {
             self.consume_keyword(b"boolean")?;
             ParserTypeVariant::Bool
         } else if self.has_keyword(b"byte") {
             self.consume_keyword(b"byte")?;
             ParserTypeVariant::Byte
         } else if self.has_keyword(b"short") {
             self.consume_keyword(b"short")?;
             ParserTypeVariant::Short
         } else if self.has_keyword(b"int") {
             self.consume_keyword(b"int")?;
             ParserTypeVariant::Int
         } else if self.has_keyword(b"long") {
             self.consume_keyword(b"long")?;
             ParserTypeVariant::Long
         } else if self.has_keyword(b"str") {
             self.consume_keyword(b"str")?;
             ParserTypeVariant::String
         } else if self.has_keyword(b"auto") {
             if !allow_inference {
                 return Err(ParseError2::new_error(
                         &self.source, pos,
                         "Type inference is not allowed here"
                 ));
+            }
             self.consume_keyword(b"auto")?;
             ParserTypeVariant::Inferred
         } else if self.has_keyword(b"in") {
             // TODO: @cleanup: not particularly neat to have this special case
             //  where we enforce polyargs in the parser-phase
             // TODO: @hack, temporarily allow inferred port values
             self.consume_keyword(b"in")?;
             let poly_args = self.consume_polymorphic_args(h, allow_inference)?;
             let poly_arg = reduce_port_poly_args(h, &pos, poly_args)
                 .map_err(|infer_error|  {
                     let msg = if infer_error {
                         "Type inference is not allowed here"
                     } else {
                         "Type 'in' only allows for 1 polymorphic argument"
                     };
                     ParseError2::new_error(&self.source, pos, msg)
                 })?;
             ParserTypeVariant::Input(poly_arg)
         } else if self.has_keyword(b"out") {
             // TODO: @hack, temporarily allow inferred port values
             self.consume_keyword(b"out")?;
             let poly_args = self.consume_polymorphic_args(h, allow_inference)?;
             let poly_arg = reduce_port_poly_args(h, &pos, poly_args)
                 .map_err(|infer_error| {
                     let msg = if infer_error {
                         "Type inference is not allowed here"
                     } else {
                         "Type 'out' only allows for 1 polymorphic argument, but {} were specified"
                     };
                     ParseError2::new_error(&self.source, pos, msg)
                 })?;
             ParserTypeVariant::Output(poly_arg)
         } else {
             // Must be a symbolic type
             let identifier = self.consume_namespaced_identifier()?;
             let poly_args = self.consume_polymorphic_args(h, allow_inference)?;
             ParserTypeVariant::Symbolic(SymbolicParserType{identifier, poly_args, variant: None})
         };
         // If the type was a basic type (not supporting polymorphic type
         // arguments), then we make sure the user did not specify any of them.
         let mut backup_pos = self.source.pos();
         if !parser_type_variant.supports_polymorphic_args() {
             self.consume_whitespace(false)?;
             if let Some(b'<') = self.source.next() {
                 return Err(ParseError2::new_error(
                     &self.source, self.source.pos(),
                     "This type does not allow polymorphic arguments"
                 ));
+            }
             self.source.seek(backup_pos);
+        }
         let mut parser_type_id = h.alloc_parser_type(|this| ParserType{
             this, pos, variant: parser_type_variant
         });
         // If we're dealing with arrays, then we need to wrap the currently
         // parsed type in array types
         self.consume_whitespace(false)?;
         while let Some(b'[') = self.source.next() {
             let pos = self.source.pos();
             self.source.consume();
             self.consume_whitespace(false)?;
             if let Some(b']') = self.source.next() {
                 // Type is wrapped in an array
                 self.source.consume();
                 parser_type_id = h.alloc_parser_type(|this| ParserType{
                     this, pos, variant: ParserTypeVariant::Array(parser_type_id)
                 });
                 backup_pos = self.source.pos();
                 // In case we're dealing with another array
                 self.consume_whitespace(false)?;
             } else {
                 return Err(ParseError2::new_error(
                     &self.source, pos,
                     "Expected a closing ']'"
                 ));
+            }
+        }
         self.source.seek(backup_pos);
         Ok(parser_type_id)
+    }
     /// Attempts to consume a type without returning it. If it doesn't encounter
     /// a well-formed type, then the input position is left at a "random"
     /// position.
     fn maybe_consume_type_spilled_without_pos_recovery(&mut self) -> bool {
         // Consume type identifier
         if self.has_type_keyword() {
             self.consume_any_chars();
         } else {
             let ident = self.consume_namespaced_identifier();
             if ident.is_err() { return false; }
+        }
         // Consume any polymorphic arguments that follow the type identifier
         let mut backup_pos = self.source.pos();
         if self.consume_whitespace(false).is_err() { return false; }
         if !self.maybe_consume_poly_args_spilled_without_pos_recovery() { return false; }
         // Consume any array specifiers. Make sure we always leave the input
         // position at the end of the last array specifier if we do find a
         // valid type
-        let mut backup_pos = self.source.pos();
         if self.consume_whitespace(false).is_err() { return false; }
         while let Some(b'[') = self.source.next() {
             self.source.consume();
             if self.consume_whitespace(false).is_err() { return false; }
             if self.source.next() != Some(b']') { return false; }
             self.source.consume();
             backup_pos = self.source.pos();
             if self.consume_whitespace(false).is_err() { return false; }
+        }
         self.source.seek(backup_pos);
         return true;
+    }
     fn maybe_consume_type_spilled(&mut self) -> bool {
         let backup_pos = self.source.pos();
         if !self.maybe_consume_type_spilled_without_pos_recovery() {
             self.source.seek(backup_pos);
             return false;
+        }
         return true;
+    }
     /// Attempts to consume polymorphic arguments without returning them. If it
     /// doesn't encounter well-formed polymorphic arguments, then the input
     /// position is left at a "random" position.
     fn maybe_consume_poly_args_spilled_without_pos_recovery(&mut self) -> bool {
         if let Some(b'<') = self.source.next() {
             self.source.consume();
             if self.consume_whitespace(false).is_err() { return false; }
             loop {
                 if !self.maybe_consume_type_spilled_without_pos_recovery() { return false; }
                 if self.consume_whitespace(false).is_err() { return false; }
                 let has_comma = self.source.next() == Some(b',');
                 if has_comma {
                     self.source.consume();
                     if self.consume_whitespace(false).is_err() { return false; }
+                }
                 if let Some(b'>') = self.source.next() {
                     self.source.consume();
                     break;
                 } else if !has_comma {
                     return false;
+                }
+            }
+        }
         return true;
+    }
     /// Consumes polymorphic arguments and its delimiters if specified. The
     /// input position may be at whitespace. If polyargs are present then the
     /// whitespace and the args are consumed and the input position will be
     /// placed after the polyarg list. If polyargs are not present then the
     /// input position will remain unmodified and an empty vector will be
     /// returned.
     ///
     /// Polymorphic arguments represent the specification of the parametric
     /// types of a polymorphic type: they specify the value of the polymorphic
     /// type's polymorphic variables.
     fn consume_polymorphic_args(&mut self, h: &mut Heap, allow_inference: bool) -> Result<Vec<ParserTypeId>, ParseError2> {
         let backup_pos = self.source.pos();
         self.consume_whitespace(false)?;
         if let Some(b'<') = self.source.next() {
             // Has polymorphic args, at least one type must be specified
             self.source.consume();
             self.consume_whitespace(false)?;
             let mut poly_args = Vec::new();
             loop {
                 // TODO: @cleanup, remove the no_more_types var
                 poly_args.push(self.consume_type2(h, allow_inference)?);
                 self.consume_whitespace(false)?;
                 let has_comma = self.source.next() == Some(b',');
                 if has_comma {
                     // We might not actually be getting more types when the
                     // comma is at the end of the line, and we get a closing
                     // angular bracket on the next line.
                     self.source.consume();
                     self.consume_whitespace(false)?;
+                }
                 if let Some(b'>') = self.source.next() {
                     self.source.consume();
                     break;
                 } else if !has_comma {
                     return Err(ParseError2::new_error(
                         &self.source, self.source.pos(),
                         "Expected the end of the polymorphic argument list"
                     ))
+                }
+            }
             Ok(poly_args)
         } else {
             // No polymorphic args
             self.source.seek(backup_pos);
             Ok(vec!())
+        }
+    }
     /// Consumes polymorphic variables. These are identifiers that are used
     /// within polymorphic types. The input position may be at whitespace. If
     /// polymorphic variables are present then the whitespace, wrapping
     /// delimiters and the polymorphic variables are consumed. Otherwise the
     /// input position will stay where it is. If no polymorphic variables are
     /// present then an empty vector will be returned.
     fn consume_polymorphic_vars(&mut self) -> Result<Vec<Identifier>, ParseError2> {
         let backup_pos = self.source.pos();
         self.consume_whitespace(false)?;
         if let Some(b'<') = self.source.next() {
             // Found the opening delimiter, we want at least one polyvar
             self.source.consume();
             self.consume_whitespace(false)?;
             let mut poly_vars = Vec::new();
             loop {
                 poly_vars.push(self.consume_identifier()?);
                 self.consume_whitespace(false)?;
                 let has_comma = self.source.next() == Some(b',');
                 if has_comma {
                     // We may get another variable
                     self.source.consume();
                     self.consume_whitespace(false)?;
+                }
                 if let Some(b'>') = self.source.next() {
                     self.source.consume();
                     break;
                 } else if !has_comma {
                     return Err(ParseError2::new_error(
                         &self.source, self.source.pos(),
                         "Expected the end of the polymorphic variable list"
                     ))
+                }
+            }
             Ok(poly_vars)
         } else {
             // No polymorphic args
             self.source.seek(backup_pos);
             Ok(vec!())
+        }
+    }
     // Parameters
     fn consume_parameter(&mut self, h: &mut Heap) -> Result<ParameterId, ParseError2> {
         let parser_type = self.consume_type2(h, false)?;
         self.consume_whitespace(true)?;
         let position = self.source.pos();
         let identifier = self.consume_identifier()?;
         let id =
             h.alloc_parameter(|this| Parameter { this, position, parser_type, identifier });
         Ok(id)
+    }
     fn consume_parameters(
         &mut self,
         h: &mut Heap,
         params: &mut Vec<ParameterId>,
     ) -> Result<(), ParseError2> {
         self.consume_string(b"(")?;
         self.consume_whitespace(false)?;
         if !self.has_string(b")") {
             while self.source.next().is_some() {
                 params.push(self.consume_parameter(h)?);
                 self.consume_whitespace(false)?;
                 if self.has_string(b")") {
                     break;
+                }
                 self.consume_string(b",")?;
                 self.consume_whitespace(false)?;
+            }
+        }
         self.consume_string(b")")?;
         Ok(())
+    }
     // ====================
     // Expressions
     // ====================
     fn consume_paren_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         self.consume_string(b"(")?;
         self.consume_whitespace(false)?;
         let result = self.consume_expression(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b")")?;
         Ok(result)
+    }
     fn consume_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         if self.level >= MAX_LEVEL {
             return Err(self.error_at_pos("Too deeply nested expression"));
+        }
         self.level += 1;
         let result = self.consume_assignment_expression(h);
         self.level -= 1;
         result
+    }
     fn consume_assignment_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let result = self.consume_conditional_expression(h)?;
         self.consume_whitespace(false)?;
         if self.has_assignment_operator() {
             let position = self.source.pos();
             let left = result;
             let operation = self.consume_assignment_operator()?;
             self.consume_whitespace(false)?;
             let right = self.consume_expression(h)?;
             Ok(h.alloc_assignment_expression(|this| AssignmentExpression {
                 this,
                 position,
                 left,
                 operation,
                 right,
                 parent: ExpressionParent::None,
                 concrete_type: ConcreteType::default(),
             })
             .upcast())
         } else {
             Ok(result)
+        }
+    }
     fn has_assignment_operator(&self) -> bool {
         self.has_string(b"=")
             || self.has_string(b"*=")
             || self.has_string(b"/=")
             || self.has_string(b"%=")
             || self.has_string(b"+=")
             || self.has_string(b"-=")
             || self.has_string(b"<<=")
             || self.has_string(b">>=")
             || self.has_string(b"&=")
             || self.has_string(b"^=")
             || self.has_string(b"|=")
+    }
     fn consume_assignment_operator(&mut self) -> Result<AssignmentOperator, ParseError2> {
         if self.has_string(b"=") {
             self.consume_string(b"=")?;
             Ok(AssignmentOperator::Set)
         } else if self.has_string(b"*=") {
             self.consume_string(b"*=")?;
             Ok(AssignmentOperator::Multiplied)
         } else if self.has_string(b"/=") {
             self.consume_string(b"/=")?;
             Ok(AssignmentOperator::Divided)
         } else if self.has_string(b"%=") {
             self.consume_string(b"%=")?;
             Ok(AssignmentOperator::Remained)
         } else if self.has_string(b"+=") {
             self.consume_string(b"+=")?;
             Ok(AssignmentOperator::Added)
         } else if self.has_string(b"-=") {
             self.consume_string(b"-=")?;
             Ok(AssignmentOperator::Subtracted)
         } else if self.has_string(b"<<=") {
             self.consume_string(b"<<=")?;
             Ok(AssignmentOperator::ShiftedLeft)
         } else if self.has_string(b">>=") {
             self.consume_string(b">>=")?;
             Ok(AssignmentOperator::ShiftedRight)
         } else if self.has_string(b"&=") {
             self.consume_string(b"&=")?;
             Ok(AssignmentOperator::BitwiseAnded)
         } else if self.has_string(b"^=") {
             self.consume_string(b"^=")?;
             Ok(AssignmentOperator::BitwiseXored)
         } else if self.has_string(b"|=") {
             self.consume_string(b"|=")?;
             Ok(AssignmentOperator::BitwiseOred)
         } else {
             Err(self.error_at_pos("Expected assignment operator"))
+        }
+    }
     fn consume_conditional_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let result = self.consume_concat_expression(h)?;
         self.consume_whitespace(false)?;
         if self.has_string(b"?") {
             let position = self.source.pos();
             let test = result;
             self.consume_string(b"?")?;
             self.consume_whitespace(false)?;
             let true_expression = self.consume_expression(h)?;
             self.consume_whitespace(false)?;
             self.consume_string(b":")?;
             self.consume_whitespace(false)?;
             let false_expression = self.consume_expression(h)?;
             Ok(h.alloc_conditional_expression(|this| ConditionalExpression {
                 this,
                 position,
                 test,
                 true_expression,
                 false_expression,
                 parent: ExpressionParent::None,
                 concrete_type: ConcreteType::default(),
             })
             .upcast())
         } else {
             Ok(result)
+        }
+    }
     fn consume_concat_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let mut result = self.consume_lor_expression(h)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"@") {
             let position = self.source.pos();
             let left = result;
             self.consume_string(b"@")?;
             let operation = BinaryOperator::Concatenate;
             self.consume_whitespace(false)?;
             let right = self.consume_lor_expression(h)?;
             self.consume_whitespace(false)?;
             result = h
                 .alloc_binary_expression(|this| BinaryExpression {
                     this,
                     position,
                     left,
                     operation,
                     right,
                     parent: ExpressionParent::None,
                     concrete_type: ConcreteType::default(),
                 })
                 .upcast();
+        }
         Ok(result)
+    }
     fn consume_lor_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let mut result = self.consume_land_expression(h)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"||") {
             let position = self.source.pos();
             let left = result;
             self.consume_string(b"||")?;
             let operation = BinaryOperator::LogicalOr;
             self.consume_whitespace(false)?;
             let right = self.consume_land_expression(h)?;
             self.consume_whitespace(false)?;
             result = h
                 .alloc_binary_expression(|this| BinaryExpression {
                     this,
                     position,
                     left,
                     operation,
                     right,
                     parent: ExpressionParent::None,
                     concrete_type: ConcreteType::default(),
                 })
                 .upcast();
+        }
         Ok(result)
+    }
     fn consume_land_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let mut result = self.consume_bor_expression(h)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"&&") {
             let position = self.source.pos();
             let left = result;
             self.consume_string(b"&&")?;
             let operation = BinaryOperator::LogicalAnd;
             self.consume_whitespace(false)?;
             let right = self.consume_bor_expression(h)?;
             self.consume_whitespace(false)?;
             result = h
                 .alloc_binary_expression(|this| BinaryExpression {
                     this,
                     position,
                     left,
                     operation,
                     right,
                     parent: ExpressionParent::None,
                     concrete_type: ConcreteType::default(),
                 })
                 .upcast();
+        }
         Ok(result)
+    }
     fn consume_bor_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let mut result = self.consume_xor_expression(h)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"|") && !self.has_string(b"||") && !self.has_string(b"|=") {
             let position = self.source.pos();
             let left = result;
             self.consume_string(b"|")?;
             let operation = BinaryOperator::BitwiseOr;
             self.consume_whitespace(false)?;
             let right = self.consume_xor_expression(h)?;
             self.consume_whitespace(false)?;
             result = h
                 .alloc_binary_expression(|this| BinaryExpression {
                     this,
                     position,
                     left,
                     operation,
                     right,
                     parent: ExpressionParent::None,
                     concrete_type: ConcreteType::default(),
                 })
                 .upcast();
+        }
         Ok(result)
+    }
     fn consume_xor_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let mut result = self.consume_band_expression(h)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"^") && !self.has_string(b"^=") {
             let position = self.source.pos();
             let left = result;
             self.consume_string(b"^")?;
             let operation = BinaryOperator::BitwiseXor;
             self.consume_whitespace(false)?;
             let right = self.consume_band_expression(h)?;
             self.consume_whitespace(false)?;
             result = h
                 .alloc_binary_expression(|this| BinaryExpression {
                     this,
                     position,
                     left,
                     operation,
                     right,
                     parent: ExpressionParent::None,
                     concrete_type: ConcreteType::default(),
                 })
                 .upcast();
+        }
         Ok(result)
+    }
     fn consume_band_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let mut result = self.consume_eq_expression(h)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"&") && !self.has_string(b"&&") && !self.has_string(b"&=") {
             let position = self.source.pos();
             let left = result;
             self.consume_string(b"&")?;
             let operation = BinaryOperator::BitwiseAnd;
             self.consume_whitespace(false)?;
             let right = self.consume_eq_expression(h)?;
             self.consume_whitespace(false)?;
             result = h
                 .alloc_binary_expression(|this| BinaryExpression {
                     this,
                     position,
                     left,
                     operation,
                     right,
                     parent: ExpressionParent::None,
                     concrete_type: ConcreteType::default(),
                 })
                 .upcast();
+        }
         Ok(result)
+    }
     fn consume_eq_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let mut result = self.consume_rel_expression(h)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"==") || self.has_string(b"!=") {
             let position = self.source.pos();
             let left = result;
             let operation;
             if self.has_string(b"==") {
                 self.consume_string(b"==")?;
                 operation = BinaryOperator::Equality;
             } else {
                 self.consume_string(b"!=")?;
                 operation = BinaryOperator::Inequality;
+            }
             self.consume_whitespace(false)?;
             let right = self.consume_rel_expression(h)?;
             self.consume_whitespace(false)?;
             result = h
                 .alloc_binary_expression(|this| BinaryExpression {
                     this,
                     position,
                     left,
                     operation,
                     right,
                     parent: ExpressionParent::None,
                     concrete_type: ConcreteType::default(),
                 })
                 .upcast();
+        }
         Ok(result)
+    }
     fn consume_rel_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let mut result = self.consume_shift_expression(h)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"<=")
             || self.has_string(b">=")
             || self.has_string(b"<") && !self.has_string(b"<<=")
             || self.has_string(b">") && !self.has_string(b">>=")
+        {
             let position = self.source.pos();
             let left = result;
             let operation;
             if self.has_string(b"<=") {
                 self.consume_string(b"<=")?;
                 operation = BinaryOperator::LessThanEqual;
             } else if self.has_string(b">=") {
                 self.consume_string(b">=")?;
                 operation = BinaryOperator::GreaterThanEqual;
             } else if self.has_string(b"<") {
                 self.consume_string(b"<")?;
                 operation = BinaryOperator::LessThan;
             } else {
                 self.consume_string(b">")?;
                 operation = BinaryOperator::GreaterThan;
+            }
             self.consume_whitespace(false)?;
             let right = self.consume_shift_expression(h)?;
             self.consume_whitespace(false)?;
             result = h
                 .alloc_binary_expression(|this| BinaryExpression {
                     this,
                     position,
                     left,
                     operation,
                     right,
                     parent: ExpressionParent::None,
                     concrete_type: ConcreteType::default(),
                 })
                 .upcast();
+        }
         Ok(result)
+    }
     fn consume_shift_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let mut result = self.consume_add_expression(h)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"<<") && !self.has_string(b"<<=")
             || self.has_string(b">>") && !self.has_string(b">>=")
+        {
             let position = self.source.pos();
             let left = result;
             let operation;
             if self.has_string(b"<<") {
                 self.consume_string(b"<<")?;
                 operation = BinaryOperator::ShiftLeft;
             } else {
                 self.consume_string(b">>")?;
                 operation = BinaryOperator::ShiftRight;
+            }
             self.consume_whitespace(false)?;
             let right = self.consume_add_expression(h)?;
             self.consume_whitespace(false)?;
             result = h
                 .alloc_binary_expression(|this| BinaryExpression {
                     this,
                     position,
                     left,
                     operation,
                     right,
                     parent: ExpressionParent::None,
                     concrete_type: ConcreteType::default(),
                 })
                 .upcast();
+        }
         Ok(result)
+    }
     fn consume_add_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let mut result = self.consume_mul_expression(h)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"+") && !self.has_string(b"+=")
             || self.has_string(b"-") && !self.has_string(b"-=")
+        {
             let position = self.source.pos();
             let left = result;
             let operation;
             if self.has_string(b"+") {
                 self.consume_string(b"+")?;
                 operation = BinaryOperator::Add;
             } else {
                 self.consume_string(b"-")?;
                 operation = BinaryOperator::Subtract;
+            }
             self.consume_whitespace(false)?;
             let right = self.consume_mul_expression(h)?;
             self.consume_whitespace(false)?;
             result = h
                 .alloc_binary_expression(|this| BinaryExpression {
                     this,
                     position,
                     left,
                     operation,
                     right,
                     parent: ExpressionParent::None,
                     concrete_type: ConcreteType::default(),
                 })
                 .upcast();
+        }
         Ok(result)
+    }
     fn consume_mul_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let mut result = self.consume_prefix_expression(h)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"*") && !self.has_string(b"*=")
             || self.has_string(b"/") && !self.has_string(b"/=")
             || self.has_string(b"%") && !self.has_string(b"%=")
+        {
             let position = self.source.pos();
             let left = result;
             let operation;
             if self.has_string(b"*") {
                 self.consume_string(b"*")?;
                 operation = BinaryOperator::Multiply;
             } else if self.has_string(b"/") {
                 self.consume_string(b"/")?;
                 operation = BinaryOperator::Divide;
             } else {
                 self.consume_string(b"%")?;
                 operation = BinaryOperator::Remainder;
+            }
             self.consume_whitespace(false)?;
             let right = self.consume_prefix_expression(h)?;
             self.consume_whitespace(false)?;
             result = h
                 .alloc_binary_expression(|this| BinaryExpression {
                     this,
                     position,
                     left,
                     operation,
                     right,
                     parent: ExpressionParent::None,
                     concrete_type: ConcreteType::default(),
                 })
                 .upcast();
+        }
         Ok(result)
+    }
     fn consume_prefix_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         if self.has_string(b"+")
             || self.has_string(b"-")
             || self.has_string(b"~")
             || self.has_string(b"!")
+        {
             let position = self.source.pos();
             let operation;
             if self.has_string(b"+") {
                 self.consume_string(b"+")?;
                 if self.has_string(b"+") {
                     self.consume_string(b"+")?;
                     operation = UnaryOperation::PreIncrement;
                 } else {
                     operation = UnaryOperation::Positive;
+                }
             } else if self.has_string(b"-") {
                 self.consume_string(b"-")?;
                 if self.has_string(b"-") {
                     self.consume_string(b"-")?;
                     operation = UnaryOperation::PreDecrement;
                 } else {
                     operation = UnaryOperation::Negative;
+                }
             } else if self.has_string(b"~") {
                 self.consume_string(b"~")?;
                 operation = UnaryOperation::BitwiseNot;
             } else {
                 self.consume_string(b"!")?;
                 operation = UnaryOperation::LogicalNot;
+            }
             self.consume_whitespace(false)?;
             if self.level >= MAX_LEVEL {
                 return Err(self.error_at_pos("Too deeply nested expression"));
+            }
             self.level += 1;
             let result = self.consume_prefix_expression(h);
             self.level -= 1;
             let expression = result?;
             return Ok(h
                 .alloc_unary_expression(|this| UnaryExpression {
                     this,
                     position,
                     operation,
                     expression,
                     parent: ExpressionParent::None,
                     concrete_type: ConcreteType::default(),
                 })
                 .upcast());
+        }
         self.consume_postfix_expression(h)
+    }
     fn consume_postfix_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         let mut result = self.consume_primary_expression(h)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"++")
             || self.has_string(b"--")
             || self.has_string(b"[")
             || (self.has_string(b".") && !self.has_string(b".."))
+        {
             let mut position = self.source.pos();
             if self.has_string(b"++") {
                 self.consume_string(b"++")?;
                 let operation = UnaryOperation::PostIncrement;
                 let expression = result;
                 self.consume_whitespace(false)?;
                 result = h
                     .alloc_unary_expression(|this| UnaryExpression {
                         this,
                         position,
                         operation,
                         expression,
                         parent: ExpressionParent::None,
                         concrete_type: ConcreteType::default(),
                     })
                     .upcast();
             } else if self.has_string(b"--") {
                 self.consume_string(b"--")?;
                 let operation = UnaryOperation::PostDecrement;
                 let expression = result;
                 self.consume_whitespace(false)?;
                 result = h
                     .alloc_unary_expression(|this| UnaryExpression {
                         this,
                         position,
                         operation,
                         expression,
                         parent: ExpressionParent::None,
                         concrete_type: ConcreteType::default(),
                     })
                     .upcast();
             } else if self.has_string(b"[") {
                 self.consume_string(b"[")?;
                 self.consume_whitespace(false)?;
                 let subject = result;
                 let index = self.consume_expression(h)?;
                 self.consume_whitespace(false)?;
                 if self.has_string(b"..") || self.has_string(b":") {
                     position = self.source.pos();
                     if self.has_string(b"..") {
                         self.consume_string(b"..")?;
                     } else {
                         self.consume_string(b":")?;
+                    }
                     self.consume_whitespace(false)?;
                     let to_index = self.consume_expression(h)?;
                     self.consume_whitespace(false)?;
                     result = h
                         .alloc_slicing_expression(|this| SlicingExpression {
                             this,
                             position,
                             subject,
                             from_index: index,
                             to_index,
                             parent: ExpressionParent::None,
                             concrete_type: ConcreteType::default(),
                         })
                         .upcast();
                 } else {
                     result = h
                         .alloc_indexing_expression(|this| IndexingExpression {
                             this,
                             position,
                             subject,
                             index,
                             parent: ExpressionParent::None,
                             concrete_type: ConcreteType::default(),
                         })
                         .upcast();
+                }
                 self.consume_string(b"]")?;
                 self.consume_whitespace(false)?;
             } else {
                 assert!(self.has_string(b"."));
                 self.consume_string(b".")?;
                 self.consume_whitespace(false)?;
                 let subject = result;
                 let field;
                 if self.has_keyword(b"length") {
                     self.consume_keyword(b"length")?;
                     field = Field::Length;
                 } else {
                     field = Field::Symbolic(self.consume_identifier()?);
+                }
                 result = h
                     .alloc_select_expression(|this| SelectExpression {
                         this,
                         position,
                         subject,
                         field,
                         parent: ExpressionParent::None,
                         concrete_type: ConcreteType::default(),
                     })
                     .upcast();
+            }
+        }
         Ok(result)
+    }
     fn consume_primary_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError2> {
         if self.has_string(b"(") {
             return self.consume_paren_expression(h);
+        }
         if self.has_string(b"{") {
             return Ok(self.consume_array_expression(h)?.upcast());
+        }
         if self.has_constant()
             || self.has_keyword(b"null")
             || self.has_keyword(b"true")
             || self.has_keyword(b"false")
+        {
             return Ok(self.consume_constant_expression(h)?.upcast());
+        }
         if self.has_call_expression() {
             return Ok(self.consume_call_expression(h)?.upcast());
+        }
         Ok(self.consume_variable_expression(h)?.upcast())
+    }
     fn consume_array_expression(&mut self, h: &mut Heap) -> Result<ArrayExpressionId, ParseError2> {
         let position = self.source.pos();
         let mut elements = Vec::new();
         self.consume_string(b"{")?;
         self.consume_whitespace(false)?;
         if !self.has_string(b"}") {
             while self.source.next().is_some() {
                 elements.push(self.consume_expression(h)?);
                 self.consume_whitespace(false)?;
                 if self.has_string(b"}") {
                     break;
+                }
                 self.consume_string(b",")?;
                 self.consume_whitespace(false)?;
+            }
+        }
         self.consume_string(b"}")?;
         Ok(h.alloc_array_expression(|this| ArrayExpression {
             this,
             position,
             elements,
             parent: ExpressionParent::None,
             concrete_type: ConcreteType::default(),
         }))
+    }
     fn has_constant(&self) -> bool {
         is_constant(self.source.next())
+    }
     fn consume_constant_expression(
         &mut self,
         h: &mut Heap,
     ) -> Result<ConstantExpressionId, ParseError2> {
         let position = self.source.pos();
         let value;
         if self.has_keyword(b"null") {
             self.consume_keyword(b"null")?;
             value = Constant::Null;
         } else if self.has_keyword(b"true") {
             self.consume_keyword(b"true")?;
             value = Constant::True;
         } else if self.has_keyword(b"false") {
             self.consume_keyword(b"false")?;
             value = Constant::False;
         } else if self.source.next() == Some(b'\'') {
             self.source.consume();
             let mut data = Vec::new();
             let mut next = self.source.next();
             while next != Some(b'\'') && (is_vchar(next) || next == Some(b' ')) {
                 data.push(next.unwrap());
                 self.source.consume();
                 next = self.source.next();
+            }
             if next != Some(b'\'') || data.is_empty() {
                 return Err(self.error_at_pos("Expected character constant"));
+            }
             self.source.consume();
             value = Constant::Character(data);
         } else {
             if !self.has_integer() {
                 return Err(self.error_at_pos("Expected integer constant"));
+            }
             value = Constant::Integer(self.consume_integer()?);
+        }
         Ok(h.alloc_constant_expression(|this| ConstantExpression {
             this,
             position,
             value,
             parent: ExpressionParent::None,
             concrete_type: ConcreteType::default(),
         }))
+    }
     fn has_call_expression(&mut self) -> bool {
         // We need to prevent ambiguity with various operators (because we may
         // be specifying polymorphic variables) and variables.
         if self.has_builtin_keyword() {
             return true;
+        }
         let backup_pos = self.source.pos();
         let mut result = false;
         if self.consume_namespaced_identifier_spilled().is_ok() &&
             self.consume_whitespace(false).is_ok() &&
             self.maybe_consume_poly_args_spilled_without_pos_recovery() &&
             self.consume_whitespace(false).is_ok() &&
             self.source.next() == Some(b'(') {
             // Seems like we have a function call or an enum literal
             result = true;
+        }
         self.source.seek(backup_pos);
         return result;
+    }
     fn consume_call_expression(&mut self, h: &mut Heap) -> Result<CallExpressionId, ParseError2> {
         let position = self.source.pos();
         // Consume method identifier
         let method;
         if self.has_keyword(b"get") {
             self.consume_keyword(b"get")?;
             method = Method::Get;
         } else if self.has_keyword(b"put") {
             self.consume_keyword(b"put")?;
             method = Method::Put;
         } else if self.has_keyword(b"fires") {
             self.consume_keyword(b"fires")?;
             method = Method::Fires;
         } else if self.has_keyword(b"create") {
             self.consume_keyword(b"create")?;
             method = Method::Create;
         } else {
             let identifier = self.consume_namespaced_identifier()?;
             method = Method::Symbolic(MethodSymbolic{
                 identifier,
                 definition: None
             })
+        }
         // Consume polymorphic arguments
         self.consume_whitespace(false)?;
         let poly_args = self.consume_polymorphic_args(h, true)?;
         // Consume arguments to call
         self.consume_whitespace(false)?;
         let mut arguments = Vec::new();
         self.consume_string(b"(")?;
         self.consume_whitespace(false)?;
         if !self.has_string(b")") {
             // TODO: allow trailing comma
             while self.source.next().is_some() {
                 arguments.push(self.consume_expression(h)?);
                 self.consume_whitespace(false)?;
                 if self.has_string(b")") {
                     break;
+                }
                 self.consume_string(b",")?;
                 self.consume_whitespace(false)?
+            }
+        }
         self.consume_string(b")")?;
         Ok(h.alloc_call_expression(|this| CallExpression {
             this,
             position,
             method,
             arguments,
             poly_args,
             parent: ExpressionParent::None,
             concrete_type: ConcreteType::default(),
         }))
+    }
     fn consume_variable_expression(
         &mut self,
         h: &mut Heap,
     ) -> Result<VariableExpressionId, ParseError2> {
         let position = self.source.pos();
         let identifier = self.consume_namespaced_identifier()?;
         Ok(h.alloc_variable_expression(|this| VariableExpression {
             this,
             position,
             identifier,
             declaration: None,
             parent: ExpressionParent::None,
             concrete_type: ConcreteType::default(),
         }))
+    }
     // ====================
     // Statements
     // ====================
     /// Consumes any kind of statement from the source and will error if it
     /// did not encounter a statement. Will also return an error if the
     /// statement is nested too deeply.
     ///
     /// `wrap_in_block` may be set to true to ensure that the parsed statement
     /// will be wrapped in a block statement if it is not already a block
     /// statement. This is used to ensure that all `if`, `while` and `sync`
     /// statements have a block statement as body.
     fn consume_statement(&mut self, h: &mut Heap, wrap_in_block: bool) -> Result<StatementId, ParseError2> {
         if self.level >= MAX_LEVEL {
             return Err(self.error_at_pos("Too deeply nested statement"));
+        }
         self.level += 1;
         let result = self.consume_statement_impl(h, wrap_in_block);
         self.level -= 1;
         result
+    }
     fn has_label(&mut self) -> bool {
         // To prevent ambiguity with expression statements consisting only of an
         // identifier or a namespaced identifier, we look ahead and match on the
         // *single* colon that signals a labeled statement.
         let backup_pos = self.source.pos();
         let mut result = false;
         if self.consume_identifier_spilled().is_ok() {
             // next character is ':', second character is NOT ':'
             result = Some(b':') == self.source.next() && Some(b':') != self.source.lookahead(1)
+        }
         self.source.seek(backup_pos);
         return result;
+    }
     fn consume_statement_impl(&mut self, h: &mut Heap, wrap_in_block: bool) -> Result<StatementId, ParseError2> {
         // Parse and allocate statement
         let mut must_wrap = true;
         let mut stmt_id = if self.has_string(b"{") {
             must_wrap = false;
             self.consume_block_statement(h)?
         } else if self.has_keyword(b"skip") {
             must_wrap = false;
             self.consume_skip_statement(h)?.upcast()
         } else if self.has_keyword(b"if") {
             self.consume_if_statement(h)?.upcast()
         } else if self.has_keyword(b"while") {
             self.consume_while_statement(h)?.upcast()
         } else if self.has_keyword(b"break") {
             self.consume_break_statement(h)?.upcast()
         } else if self.has_keyword(b"continue") {
             self.consume_continue_statement(h)?.upcast()
         } else if self.has_keyword(b"synchronous") {
             self.consume_synchronous_statement(h)?.upcast()
         } else if self.has_keyword(b"return") {
             self.consume_return_statement(h)?.upcast()
         } else if self.has_keyword(b"assert") {
             self.consume_assert_statement(h)?.upcast()
         } else if self.has_keyword(b"goto") {
             self.consume_goto_statement(h)?.upcast()
         } else if self.has_keyword(b"new") {
             self.consume_new_statement(h)?.upcast()
         } else if self.has_label() {
             self.consume_labeled_statement(h)?.upcast()
         } else {
             self.consume_expression_statement(h)?.upcast()
         };
         // Wrap if desired and if needed
         if must_wrap && wrap_in_block {
             let position = h[stmt_id].position();
             let block_wrapper = h.alloc_block_statement(|this| BlockStatement{
                 this,
                 position,
                 statements: vec![stmt_id],
                 parent_scope: None,
                 relative_pos_in_parent: 0,
                 locals: Vec::new(),
                 labels: Vec::new()
             });
             stmt_id = block_wrapper.upcast();
+        }
         Ok(stmt_id)
+    }
     fn has_local_statement(&mut self) -> bool {
         /* To avoid ambiguity, we look ahead to find either the
         channel keyword that signals a variable declaration, or
         a type annotation followed by another identifier.
         Example:
           my_type[] x = {5}; // memory statement
           my_var[5] = x; // assignment expression, expression statement
         Note how both the local and the assignment
         start with arbitrary identifier followed by [. */
         if self.has_keyword(b"channel") {
             return true;
+        }
         if self.has_statement_keyword() {
             return false;
+        }
         let backup_pos = self.source.pos();
         let mut result = false;
         if self.maybe_consume_type_spilled_without_pos_recovery() {
             // We seem to have a valid type, do we now have an identifier?
             if self.consume_whitespace(true).is_ok() {
                 result = self.has_identifier();
+            }
+        }
         self.source.seek(backup_pos);
         return result;
+    }
     fn consume_block_statement(&mut self, h: &mut Heap) -> Result<StatementId, ParseError2> {
         let position = self.source.pos();
         let mut statements = Vec::new();
         self.consume_string(b"{")?;
         self.consume_whitespace(false)?;
         while self.has_local_statement() {
             statements.push(self.consume_local_statement(h)?.upcast());
             self.consume_whitespace(false)?;
+        }
         while !self.has_string(b"}") {
             statements.push(self.consume_statement(h, false)?);
             self.consume_whitespace(false)?;
+        }
         self.consume_string(b"}")?;
         if statements.is_empty() {
             Ok(h.alloc_skip_statement(|this| SkipStatement { this, position, next: None }).upcast())
         } else {
             Ok(h.alloc_block_statement(|this| BlockStatement {
                 this,
                 position,
                 statements,
                 parent_scope: None,
                 relative_pos_in_parent: 0,
                 locals: Vec::new(),
                 labels: Vec::new(),
             })
             .upcast())
+        }
+    }
     fn consume_local_statement(&mut self, h: &mut Heap) -> Result<LocalStatementId, ParseError2> {
         if self.has_keyword(b"channel") {
             Ok(self.consume_channel_statement(h)?.upcast())
         } else {
             Ok(self.consume_memory_statement(h)?.upcast())
+        }
+    }
     fn consume_channel_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<ChannelStatementId, ParseError2> {
         // Consume channel statement and polymorphic argument if specified
         let position = self.source.pos();
         self.consume_keyword(b"channel")?;
         let poly_args = self.consume_polymorphic_args(h, true)?;
         let poly_arg_id = match poly_args.len() {
 => h.alloc_parser_type(|this| ParserType{
                 this, pos: position.clone(), variant: ParserTypeVariant::Inferred,
             }),
 => poly_args[0],
             _ => return Err(ParseError2::new_error(
                 &self.source, self.source.pos(),
                 "port construction using 'channel' accepts up to 1 polymorphic argument"
             ))
         };
         self.consume_whitespace(true)?;
         // Consume the output port
         let out_parser_type = h.alloc_parser_type(|this| ParserType{
             this, pos: position.clone(), variant: ParserTypeVariant::Output(poly_arg_id)
         });
         let out_identifier = self.consume_identifier()?;
         // Consume the "->" syntax
         self.consume_whitespace(false)?;
         self.consume_string(b"->")?;
         self.consume_whitespace(false)?;
         // Consume the input port
         // TODO: Unsure about this, both ports refer to the same ParserType, is this ok?
         let in_parser_type = h.alloc_parser_type(|this| ParserType{
             this, pos: position.clone(), variant: ParserTypeVariant::Input(poly_arg_id)
         });
         let in_identifier = self.consume_identifier()?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         let out_port = h.alloc_local(|this| Local {
             this,
             position,
             parser_type: out_parser_type,
             identifier: out_identifier,
             relative_pos_in_block: 0
         });
         let in_port = h.alloc_local(|this| Local {
             this,
             position,
             parser_type: in_parser_type,
             identifier: in_identifier,
             relative_pos_in_block: 0
         });
         Ok(h.alloc_channel_statement(|this| ChannelStatement {
             this,
             position,
             from: out_port,
             to: in_port,
             relative_pos_in_block: 0,
             next: None,
         }))
+    }
     fn consume_memory_statement(&mut self, h: &mut Heap) -> Result<MemoryStatementId, ParseError2> {
         let position = self.source.pos();
         let parser_type = self.consume_type2(h, true)?;
         self.consume_whitespace(true)?;
         let identifier = self.consume_identifier()?;
         self.consume_whitespace(false)?;
         self.consume_string(b"=")?;
         self.consume_whitespace(false)?;
         let initial = self.consume_expression(h)?;
         let variable = h.alloc_local(|this| Local {
             this,
             position,
             parser_type,
             identifier,
             relative_pos_in_block: 0
         });
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_memory_statement(|this| MemoryStatement {
             this,
             position,
             variable,
             initial,
             next: None,
         }))
+    }
     fn consume_labeled_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<LabeledStatementId, ParseError2> {
         let position = self.source.pos();
         let label = self.consume_identifier()?;
         self.consume_whitespace(false)?;
         self.consume_string(b":")?;
         self.consume_whitespace(false)?;
         let body = self.consume_statement(h, false)?;
         Ok(h.alloc_labeled_statement(|this| LabeledStatement {
             this,
             position,
             label,
             body,
             relative_pos_in_block: 0,
             in_sync: None,
         }))
+    }
     fn consume_skip_statement(&mut self, h: &mut Heap) -> Result<SkipStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"skip")?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_skip_statement(|this| SkipStatement { this, position, next: None }))
+    }
     fn consume_if_statement(&mut self, h: &mut Heap) -> Result<IfStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"if")?;
         self.consume_whitespace(false)?;
         let test = self.consume_paren_expression(h)?;
         self.consume_whitespace(false)?;
         let true_body = self.consume_statement(h, true)?;
         self.consume_whitespace(false)?;
         let false_body = if self.has_keyword(b"else") {
             self.consume_keyword(b"else")?;
             self.consume_whitespace(false)?;
             self.consume_statement(h, true)?
         } else {
             h.alloc_skip_statement(|this| SkipStatement { this, position, next: None }).upcast()
         };
         Ok(h.alloc_if_statement(|this| IfStatement { this, position, test, true_body, false_body, end_if: None }))
+    }
     fn consume_while_statement(&mut self, h: &mut Heap) -> Result<WhileStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"while")?;
         self.consume_whitespace(false)?;
         let test = self.consume_paren_expression(h)?;
         self.consume_whitespace(false)?;
         let body = self.consume_statement(h, true)?;
         Ok(h.alloc_while_statement(|this| WhileStatement {
             this,
             position,
             test,
             body,
             end_while: None,
             in_sync: None,
         }))
+    }
     fn consume_break_statement(&mut self, h: &mut Heap) -> Result<BreakStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"break")?;
         self.consume_whitespace(false)?;
         let label;
         if self.has_identifier() {
             label = Some(self.consume_identifier()?);
             self.consume_whitespace(false)?;
         } else {
             label = None;
+        }
         self.consume_string(b";")?;
         Ok(h.alloc_break_statement(|this| BreakStatement { this, position, label, target: None }))
+    }
     fn consume_continue_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<ContinueStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"continue")?;
         self.consume_whitespace(false)?;
         let label;
         if self.has_identifier() {
             label = Some(self.consume_identifier()?);
             self.consume_whitespace(false)?;
         } else {
             label = None;
+        }
         self.consume_string(b";")?;
         Ok(h.alloc_continue_statement(|this| ContinueStatement {
             this,
             position,
             label,
             target: None,
         }))
+    }
     fn consume_synchronous_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<SynchronousStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"synchronous")?;
         self.consume_whitespace(false)?;
         // TODO: What was the purpose of this? Seems superfluous and confusing?
         // let mut parameters = Vec::new();
         // if self.has_string(b"(") {
         //     self.consume_parameters(h, &mut parameters)?;
         //     self.consume_whitespace(false)?;
         // } else if !self.has_keyword(b"skip") && !self.has_string(b"{") {
         //     return Err(self.error_at_pos("Expected block statement"));
         // }
         let body = self.consume_statement(h, true)?;
         Ok(h.alloc_synchronous_statement(|this| SynchronousStatement {
             this,
             position,
             body,
             end_sync: None,
             parent_scope: None,
         }))
+    }
     fn consume_return_statement(&mut self, h: &mut Heap) -> Result<ReturnStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"return")?;
         self.consume_whitespace(false)?;
         let expression = if self.has_string(b"(") {
             self.consume_paren_expression(h)
         } else {
             self.consume_expression(h)
         }?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_return_statement(|this| ReturnStatement { this, position, expression }))
+    }
     fn consume_assert_statement(&mut self, h: &mut Heap) -> Result<AssertStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"assert")?;
         self.consume_whitespace(false)?;
         let expression = if self.has_string(b"(") {
             self.consume_paren_expression(h)
         } else {
             self.consume_expression(h)
         }?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_assert_statement(|this| AssertStatement {
             this,
             position,
             expression,
             next: None,
         }))
+    }
     fn consume_goto_statement(&mut self, h: &mut Heap) -> Result<GotoStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"goto")?;
         self.consume_whitespace(false)?;
         let label = self.consume_identifier()?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_goto_statement(|this| GotoStatement { this, position, label, target: None }))
+    }
     fn consume_new_statement(&mut self, h: &mut Heap) -> Result<NewStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"new")?;
         self.consume_whitespace(false)?;
         let expression = self.consume_call_expression(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_new_statement(|this| NewStatement { this, position, expression, next: None }))
+    }
     fn consume_expression_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<ExpressionStatementId, ParseError2> {
         let position = self.source.pos();
         let expression = self.consume_expression(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_expression_statement(|this| ExpressionStatement {
             this,
             position,
             expression,
             next: None,
         }))
+    }
     // ====================
     // Symbol definitions
     // ====================
     fn has_symbol_definition(&self) -> bool {
         self.has_keyword(b"composite")
             || self.has_keyword(b"primitive")
             || self.has_type_keyword()
             || self.has_identifier()
+    }
     fn consume_symbol_definition(&mut self, h: &mut Heap) -> Result<DefinitionId, ParseError2> {
         if self.has_keyword(b"struct") {
             Ok(self.consume_struct_definition(h)?.upcast())
         } else if self.has_keyword(b"enum") {
             Ok(self.consume_enum_definition(h)?.upcast())
         } else if self.has_keyword(b"composite") || self.has_keyword(b"primitive") {
             Ok(self.consume_component_definition(h)?.upcast())
         } else {
             Ok(self.consume_function_definition(h)?.upcast())
+        }
+    }
     fn consume_struct_definition(&mut self, h: &mut Heap) -> Result<StructId, ParseError2> {
         // Parse "struct" keyword, optional polyvars and its identifier
         let struct_pos = self.source.pos();
         self.consume_keyword(b"struct")?;
         self.consume_whitespace(true)?;
         let struct_ident = self.consume_identifier()?;
         let poly_vars = self.consume_polymorphic_vars()?;
         self.consume_whitespace(false)?;
         // Parse struct fields
         self.consume_string(b"{")?;
         let mut next = self.source.next();
         let mut fields = Vec::new();
         while next.is_some() {
             let char = next.unwrap();
             if char == b'}' {
                 break;
+            }
             // Consume field definition
             self.consume_whitespace(false)?;
             let field_position = self.source.pos();
             let field_parser_type = self.consume_type2(h, false)?;
             self.consume_whitespace(true)?;
             let field_ident = self.consume_identifier()?;
             self.consume_whitespace(false)?;
             fields.push(StructFieldDefinition{
                 position: field_position,
                 field: field_ident,
                 parser_type: field_parser_type,
             });
             // If we have a comma, then we may or may not have another field
             // definition. Otherwise we expect the struct to be fully defined
             // and expect a closing brace
             next = self.source.next();
             if let Some(b',') = next {
                 self.source.consume();
                 self.consume_whitespace(false)?;
                 next = self.source.next();
             } else {
                 break;
+            }
+        }
         // End of struct definition, so we expect a closing brace
         self.consume_string(b"}")?;
         // Valid struct definition
         Ok(h.alloc_struct_definition(|this| StructDefinition{
             this,
             position: struct_pos,
             identifier: struct_ident,
             poly_vars,
             fields,
         }))
+    }
     fn consume_enum_definition(&mut self, h: &mut Heap) -> Result<EnumId, ParseError2> {
         // Parse "enum" keyword, optional polyvars and its identifier
         let enum_pos = self.source.pos();
         self.consume_keyword(b"enum")?;
         self.consume_whitespace(true)?;
         let enum_ident = self.consume_identifier()?;
         let poly_vars = self.consume_polymorphic_vars()?;
         self.consume_whitespace(false)?;
         // Parse enum variants
         self.consume_string(b"{")?;
         let mut next = self.source.next();
         let mut variants = Vec::new();
         while next.is_some() {
             let char = next.unwrap();
             if char == b'}' {
                 break;
+            }
             // Consume variant identifier
             self.consume_whitespace(false)?;
             let variant_position = self.source.pos();
             let variant_ident = self.consume_identifier()?;
             self.consume_whitespace(false)?;
             // Consume variant (tag) value: may be nothing, in which case it is
             // assigned automatically, may be a constant integer, or an embedded
             // type as value, resulting in a tagged union
             next = self.source.next();
             let variant_value = if let Some(b',') = next {
                 EnumVariantValue::None
             } else if let Some(b'=') = next {
                 self.source.consume();
                 self.consume_whitespace(false)?;
                 if !self.has_integer() {
                     return Err(self.error_at_pos("expected integer"));
+                }
                 let variant_int = self.consume_integer()?;
                 self.consume_whitespace(false)?;
                 EnumVariantValue::Integer(variant_int)
             } else if let Some(b'(') = next {
                 self.source.consume();
                 self.consume_whitespace(false)?;
                 let variant_type = self.consume_type2(h, false)?;
                 self.consume_whitespace(false)?;
                 self.consume_string(b")")?;
                 self.consume_whitespace(false)?;
                 EnumVariantValue::Type(variant_type)
             } else {
                 return Err(self.error_at_pos("expected ',', '=', or '('"));
             };
             variants.push(EnumVariantDefinition{
                 position: variant_position,
                 identifier: variant_ident,
                 value: variant_value
             });
             // If we have a comma, then we may or may not have another variant,
             // otherwise we expect the enum is fully defined
             next = self.source.next();
             if let Some(b',') = next {
                 self.source.consume();
                 self.consume_whitespace(false)?;
                 next = self.source.next();
             } else {
                 break;
+            }
+        }
         self.consume_string(b"}")?;
         // An enum without variants is somewhat valid, but completely useless
         // within the language
         if variants.is_empty() {
             return Err(ParseError2::new_error(self.source, enum_pos, "enum definition without variants"));
+        }
         Ok(h.alloc_enum_definition(|this| EnumDefinition{
             this,
             position: enum_pos,
             identifier: enum_ident,
             poly_vars,
             variants,
         }))
+    }
     fn consume_component_definition(&mut self, h: &mut Heap) -> Result<ComponentId, ParseError2> {
         // TODO: Cleanup
         if self.has_keyword(b"composite") {
             Ok(self.consume_composite_definition(h)?)
         } else {
             Ok(self.consume_primitive_definition(h)?)
+        }
+    }
     fn consume_composite_definition(&mut self, h: &mut Heap) -> Result<ComponentId, ParseError2> {
         // Parse keyword, optional polyvars and the identifier
         let position = self.source.pos();
         self.consume_keyword(b"composite")?;
         self.consume_whitespace(true)?;
         let identifier = self.consume_identifier()?;
         let poly_vars = self.consume_polymorphic_vars()?;
         self.consume_whitespace(false)?;
         // Consume parameters
         let mut parameters = Vec::new();
         self.consume_parameters(h, &mut parameters)?;
         self.consume_whitespace(false)?;
         // Parse body
         let body = self.consume_block_statement(h)?;
         Ok(h.alloc_component(|this| Component {
             this,
             variant: ComponentVariant::Composite,
             position,
             identifier,
             poly_vars,
             parameters,
             body
         }))
+    }
     fn consume_primitive_definition(&mut self, h: &mut Heap) -> Result<ComponentId, ParseError2> {
         // Consume keyword, optional polyvars and identifier
         let position = self.source.pos();
         self.consume_keyword(b"primitive")?;
         self.consume_whitespace(true)?;
         let identifier = self.consume_identifier()?;
         let poly_vars = self.consume_polymorphic_vars()?;
         self.consume_whitespace(false)?;
         // Consume parameters
         let mut parameters = Vec::new();
         self.consume_parameters(h, &mut parameters)?;
         self.consume_whitespace(false)?;
         // Consume body
         let body = self.consume_block_statement(h)?;
         Ok(h.alloc_component(|this| Component {
             this,
             variant: ComponentVariant::Primitive,
             position,
             identifier,
             poly_vars,
             parameters,
             body
         }))
+    }
     fn consume_function_definition(&mut self, h: &mut Heap) -> Result<FunctionId, ParseError2> {
         // Consume return type, optional polyvars and identifier
         let position = self.source.pos();
         let return_type = self.consume_type2(h, false)?;
         self.consume_whitespace(true)?;
         let identifier = self.consume_identifier()?;
         let poly_vars = self.consume_polymorphic_vars()?;
         self.consume_whitespace(false)?;
         // Consume parameters
         let mut parameters = Vec::new();
         self.consume_parameters(h, &mut parameters)?;
         self.consume_whitespace(false)?;
         // Consume body
         let body = self.consume_block_statement(h)?;
         Ok(h.alloc_function(|this| Function {
             this,
             position,
             return_type,
             identifier,
             poly_vars,
             parameters,
             body,
         }))
+    }
     fn has_pragma(&self) -> bool {
         if let Some(c) = self.source.next() {
             c == b'#'
         } else {
             false
+        }
+    }
     fn consume_pragma(&mut self, h: &mut Heap) -> Result<PragmaId, ParseError2> {
         let position = self.source.pos();
         let next = self.source.next();
         if next != Some(b'#') {
             return Err(self.error_at_pos("Expected pragma"));
+        }
         self.source.consume();
         if !is_vchar(self.source.next()) {
             return Err(self.error_at_pos("Expected pragma"));
+        }
         if self.has_string(b"version") {
             self.consume_string(b"version")?;
             self.consume_whitespace(true)?;
             if !self.has_integer() {
                 return Err(self.error_at_pos("Expected integer constant"));
+            }
             let version = self.consume_integer()?;
             debug_assert!(version >= 0);
             return Ok(h.alloc_pragma(|this| Pragma::Version(PragmaVersion{
                 this, position, version: version as u64
             })))
         } else if self.has_string(b"module") {
             self.consume_string(b"module")?;
             self.consume_whitespace(true)?;
             if !self.has_identifier() {
                 return Err(self.error_at_pos("Expected identifier"));
+            }
             let mut value = Vec::new();
             let mut ident = self.consume_ident()?;
             value.append(&mut ident);
             while self.has_string(b".") {
                 self.consume_string(b".")?;
                 value.push(b'.');
                 ident = self.consume_ident()?;
                 value.append(&mut ident);
+            }
             return Ok(h.alloc_pragma(|this| Pragma::Module(PragmaModule{
                 this, position, value
             })));
         } else {
             return Err(self.error_at_pos("Unknown pragma"));
+        }
+    }
     fn has_import(&self) -> bool {
         self.has_keyword(b"import")
+    }
     fn consume_import(&mut self, h: &mut Heap) -> Result<ImportId, ParseError2> {
         // Parse the word "import" and the name of the module
         let position = self.source.pos();
         self.consume_keyword(b"import")?;
         self.consume_whitespace(true)?;
         let mut value = Vec::new();
         let mut ident = self.consume_ident()?;
         value.append(&mut ident);
         let mut last_ident_start = 0;
         while self.has_string(b".") {
             self.consume_string(b".")?;
             value.push(b'.');
             ident = self.consume_ident()?;
             last_ident_start = value.len();
             value.append(&mut ident);
+        }
         self.consume_whitespace(false)?;
         // Check for the potential aliasing or specific module imports
         let import = if self.has_string(b"as") {
             self.consume_string(b"as")?;
             self.consume_whitespace(true)?;
             let alias = self.consume_ident()?;
             h.alloc_import(|this| Import::Module(ImportModule{
                 this,
                 position,
                 module_name: value,
                 alias,
                 module_id: None,
             }))
         } else if self.has_string(b"::") {
             self.consume_string(b"::")?;
             self.consume_whitespace(false)?;
             if let Some(b'{') = self.source.next() {
                 // Import specific symbols, optionally with an alias
                 self.source.consume();
                 self.consume_whitespace(false)?;
                 let mut symbols = Vec::new();
                 let mut next = self.source.next();
                 while next.is_some() {
                     let char = next.unwrap();
                     if char == b'}' {
                         break;
+                    }
                     let symbol_position = self.source.pos();
                     let symbol_name = self.consume_ident()?;
                     self.consume_whitespace(false)?;
                     if self.has_string(b"as") {
                         // Symbol has an alias
                         self.consume_string(b"as")?;
                         self.consume_whitespace(true)?;
                         let symbol_alias = self.consume_ident()?;
                         symbols.push(AliasedSymbol{
                             position: symbol_position,
                             name: symbol_name,
                             alias: symbol_alias,
                             definition_id: None,
                         });
                     } else {
                         // Symbol does not have an alias
                         symbols.push(AliasedSymbol{
                             position: symbol_position,
                             name: symbol_name.clone(),
                             alias: symbol_name,
                             definition_id: None,
                         });
+                    }
                     // A comma indicates that we may have another symbol coming
                     // up (not necessary), but if not present then we expect the
                     // end of the symbol list
                     self.consume_whitespace(false)?;
                     next = self.source.next();
                     if let Some(b',') = next {
                         self.source.consume();
                         self.consume_whitespace(false)?;
                         next = self.source.next();
                     } else {
                         break;
+                    }
+                }
                 if let Some(b'}') = next {
                     // We are fine, push the imported symbols
                     self.source.consume();
                     if symbols.is_empty() {
                         return Err(ParseError2::new_error(self.source, position, "empty symbol import list"));
+                    }
                     h.alloc_import(|this| Import::Symbols(ImportSymbols{
                         this,
                         position,
                         module_name: value,
                         module_id: None,
                         symbols,
                     }))
                 } else {
                     return Err(self.error_at_pos("Expected '}'"));
+                }
             } else if let Some(b'*') = self.source.next() {
                 // Import all symbols without alias
                 self.source.consume();
                 h.alloc_import(|this| Import::Symbols(ImportSymbols{
                     this,
                     position,
                     module_name: value,
                     module_id: None,
                     symbols: Vec::new()
                 }))
             } else {
                 return Err(self.error_at_pos("Expected '*' or '{'"));
+            }
         } else {
             // No explicit alias or subimports, so implicit alias
             let alias = Vec::from(&value[last_ident_start..]);
             h.alloc_import(|this| Import::Module(ImportModule{
                 this,
                 position,
                 module_name: value,
                 alias,
                 module_id: None,
             }))
         };
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(import)
+    }
     pub fn consume_protocol_description(&mut self, h: &mut Heap) -> Result<RootId, ParseError2> {
         let position = self.source.pos();
         let mut pragmas = Vec::new();
         let mut imports = Vec::new();
         let mut definitions = Vec::new();
         self.consume_whitespace(false)?;
         while self.has_pragma() {
             let pragma = self.consume_pragma(h)?;
             pragmas.push(pragma);
             self.consume_whitespace(false)?;
+        }
         while self.has_import() {
             let import = self.consume_import(h)?;
             imports.push(import);
             self.consume_whitespace(false)?;
+        }
         while self.has_symbol_definition() {
             let def = self.consume_symbol_definition(h)?;
             definitions.push(def);
             self.consume_whitespace(false)?;
+        }
         // end of file
         if !self.source.is_eof() {
             return Err(self.error_at_pos("Expected end of file"));
+        }
         Ok(h.alloc_protocol_description(|this| Root {
             this,
             position,
             pragmas,
             imports,
             definitions,
         }))
+    }
+}
 #[cfg(test)]
 mod tests {
     use crate::protocol::ast::*;
     use crate::protocol::lexer::*;
     use crate::protocol::inputsource::*;
     #[derive(Debug, Eq, PartialEq)]
     enum ParserTypeClass {
         Message, Bool, Byte, Short, Int, Long, String, Array, Nope
+    }
     impl ParserTypeClass {
         fn from(v: &ParserType) -> ParserTypeClass {
             use ParserTypeVariant as PTV;
             use ParserTypeClass as PTC;
             match &v.variant {
                 PTV::Message => PTC::Message,
                 PTV::Bool => PTC::Bool,
                 PTV::Byte => PTC::Byte,
                 PTV::Short => PTC::Short,
                 PTV::Int => PTC::Int,
                 PTV::Long => PTC::Long,
                 PTV::String => PTC::String,
                 PTV::Array(_) => PTC::Array,
                 _ => PTC::Nope,
+            }
+        }
+    }
     #[test]
     fn test_pragmas() {
         let mut h = Heap::new();
         let mut input = InputSource::from_string("
         #version 0o7777
         #module something.dot.separated
         ").expect("new InputSource");
         let mut lex = Lexer::new(&mut input);
         let lexed = lex.consume_protocol_description(&mut h)
             .expect("lex input source");
         let root = &h[lexed];
         assert_eq!(root.pragmas.len(), 2);
         let pv = &h[root.pragmas[0]];
         let pm = &h[root.pragmas[1]];
         if let Pragma::Version(v) = pv {
             assert_eq!(v.version, 0o7777)
         } else {
             assert!(false, "first pragma not version");
+        }
         if let Pragma::Module(m) = pm {
             assert_eq!(m.value, b"something.dot.separated");
         } else {
             assert!(false, "second pragma not module");
+        }
+    }
     #[test]
     fn test_import() {
         let mut h = Heap::new();
         let mut input = InputSource::from_string("
         // Module imports, with optional and explicit aliasing
         import single_module;
         import std.reo;
         import something.other as alias;
         // Symbol imports
         import some_module::*;
         import some_module::{Foo as Bar, Qux, Dix as Flu};
         import std.reo::{
             Foo as Bar, // because thing
             Qux as Mox, // more explanations
             Dix, /* yesh, import me */
         };
         ").unwrap();
         let mut lex = Lexer::new(&mut input);
         let lexed = lex.consume_protocol_description(&mut h).unwrap();
         let root = &h[lexed];
         assert_eq!(root.imports.len(), 6);
         let no_alias_single = h[root.imports[0]].as_module();
         let no_alias_multi = h[root.imports[1]].as_module();
         let with_alias = h[root.imports[2]].as_module();
         assert_eq!(no_alias_single.module_name, b"single_module");
         assert_eq!(no_alias_single.alias, b"single_module");
         assert_eq!(no_alias_multi.module_name, b"std.reo");
         assert_eq!(no_alias_multi.alias, b"reo");
         assert_eq!(with_alias.module_name, b"something.other");
         assert_eq!(with_alias.alias, b"alias");
         let all_symbols = h[root.imports[3]].as_symbols();
         let single_line_symbols = h[root.imports[4]].as_symbols();
         let multi_line_symbols = h[root.imports[5]].as_symbols();
         assert_eq!(all_symbols.module_name, b"some_module");
         assert!(all_symbols.symbols.is_empty());
         assert_eq!(single_line_symbols.module_name, b"some_module");
         assert_eq!(single_line_symbols.symbols.len(), 3);
         assert_eq!(single_line_symbols.symbols[0].name, b"Foo");
         assert_eq!(single_line_symbols.symbols[0].alias, b"Bar");
         assert_eq!(single_line_symbols.symbols[1].name, b"Qux");
         assert_eq!(single_line_symbols.symbols[1].alias, b"Qux");
         assert_eq!(single_line_symbols.symbols[2].name, b"Dix");
         assert_eq!(single_line_symbols.symbols[2].alias, b"Flu");
         assert_eq!(multi_line_symbols.module_name, b"std.reo");
         assert_eq!(multi_line_symbols.symbols.len(), 3);
         assert_eq!(multi_line_symbols.symbols[0].name, b"Foo");
         assert_eq!(multi_line_symbols.symbols[0].alias, b"Bar");
         assert_eq!(multi_line_symbols.symbols[1].name, b"Qux");
         assert_eq!(multi_line_symbols.symbols[1].alias, b"Mox");
         assert_eq!(multi_line_symbols.symbols[2].name, b"Dix");
         assert_eq!(multi_line_symbols.symbols[2].alias, b"Dix");
+    }
     #[test]
     fn test_struct_definition() {
         let mut h = Heap::new();
         let mut input = InputSource::from_string("
         struct Foo {
             byte one,
             short two,
             Bar three,
+        }
         struct Bar{int[] one, int[] two, Qux[] three}
         ").unwrap();
         let mut lex = Lexer::new(&mut input);
         let lexed = lex.consume_protocol_description(&mut h);
         if let Err(err) = &lexed {
             println!("{}", err);
+        }
         let lexed = lexed.unwrap();
         let root = &h[lexed];
         assert_eq!(root.definitions.len(), 2);
         // let symbolic_type = |v: &PrimitiveType| -> Vec<u8> {
         //     if let PrimitiveType::Symbolic(v) = v {
         //         v.identifier.value.clone()
         //     } else {
         //         assert!(false);
         //         unreachable!();
         //     }
         // };
         let foo_def = h[root.definitions[0]].as_struct();
         assert_eq!(foo_def.identifier.value, b"Foo");
         assert_eq!(foo_def.fields.len(), 3);
         assert_eq!(foo_def.fields[0].field.value, b"one");
         assert_eq!(ParserTypeClass::from(&h[foo_def.fields[0].parser_type]), ParserTypeClass::Byte);
         assert_eq!(foo_def.fields[1].field.value, b"two");
         assert_eq!(ParserTypeClass::from(&h[foo_def.fields[1].parser_type]), ParserTypeClass::Short);
         assert_eq!(foo_def.fields[2].field.value, b"three");
         // assert_eq!(
         //     symbolic_type(&h[foo_def.fields[2].the_type].the_type.primitive),
         //     Vec::from("Bar".as_bytes())
         // );
         let bar_def = h[root.definitions[1]].as_struct();
         assert_eq!(bar_def.identifier.value, b"Bar");
         assert_eq!(bar_def.fields.len(), 3);
         assert_eq!(bar_def.fields[0].field.value, b"one");
         assert_eq!(ParserTypeClass::from(&h[bar_def.fields[0].parser_type]), ParserTypeClass::Array);
         assert_eq!(bar_def.fields[1].field.value, b"two");
         assert_eq!(ParserTypeClass::from(&h[bar_def.fields[1].parser_type]), ParserTypeClass::Array);
         assert_eq!(bar_def.fields[2].field.value, b"three");
         assert_eq!(ParserTypeClass::from(&h[bar_def.fields[2].parser_type]), ParserTypeClass::Array);
         // assert_eq!(
         //     symbolic_type(&h[bar_def.fields[2].parser_type].the_type.primitive),
         //     Vec::from("Qux".as_bytes())
         // );
+    }
     #[test]
     fn test_enum_definition() {
         let mut h = Heap::new();
         let mut input = InputSource::from_string("
         enum Foo {
             A = 0,
             B = 5,
             C,
             D = 0xFF,
+        }
         enum Bar { Ayoo, Byoo, Cyoo,}
         enum Qux { A(byte[]), B(Bar[]), C(byte)
+        }
         ").unwrap();
         let mut lex = Lexer::new(&mut input);
         let lexed = lex.consume_protocol_description(&mut h).unwrap();
         let root = &h[lexed];
         assert_eq!(root.definitions.len(), 3);
         let foo_def = h[root.definitions[0]].as_enum();
         assert_eq!(foo_def.identifier.value, b"Foo");
         assert_eq!(foo_def.variants.len(), 4);
         assert_eq!(foo_def.variants[0].identifier.value, b"A");
         assert_eq!(foo_def.variants[0].value, EnumVariantValue::Integer(0));
         assert_eq!(foo_def.variants[1].identifier.value, b"B");
         assert_eq!(foo_def.variants[1].value, EnumVariantValue::Integer(5));
         assert_eq!(foo_def.variants[2].identifier.value, b"C");
         assert_eq!(foo_def.variants[2].value, EnumVariantValue::None);
         assert_eq!(foo_def.variants[3].identifier.value, b"D");
         assert_eq!(foo_def.variants[3].value, EnumVariantValue::Integer(0xFF));
         let bar_def = h[root.definitions[1]].as_enum();
         assert_eq!(bar_def.identifier.value, b"Bar");
         assert_eq!(bar_def.variants.len(), 3);
         assert_eq!(bar_def.variants[0].identifier.value, b"Ayoo");
         assert_eq!(bar_def.variants[0].value, EnumVariantValue::None);
         assert_eq!(bar_def.variants[1].identifier.value, b"Byoo");
         assert_eq!(bar_def.variants[1].value, EnumVariantValue::None);
         assert_eq!(bar_def.variants[2].identifier.value, b"Cyoo");
         assert_eq!(bar_def.variants[2].value, EnumVariantValue::None);
         let qux_def = h[root.definitions[2]].as_enum();
         let enum_type = |value: &EnumVariantValue| -> &ParserType {
             if let EnumVariantValue::Type(t) = value {
                 &h[*t]
             } else {
                 assert!(false);
                 unreachable!();
+            }
         };
         assert_eq!(qux_def.identifier.value, b"Qux");
         assert_eq!(qux_def.variants.len(), 3);
         assert_eq!(qux_def.variants[0].identifier.value, b"A");
         assert_eq!(ParserTypeClass::from(enum_type(&qux_def.variants[0].value)), ParserTypeClass::Array);
         assert_eq!(qux_def.variants[1].identifier.value, b"B");
         assert_eq!(ParserTypeClass::from(enum_type(&qux_def.variants[1].value)), ParserTypeClass::Array);
         // if let PrimitiveType::Symbolic(t) = &enum_type(&qux_def.variants[1].value).the_type.primitive {
         //     assert_eq!(t.identifier.value, Vec::from("Bar".as_bytes()));
         // } else { assert!(false) }
         assert_eq!(qux_def.variants[2].identifier.value, b"C");
         assert_eq!(ParserTypeClass::from(enum_type(&qux_def.variants[2].value)), ParserTypeClass::Byte);
+    }
 //     #[test]
 //     fn test_lowercase() {
 //         assert_eq!(lowercase(b'a'), b'a');
 //         assert_eq!(lowercase(b'A'), b'a');
 //         assert_eq!(lowercase(b'z'), b'z');
 //         assert_eq!(lowercase(b'Z'), b'z');
 //     }
 //     #[test]
 //     fn test_basic_expression() {
 //         let mut h = Heap::new();
 //         let mut is = InputSource::from_string("a+b;").unwrap();
 //         let mut lex = Lexer::new(&mut is);
 //         match lex.consume_expression(&mut h) {
 //             Ok(expr) => {
 //                 println!("{:?}", expr);
 //                 if let Binary(bin) = &h[expr] {
 //                     if let Variable(left) = &h[bin.left] {
 //                         if let Variable(right) = &h[bin.right] {
 //                             assert_eq!("a", format!("{}", h[left.identifier]));
 //                             assert_eq!("b", format!("{}", h[right.identifier]));
 //                             assert_eq!(Some(b';'), is.next());
 //                             return;
 //                         }
 //                     }
 //                 }
 //                 assert!(false);
 //             }
 //             Err(err) => {
 //                 err.print(&is);
 //                 assert!(false);
 //             }
 //         }
 //     }
 //     #[test]
 //     fn test_paren_expression() {
 //         let mut h = Heap::new();
 //         let mut is = InputSource::from_string("(true)").unwrap();
 //         let mut lex = Lexer::new(&mut is);
 //         match lex.consume_paren_expression(&mut h) {
 //             Ok(expr) => {
 //                 println!("{:#?}", expr);
 //                 if let Constant(con) = &h[expr] {
 //                     if let ast::Constant::True = con.value {
 //                         return;
 //                     }
 //                 }
 //                 assert!(false);
 //             }
 //             Err(err) => {
 //                 err.print(&is);
 //                 assert!(false);
 //             }
 //         }
 //     }
 //     #[test]
 //     fn test_expression() {
 //         let mut h = Heap::new();
 //         let mut is = InputSource::from_string("(x(1+5,get(y))-w[5])+z++\n").unwrap();
 //         let mut lex = Lexer::new(&mut is);
 //         match lex.consume_expression(&mut h) {
 //             Ok(expr) => {
 //                 println!("{:#?}", expr);
 //             }
 //             Err(err) => {
 //                 err.print(&is);
 //                 assert!(false);
 //             }
 //         }
 //     }
 //     #[test]
 //     fn test_basic_statement() {
 //         let mut h = Heap::new();
 //         let mut is = InputSource::from_string("while (true) { skip; }").unwrap();
 //         let mut lex = Lexer::new(&mut is);
 //         match lex.consume_statement(&mut h) {
 //             Ok(stmt) => {
 //                 println!("{:#?}", stmt);
 //                 if let Statement::While(w) = &h[stmt] {
 //                     if let Expression::Constant(_) = h[w.test] {
 //                         if let Statement::Block(_) = h[w.body] {
 //                             return;
 //                         }
 //                     }
 //                 }
 //                 assert!(false);
 //             }
 //             Err(err) => {
 //                 err.print(&is);
 //                 assert!(false);
 //             }
 //         }
 //     }
 //     #[test]
 //     fn test_statement() {
 //         let mut h = Heap::new();
 //         let mut is = InputSource::from_string(
 //             "label: while (true) { if (x++ > y[0]) break label; else continue; }\n",
 //         )
 //         .unwrap();
 //         let mut lex = Lexer::new(&mut is);
 //         match lex.consume_statement(&mut h) {
 //             Ok(stmt) => {
 //                 println!("{:#?}", stmt);
 //             }
 //             Err(err) => {
 //                 err.print(&is);
 //                 assert!(false);
 //             }
 //         }
 //     }
+}

src/protocol/mod.rs

➞

Show inline comments

 mod arena;
 // mod ast;
 mod eval;
 pub(crate) mod inputsource;
 // mod lexer;
 mod parser;
 // TODO: Remove when not benchmarking
 pub(crate) mod ast;
 pub(crate) mod ast_printer;
 pub(crate) mod lexer;
 lazy_static::lazy_static! {
     /// Conveniently-provided protocol description initialized with a zero-length PDL string.
     /// Exposed to minimize repeated initializations of this common protocol description.
     pub static ref TRIVIAL_PD: std::sync::Arc<ProtocolDescription> = {
         std::sync::Arc::new(ProtocolDescription::parse(b"").unwrap())
     };
+}
 use crate::common::*;
 use crate::protocol::ast::*;
 use crate::protocol::eval::*;
 use crate::protocol::inputsource::*;
 use crate::protocol::parser::*;
 /// Description of a protocol object, used to configure new connectors.
 /// (De)serializable.
 #[derive(serde::Serialize, serde::Deserialize)]
 #[repr(C)]
 pub struct ProtocolDescription {
     heap: Heap,
     source: InputSource,
     root: RootId,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub(crate) struct ComponentState {
     prompt: Prompt,
+}
 pub(crate) enum EvalContext<'a> {
     Nonsync(&'a mut NonsyncProtoContext<'a>),
     Sync(&'a mut SyncProtoContext<'a>),
     // None,
+}
 //////////////////////////////////////////////
 impl std::fmt::Debug for ProtocolDescription {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "(An opaque protocol description)")
+    }
+}
 impl ProtocolDescription {
     pub fn parse(buffer: &[u8]) -> Result<Self, String> {
         // TODO: @fixme, keep code compilable, but needs support for multiple
         //  input files.
         let source = InputSource::from_buffer(buffer).unwrap();
         let mut parser = Parser::new();
         parser.feed(source).expect("failed to parse source");
         match parser.parse() {
             Ok(root) => {
                 return Ok(ProtocolDescription { heap: parser.heap, source: parser.modules[0].source.clone(), root });
+            }
             Err(err) => {
                 println!("ERROR:\n{}", err);
                 Err(format!("{}", err))
+            }
+        }
+    }
     pub(crate) fn component_polarities(
         &self,
         identifier: &[u8],
     ) -> Result<Vec<Polarity>, AddComponentError> {
         use AddComponentError::*;
         let h = &self.heap;
         let root = &h[self.root];
         let def = root.get_definition_ident(h, identifier);
         if def.is_none() {
             return Err(NoSuchComponent);
+        }
         let def = &h[def.unwrap()];
         if !def.is_component() {
             return Err(NoSuchComponent);
+        }
         for &param in def.parameters().iter() {
             let param = &h[param];
             let parser_type = &h[param.parser_type];
             match parser_type.variant {
                 ParserTypeVariant::Input(_) | ParserTypeVariant::Output(_) => continue,
                 _ => {
                     return Err(NonPortTypeParameters);
+                }
+            }
+        }
         let mut result = Vec::new();
         for &param in def.parameters().iter() {
             let param = &h[param];
             let parser_type = &h[param.parser_type];
             if let ParserTypeVariant::Input(_) = parser_type.variant {
                 result.push(Polarity::Getter)
             } else if let ParserTypeVariant::Output(_) = parser_type.variant {
                 result.push(Polarity::Putter)
             } else {
                 unreachable!()
+            }
+        }
         Ok(result)
+    }
     // expects port polarities to be correct
     pub(crate) fn new_component(&self, identifier: &[u8], ports: &[PortId]) -> ComponentState {
         let mut args = Vec::new();
         for (&x, y) in ports.iter().zip(self.component_polarities(identifier).unwrap()) {
             match y {
                 Polarity::Getter => args.push(Value::Input(InputValue(x))),
                 Polarity::Putter => args.push(Value::Output(OutputValue(x))),
+            }
+        }
         let h = &self.heap;
         let root = &h[self.root];
         let def = root.get_definition_ident(h, identifier).unwrap();
         ComponentState { prompt: Prompt::new(h, def, &args) }
+    }
+}
 impl ComponentState {
     pub(crate) fn nonsync_run<'a: 'b, 'b>(
         &'a mut self,
         context: &'b mut NonsyncProtoContext<'b>,
         pd: &'a ProtocolDescription,
     ) -> NonsyncBlocker {
         let mut context = EvalContext::Nonsync(context);
         loop {
             let result = self.prompt.step(&pd.heap, &mut context);
             match result {
                 // In component definitions, there are no return statements
                 Ok(_) => unreachable!(),
                 Err(cont) => match cont {
                     EvalContinuation::Stepping => continue,
                     EvalContinuation::Inconsistent => return NonsyncBlocker::Inconsistent,
                     EvalContinuation::Terminal => return NonsyncBlocker::ComponentExit,
                     EvalContinuation::SyncBlockStart => return NonsyncBlocker::SyncBlockStart,
                     // Not possible to end sync block if never entered one
                     EvalContinuation::SyncBlockEnd => unreachable!(),
                     EvalContinuation::NewComponent(definition_id, args) => {
                         // Look up definition (TODO for now, assume it is a definition)
                         let h = &pd.heap;
                         let init_state = ComponentState { prompt: Prompt::new(h, definition_id, &args) };
                         context.new_component(&args, init_state);
                         // Continue stepping
                         continue;
+                    }
                     // Outside synchronous blocks, no fires/get/put happens
                     EvalContinuation::BlockFires(_) => unreachable!(),
                     EvalContinuation::BlockGet(_) => unreachable!(),
                     EvalContinuation::Put(_, _) => unreachable!(),
                 },
+            }
+        }
+    }
     pub(crate) fn sync_run<'a: 'b, 'b>(
         &'a mut self,
         context: &'b mut SyncProtoContext<'b>,
         pd: &'a ProtocolDescription,
     ) -> SyncBlocker {
         let mut context = EvalContext::Sync(context);
         loop {
             let result = self.prompt.step(&pd.heap, &mut context);
             match result {
                 // Inside synchronous blocks, there are no return statements
                 Ok(_) => unreachable!(),
                 Err(cont) => match cont {
                     EvalContinuation::Stepping => continue,
                     EvalContinuation::Inconsistent => return SyncBlocker::Inconsistent,
                     // First need to exit synchronous block before definition may end
                     EvalContinuation::Terminal => unreachable!(),
                     // No nested synchronous blocks
                     EvalContinuation::SyncBlockStart => unreachable!(),
                     EvalContinuation::SyncBlockEnd => return SyncBlocker::SyncBlockEnd,
                     // Not possible to create component in sync block
                     EvalContinuation::NewComponent(_, _) => unreachable!(),
                     EvalContinuation::BlockFires(port) => match port {
                         Value::Output(OutputValue(port)) => {
                             return SyncBlocker::CouldntCheckFiring(port);
+                        }
                         Value::Input(InputValue(port)) => {
                             return SyncBlocker::CouldntCheckFiring(port);
+                        }
                         _ => unreachable!(),
                     },
                     EvalContinuation::BlockGet(port) => match port {
                         Value::Output(OutputValue(port)) => {
                             return SyncBlocker::CouldntReadMsg(port);
+                        }
                         Value::Input(InputValue(port)) => {
                             return SyncBlocker::CouldntReadMsg(port);
+                        }
                         _ => unreachable!(),
                     },
                     EvalContinuation::Put(port, message) => {
                         let value;
                         match port {
                             Value::Output(OutputValue(port_value)) => {
                                 value = port_value;
+                            }
                             Value::Input(InputValue(port_value)) => {
                                 value = port_value;
+                            }
                             _ => unreachable!(),
+                        }
                         let payload;
                         match message {
                             Value::Message(MessageValue(None)) => {
                                 // Putting a null message is inconsistent
                                 return SyncBlocker::Inconsistent;
+                            }
                             Value::Message(MessageValue(Some(buffer))) => {
                                 // Create a copy of the payload
                                 payload = buffer;
+                            }
                             _ => unreachable!(),
+                        }
                         return SyncBlocker::PutMsg(value, payload);
+                    }
                 },
+            }
+        }
+    }
+}
 impl EvalContext<'_> {
     // fn random(&mut self) -> LongValue {
     //     match self {
     //         // EvalContext::None => unreachable!(),
     //         EvalContext::Nonsync(_context) => todo!(),
     //         EvalContext::Sync(_) => unreachable!(),
     //     }
     // }
     fn new_component(&mut self, args: &[Value], init_state: ComponentState) -> () {
         match self {
             // EvalContext::None => unreachable!(),
             EvalContext::Nonsync(context) => {
                 let mut moved_ports = HashSet::new();
                 for arg in args.iter() {
                     match arg {
                         Value::Output(OutputValue(port)) => {
                             moved_ports.insert(*port);
+                        }
                         Value::Input(InputValue(port)) => {
                             moved_ports.insert(*port);
+                        }
                         _ => {}
+                    }
+                }
                 context.new_component(moved_ports, init_state)
+            }
             EvalContext::Sync(_) => unreachable!(),
+        }
+    }
     fn new_channel(&mut self) -> [Value; 2] {
         match self {
             // EvalContext::None => unreachable!(),
             EvalContext::Nonsync(context) => {
                 let [from, to] = context.new_port_pair();
                 let from = Value::Output(OutputValue(from));
                 let to = Value::Input(InputValue(to));
                 return [from, to];
+            }
             EvalContext::Sync(_) => unreachable!(),
+        }
+    }
     fn fires(&mut self, port: Value) -> Option<Value> {
         match self {
             // EvalContext::None => unreachable!(),
             EvalContext::Nonsync(_) => unreachable!(),
             EvalContext::Sync(context) => match port {
                 Value::Output(OutputValue(port)) => context.is_firing(port).map(Value::from),
                 Value::Input(InputValue(port)) => context.is_firing(port).map(Value::from),
                 _ => unreachable!(),
             },
+        }
+    }
     fn get(&mut self, port: Value) -> Option<Value> {
         match self {
             // EvalContext::None => unreachable!(),
             EvalContext::Nonsync(_) => unreachable!(),
             EvalContext::Sync(context) => match port {
                 Value::Output(OutputValue(port)) => {
                     context.read_msg(port).map(Value::receive_message)
+                }
                 Value::Input(InputValue(port)) => {
                     context.read_msg(port).map(Value::receive_message)
+                }
                 _ => unreachable!(),
             },
+        }
+    }
     fn did_put(&mut self, port: Value) -> bool {
         match self {
             EvalContext::Nonsync(_) => unreachable!("did_put in nonsync context"),
             EvalContext::Sync(context) => match port {
                 Value::Output(OutputValue(port)) => {
-                    context.is_firing(port).unwrap_or(false)
+                    context.did_put_or_get(port)
                 },
                 Value::Input(_) => unreachable!("did_put on input port"),
                 _ => unreachable!("did_put on non-port value")
+            }
+        }
+    }
+}

src/protocol/parser/mod.rs

➞

Show inline comments

 mod depth_visitor;
 mod symbol_table;
 // mod type_table_old;
 mod type_table;
 mod type_resolver;
 mod visitor;
 mod visitor_linker;
 mod utils;
 use depth_visitor::*;
 use symbol_table::SymbolTable;
 use visitor::Visitor2;
 use visitor_linker::ValidityAndLinkerVisitor;
 use type_resolver::{TypeResolvingVisitor, ResolveQueue};
 use type_table::{TypeTable, TypeCtx};
 use crate::protocol::ast::*;
 use crate::protocol::inputsource::*;
 use crate::protocol::lexer::*;
 use std::collections::HashMap;
 use crate::protocol::ast_printer::ASTWriter;
 // TODO: @fixme, pub qualifier
 pub(crate) struct LexedModule {
     pub(crate) source: InputSource,
     module_name: Vec<u8>,
     version: Option<u64>,
     root_id: RootId,
+}
 pub struct Parser {
     pub(crate) heap: Heap,
     pub(crate) modules: Vec<LexedModule>,
     pub(crate) module_lookup: HashMap<Vec<u8>, usize>, // from (optional) module name to `modules` idx
+}
 impl Parser {
     pub fn new() -> Self {
         Parser{
             heap: Heap::new(),
             modules: Vec::new(),
             module_lookup: HashMap::new()
+        }
+    }
     // TODO: @fix, temporary implementation to keep code compilable
     pub fn new_with_source(source: InputSource) -> Result<Self, ParseError2> {
         let mut parser = Parser::new();
         parser.feed(source)?;
         Ok(parser)
+    }
     pub fn feed(&mut self, mut source: InputSource) -> Result<RootId, ParseError2> {
         // Lex the input source
         let mut lex = Lexer::new(&mut source);
         let pd = lex.consume_protocol_description(&mut self.heap)?;
         // Seek the module name and version
         let root = &self.heap[pd];
         let mut module_name_pos = InputPosition::default();
         let mut module_name = Vec::new();
         let mut module_version_pos = InputPosition::default();
         let mut module_version = None;
         for pragma in &root.pragmas {
             match &self.heap[*pragma] {
                 Pragma::Module(module) => {
                     if !module_name.is_empty() {
                         return Err(
                             ParseError2::new_error(&source, module.position, "Double definition of module name in the same file")
                                 .with_postfixed_info(&source, module_name_pos, "Previous definition was here")
+                        )
+                    }
                     module_name_pos = module.position.clone();
                     module_name = module.value.clone();
                 },
                 Pragma::Version(version) => {
                     if module_version.is_some() {
                         return Err(
                             ParseError2::new_error(&source, version.position, "Double definition of module version")
                                 .with_postfixed_info(&source, module_version_pos, "Previous definition was here")
+                        )
+                    }
                     module_version_pos = version.position.clone();
                     module_version = Some(version.version);
                 },
+            }
+        }
         // Add module to list of modules and prevent naming conflicts
         let cur_module_idx = self.modules.len();
         if let Some(prev_module_idx) = self.module_lookup.get(&module_name) {
             // Find `#module` statement in other module again
             let prev_module = &self.modules[*prev_module_idx];
             let prev_module_pos = self.heap[prev_module.root_id].pragmas
                 .iter()
                 .find_map(|p| {
                     match &self.heap[*p] {
                         Pragma::Module(module) => Some(module.position.clone()),
                         _ => None
+                    }
                 })
                 .unwrap_or(InputPosition::default());
             let module_name_msg = if module_name.is_empty() {
                 format!("a nameless module")
             } else {
                 format!("module '{}'", String::from_utf8_lossy(&module_name))
             };
             return Err(
                 ParseError2::new_error(&source, module_name_pos, &format!("Double definition of {} across files", module_name_msg))
                     .with_postfixed_info(&prev_module.source, prev_module_pos, "Other definition was here")
             );
+        }
         self.modules.push(LexedModule{
             source,
             module_name: module_name.clone(),
             version: module_version,
             root_id: pd
         });
         self.module_lookup.insert(module_name, cur_module_idx);
         Ok(pd)
+    }
     pub fn compile(&mut self) {
         // Build module lookup
+    }
     fn resolve_symbols_and_types(&mut self) -> Result<(SymbolTable, TypeTable), ParseError2> {
         // Construct the symbol table to resolve any imports and/or definitions,
         // then use the symbol table to actually annotate all of the imports.
         // If the type table is constructed correctly then all imports MUST be
         // resolvable.
         // TODO: Update once namespaced identifiers are implemented
         let symbol_table = SymbolTable::new(&self.heap, &self.modules)?;
         // Not pretty, but we need to work around rust's borrowing rules, it is
         // totally safe to mutate the contents of an AST element that we are
         // not borrowing anywhere else.
         // TODO: Maybe directly access heap's members to allow borrowing from
         //  mutliple members of Heap? Not pretty though...
         let mut module_index = 0;
         let mut import_index = 0;
         loop {
             if module_index >= self.modules.len() {
                 break;
+            }
             let module_root_id = self.modules[module_index].root_id;
             let import_id = {
                 let root = &self.heap[module_root_id];
                 if import_index >= root.imports.len() {
                     module_index += 1;
                     import_index = 0;
                     continue
+                }
                 root.imports[import_index]
             };
             let import = &mut self.heap[import_id];
             match import {
                 Import::Module(import) => {
                     debug_assert!(import.module_id.is_none(), "module import already resolved");
                     let target_module_id = symbol_table.resolve_module(&import.module_name)
                         .expect("module import is resolved by symbol table");
                     import.module_id = Some(target_module_id)
                 },
                 Import::Symbols(import) => {
                     debug_assert!(import.module_id.is_none(), "module of symbol import already resolved");
                     let target_module_id = symbol_table.resolve_module(&import.module_name)
                         .expect("symbol import's module is resolved by symbol table");
                     import.module_id = Some(target_module_id);
                     for symbol in &mut import.symbols {
                         debug_assert!(symbol.definition_id.is_none(), "symbol import already resolved");
                         let (_, target_definition_id) = symbol_table.resolve_symbol(module_root_id, &symbol.alias)
                             .expect("symbol import is resolved by symbol table")
                             .as_definition()
                             .expect("symbol import does not resolve to namespace symbol");
                         symbol.definition_id = Some(target_definition_id);
+                    }
+                }
+            }
+        }
         // All imports in the AST are now annotated. We now use the symbol table
         // to construct the type table.
         let mut type_ctx = TypeCtx::new(&symbol_table, &mut self.heap, &self.modules);
         let type_table = TypeTable::new(&mut type_ctx)?;
         Ok((symbol_table, type_table))
+    }
     // TODO: @fix, temporary impl to keep code compilable
     pub fn parse(&mut self) -> Result<RootId, ParseError2> {
         assert_eq!(self.modules.len(), 1, "Fix meeeee");
         let root_id = self.modules[0].root_id;
         let (mut symbol_table, mut type_table) = self.resolve_symbols_and_types()?;
         // TODO: @cleanup
         let mut ctx = visitor::Ctx{
             heap: &mut self.heap,
             module: &self.modules[0],
             symbols: &mut symbol_table,
             types: &mut type_table,
         };
         let mut visit = ValidityAndLinkerVisitor::new();
         visit.visit_module(&mut ctx)?;
         let mut type_visit = TypeResolvingVisitor::new();
         let mut queue = ResolveQueue::new();
         TypeResolvingVisitor::queue_module_definitions(&ctx, &mut queue);
         while !queue.is_empty() {
             let top = queue.pop().unwrap();
             println!("Resolving root={}, def={}, mono={:?}", top.root_id.index, top.definition_id.index, top.monomorph_types);
             type_visit.handle_module_definition(&mut ctx, &mut queue, top)?;
+        }
         if let Err((position, message)) = Self::parse_inner(&mut self.heap, root_id) {
             return Err(ParseError2::new_error(&self.modules[0].source, position, &message))
+        }
         let mut writer = ASTWriter::new();
         let mut file = std::fs::File::create(std::path::Path::new("ast.txt")).unwrap();
         writer.write_ast(&mut file, &self.heap);
         Ok(root_id)
+    }
     pub fn parse_inner(h: &mut Heap, pd: RootId) -> VisitorResult {
         // TODO: @cleanup, slowly phasing out old compiler
         // NestedSynchronousStatements::new().visit_protocol_description(h, pd)?;
         // ChannelStatementOccurrences::new().visit_protocol_description(h, pd)?;
         // FunctionStatementReturns::new().visit_protocol_description(h, pd)?;
         // ComponentStatementReturnNew::new().visit_protocol_description(h, pd)?;
         // CheckBuiltinOccurrences::new().visit_protocol_description(h, pd)?;
         // BuildSymbolDeclarations::new().visit_protocol_description(h, pd)?;
         // LinkCallExpressions::new().visit_protocol_description(h, pd)?;
         // BuildScope::new().visit_protocol_description(h, pd)?;
         // ResolveVariables::new().visit_protocol_description(h, pd)?;
         LinkStatements::new().visit_protocol_description(h, pd)?;
         // BuildLabels::new().visit_protocol_description(h, pd)?;
         // ResolveLabels::new().visit_protocol_description(h, pd)?;
         AssignableExpressions::new().visit_protocol_description(h, pd)?;
         IndexableExpressions::new().visit_protocol_description(h, pd)?;
         SelectableExpressions::new().visit_protocol_description(h, pd)?;
         Ok(())
+    }
+}
 #[cfg(test)]
 mod tests {
     use std::fs::File;
     use std::io::Read;
     use std::path::Path;
     use super::*;
     // #[test]
     fn positive_tests() {
         for resource in TestFileIter::new("testdata/parser/positive", "pdl") {
             let resource = resource.expect("read testdata filepath");
             // println!(" * running: {}", &resource);
             let path = Path::new(&resource);
             let source = InputSource::from_file(&path).unwrap();
             // println!("DEBUG -- input:\n{}", String::from_utf8_lossy(&source.input));
             let mut parser = Parser::new_with_source(source).expect("parse source");
             match parser.parse() {
                 Ok(_) => {}
                 Err(err) => {
                     println!(" > file: {}", &resource);
                     println!("{}", err);
                     assert!(false);
+                }
+            }
+        }
+    }
     // #[test]
     fn negative_tests() {
         for resource in TestFileIter::new("testdata/parser/negative", "pdl") {
             let resource = resource.expect("read testdata filepath");
             let path = Path::new(&resource);
             let expect = path.with_extension("txt");
             let mut source = InputSource::from_file(&path).unwrap();
             let mut parser = Parser::new_with_source(source).expect("construct parser");
             match parser.parse() {
                 Ok(pd) => {
                     println!("Expected parse error:");
                     let mut cev: Vec<u8> = Vec::new();
                     let mut f = File::open(expect).unwrap();
                     f.read_to_end(&mut cev).unwrap();
                     println!("{}", String::from_utf8_lossy(&cev));
                     assert!(false);
+                }
                 Err(err) => {
                     let expected = format!("{}", err);
                     println!("{}", &expected);
                     let mut cev: Vec<u8> = Vec::new();
                     let mut f = File::open(expect).unwrap();
                     f.read_to_end(&mut cev).unwrap();
                     println!("{}", String::from_utf8_lossy(&cev));
                     assert_eq!(expected.as_bytes(), cev);
+                }
+            }
+        }
+    }
     // #[test]
     fn counterexample_tests() {
         for resource in TestFileIter::new("testdata/parser/counterexamples", "pdl") {
             let resource = resource.expect("read testdata filepath");
             let path = Path::new(&resource);
             let source = InputSource::from_file(&path).unwrap();
             let mut parser = Parser::new_with_source(source).expect("construct parser");
             fn print_header(s: &str) {
                 println!("{}", "=".repeat(80));
                 println!(" > File: {}", s);
                 println!("{}", "=".repeat(80));
+            }
             match parser.parse() {
                 Ok(parsed) => {
                     print_header(&resource);
                     println!("\n  SUCCESS\n\n --- source:\n{}", String::from_utf8_lossy(&parser.modules[0].source.input));
                 },
                 Err(err) => {
                     print_header(&resource);
                     println!(
                         "\n  FAILURE\n\n --- error:\n{}\n --- source:\n{}",
                         err,
                         String::from_utf8_lossy(&parser.modules[0].source.input)
+                    )
+                }
+            }
+        }
+    }
     struct TestFileIter {
         iter: std::fs::ReadDir,
         root: String,
         extension: String
+    }
     impl TestFileIter {
         fn new(root_dir: &str, extension: &str) -> Self {
             let path = Path::new(root_dir);
             assert!(path.is_dir(), "root '{}' is not a directory", root_dir);
             let iter = std::fs::read_dir(path).expect("list dir contents");
             Self {
                 iter,
                 root: root_dir.to_string(),
                 extension: extension.to_string(),
+            }
+        }
+    }
     impl Iterator for TestFileIter {
         type Item = Result<String, String>;
         fn next(&mut self) -> Option<Self::Item> {
             while let Some(entry) = self.iter.next() {
                 if let Err(e) = entry {
                     return Some(Err(format!("failed to read dir entry, because: {}", e)));
+                }
                 let entry = entry.unwrap();
                 let path = entry.path();
                 if !path.is_file() { continue; }
                 let extension = path.extension();
                 if extension.is_none() { continue; }
                 let extension = extension.unwrap().to_string_lossy();
                 if extension != self.extension { continue; }
                 return Some(Ok(path.to_string_lossy().to_string()));
+            }
             None
+        }
+    }
+}

src/protocol/parser/type_resolver.rs

➞

Show inline comments

 /// type_resolver.rs
 ///
 /// Performs type inference and type checking
 ///
 /// TODO: Needs an optimization pass
 /// TODO: Needs a cleanup pass
 use std::collections::{HashMap, HashSet, VecDeque};
 use crate::protocol::ast::*;
 use crate::protocol::inputsource::*;
 use super::type_table::*;
 use super::symbol_table::*;
 use super::visitor::{
     STMT_BUFFER_INIT_CAPACITY,
     EXPR_BUFFER_INIT_CAPACITY,
     Ctx,
     Visitor2,
     VisitorResult
 };
 use std::collections::hash_map::Entry;
 use crate::protocol::parser::type_resolver::InferenceTypePart::IntegerLike;
 const MESSAGE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Message ];
 const BOOL_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Bool ];
 const NUMBERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::NumberLike ];
 const INTEGERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::IntegerLike ];
 const ARRAY_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Array, InferenceTypePart::Unknown ];
 const ARRAYLIKE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::ArrayLike, InferenceTypePart::Unknown ];
 const PORTLIKE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::PortLike, InferenceTypePart::Unknown ];
 /// TODO: @performance Turn into PartialOrd+Ord to simplify checks
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub(crate) enum InferenceTypePart {
     // A marker with an identifier which we can use to seek subsections of the
     // inferred type
     Marker(usize),
     // Completely unknown type, needs to be inferred
     Unknown,
     // Partially known type, may be inferred to to be the appropriate related
     // type.
     // IndexLike,      // index into array/slice
     NumberLike,     // any kind of integer/float
     IntegerLike,    // any kind of integer
     ArrayLike,      // array or slice. Note that this must have a subtype
     PortLike,       // input or output port
     // Special types that cannot be instantiated by the user
     Void, // For builtin functions that do not return anything
     // Concrete types without subtypes
     Message,
     Bool,
     Byte,
     Short,
     Int,
     Long,
     String,
     // One subtype
     Array,
     Slice,
     Input,
     Output,
     // A user-defined type with any number of subtypes
     Instance(DefinitionId, usize)
+}
 impl InferenceTypePart {
     fn is_marker(&self) -> bool {
         if let InferenceTypePart::Marker(_) = self { true } else { false }
+    }
     /// Checks if the type is concrete, markers are interpreted as concrete
     /// types.
     fn is_concrete(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::Unknown | ITP::NumberLike | ITP::IntegerLike |
             ITP::ArrayLike | ITP::PortLike => false,
             _ => true
+        }
+    }
     fn is_concrete_number(&self) -> bool {
         // TODO: @float
         use InferenceTypePart as ITP;
         match self {
             ITP::Byte | ITP::Short | ITP::Int | ITP::Long => true,
             _ => false,
+        }
+    }
     fn is_concrete_integer(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::Byte | ITP::Short | ITP::Int | ITP::Long => true,
             _ => false,
+        }
+    }
     fn is_concrete_array_or_slice(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::Array | ITP::Slice => true,
             _ => false,
+        }
+    }
     fn is_concrete_port(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::Input | ITP::Output => true,
             _ => false,
+        }
+    }
     /// Checks if a part is less specific than the argument. Only checks for
     /// single-part inference (i.e. not the replacement of an `Unknown` variant
     /// with the argument)
     fn may_be_inferred_from(&self, arg: &InferenceTypePart) -> bool {
         use InferenceTypePart as ITP;
         (*self == ITP::IntegerLike && arg.is_concrete_integer()) ||
         (*self == ITP::NumberLike && (arg.is_concrete_number() || *arg == ITP::IntegerLike)) ||
         (*self == ITP::ArrayLike && arg.is_concrete_array_or_slice()) ||
         (*self == ITP::PortLike && arg.is_concrete_port())
+    }
     /// Returns the change in "iteration depth" when traversing this particular
     /// part. The iteration depth is used to traverse the tree in a linear
     /// fashion. It is basically `number_of_subtypes - 1`
     fn depth_change(&self) -> i32 {
         use InferenceTypePart as ITP;
         match &self {
             ITP::Unknown | ITP::NumberLike | ITP::IntegerLike |
             ITP::Void | ITP::Message | ITP::Bool |
             ITP::Byte | ITP::Short | ITP::Int | ITP::Long |
             ITP::String => {
                 -1
             },
             ITP::Marker(_) | ITP::ArrayLike | ITP::Array | ITP::Slice |
             ITP::PortLike | ITP::Input | ITP::Output => {
                 // One subtype, so do not modify depth
             },
             ITP::Instance(_, num_args) => {
                 (*num_args as i32) - 1
+            }
+        }
+    }
+}
 impl From<ConcreteTypeVariant> for InferenceTypePart {
     fn from(v: ConcreteTypeVariant) -> InferenceTypePart {
         use ConcreteTypeVariant as CTV;
 impl From<ConcreteTypePart> for InferenceTypePart {
     fn from(v: ConcreteTypePart) -> InferenceTypePart {
         use ConcreteTypePart as CTP;
         use InferenceTypePart as ITP;
         match v {
             CTV::Message => ITP::Message,
             CTV::Bool => ITP::Bool,
             CTV::Byte => ITP::Byte,
             CTV::Short => ITP::Short,
             CTV::Int => ITP::Int,
             CTV::Long => ITP::Long,
             CTV::String => ITP::String,
             CTV::Array => ITP::Array,
             CTV::Slice => ITP::Slice,
             CTV::Input => ITP::Input,
             CTV::Output => ITP::Output,
             CTV::Instance(id, num) => ITP::Instance(id, num),
             CTP::Void => ITP::Void,
             CTP::Message => ITP::Message,
             CTP::Bool => ITP::Bool,
             CTP::Byte => ITP::Byte,
             CTP::Short => ITP::Short,
             CTP::Int => ITP::Int,
             CTP::Long => ITP::Long,
             CTP::String => ITP::String,
             CTP::Array => ITP::Array,
             CTP::Slice => ITP::Slice,
             CTP::Input => ITP::Input,
             CTP::Output => ITP::Output,
             CTP::Instance(id, num) => ITP::Instance(id, num),
+        }
+    }
+}
 #[derive(Debug)]
 struct InferenceType {
     has_marker: bool,
     is_done: bool,
     parts: Vec<InferenceTypePart>,
+}
 impl InferenceType {
     fn new(has_marker: bool, is_done: bool, parts: Vec<InferenceTypePart>) -> Self {
         if cfg!(debug_assertions) {
             debug_assert!(!parts.is_empty());
             if !has_marker {
                 debug_assert!(parts.iter().all(|v| !v.is_marker()));
+            }
             if is_done {
                 debug_assert!(parts.iter().all(|v| v.is_concrete()));
+            }
+        }
         Self{ has_marker, is_done, parts }
+    }
     fn replace_subtree(&mut self, start_idx: usize, with: &[InferenceTypePart]) {
          let end_idx = Self::find_subtree_end_idx(&self.parts, start_idx);
         debug_assert_eq!(with.len(), Self::find_subtree_end_idx(with, 0));
         self.parts.splice(start_idx..end_idx, with.iter().cloned());
         self.recompute_is_done();
+    }
     // TODO: @performance, might all be done inline in the type inference methods
     fn recompute_is_done(&mut self) {
         self.is_done = self.parts.iter().all(|v| v.is_concrete());
+    }
     /// Checks if type is, or may be inferred as, a number
     // TODO: @float
     fn might_be_number(&self) -> bool {
         use InferenceTypePart as ITP;
         // TODO: @marker?
         if self.parts.len() != 1 { return false; }
         match self.parts[0] {
             ITP::Unknown | ITP::NumberLike | ITP::IntegerLike |
             ITP::Byte | ITP::Short | ITP::Int | ITP::Long =>
                 true,
             _ =>
                 false,
+        }
+    }
     /// Checks if type is, or may be inferred as, an integer
     fn might_be_integer(&self) -> bool {
         use InferenceTypePart as ITP;
         // TODO: @marker?
         if self.parts.len() != 1 { return false; }
         match self.parts[0] {
             ITP::Unknown | ITP::IntegerLike |
             ITP::Byte | ITP::Short | ITP::Int | ITP::Long =>
                 true,
             _ =>
                 false,
+        }
+    }
     /// Checks if type is, or may be inferred as, a boolean
     fn might_be_boolean(&self) -> bool {
         use InferenceTypePart as ITP;
         // TODO: @marker?
         if self.parts.len() != 1 { return false; }
         match self.parts[0] {
             ITP::Unknown | ITP::Bool => true,
             _ => false
+        }
+    }
     /// Returns an iterator over all markers and the partial type tree that
     /// follows those markers.
     fn marker_iter(&self) -> InferenceTypeMarkerIter {
         InferenceTypeMarkerIter::new(&self.parts)
+    }
     /// Attempts to find a marker with a specific value appearing at or after
     /// the specified index. If found then the partial type tree's bounding
     /// indices that follow that marker are returned.
     fn find_subtree_idx_for_marker(&self, marker: usize, mut idx: usize) -> Option<(usize, usize)> {
         // Seek ahead to find a marker
         let marker = InferenceTypePart::Marker(marker);
         while idx < self.parts.len() {
             if marker == self.parts[idx] {
                 // Found the marker
                 let start_idx = idx + 1;
                 let end_idx = Self::find_subtree_end_idx(&self.parts, start_idx);
                 return Some((start_idx, end_idx))
+            }
             idx += 1;
+        }
         None
+    }
     /// Given that the `parts` are a depth-first serialized tree of types, this
     /// function finds the subtree anchored at a specific node. The returned
     /// index is exclusive.
     fn find_subtree_end_idx(parts: &[InferenceTypePart], start_idx: usize) -> usize {
         let mut depth = 1;
         let mut idx = start_idx;
         while idx < parts.len() {
             depth += parts[idx].depth_change();
             if depth == 0 {
                 return idx + 1;
+            }
             idx += 1;
+        }
         // If here, then the inference type is malformed
         unreachable!();
+    }
     /// Call that attempts to infer the part at `to_infer.parts[to_infer_idx]`
     /// using the subtree at `template.parts[template_idx]`. Will return
     /// `Some(depth_change_due_to_traversal)` if type inference has been
     /// applied. In this case the indices will also be modified to point to the
     /// next part in both templates. If type inference has not (or: could not)
     /// be applied then `None` will be returned. Note that this might mean that
     /// the types are incompatible.
     ///
     /// As this is a helper functions, some assumptions: the parts are not
     /// exactly equal, and neither of them contains a marker. Also: only the
     /// `to_infer` parts are checked for inference. It might be that this
     /// function returns `None`, but that that `template` is still compatible
     /// with `to_infer`, e.g. when `template` has an `Unknown` part.
     fn infer_part_for_single_type(
         to_infer: &mut InferenceType, to_infer_idx: &mut usize,
         template_parts: &[InferenceTypePart], template_idx: &mut usize,
     ) -> Option<i32> {
         use InferenceTypePart as ITP;
         let to_infer_part = &to_infer.parts[*to_infer_idx];
         let template_part = &template_parts[*template_idx];
         // Check for programmer mistakes
         debug_assert_ne!(to_infer_part, template_part);
         debug_assert!(!to_infer_part.is_marker(), "marker encountered in 'infer part'");
         debug_assert!(!template_part.is_marker(), "marker encountered in 'template part'");
         // Inference of a somewhat-specified type
         if to_infer_part.may_be_inferred_from(template_part) {
             let depth_change = to_infer_part.depth_change();
             debug_assert_eq!(depth_change, template_part.depth_change());
             to_infer.parts[*to_infer_idx] = template_part.clone();
             *to_infer_idx += 1;
             *template_idx += 1;
             return Some(depth_change);
+        }
         // Inference of a completely unknown type
         if *to_infer_part == ITP::Unknown {
             // template part is different, so cannot be unknown, hence copy the
             // entire subtree
             let template_end_idx = Self::find_subtree_end_idx(template_parts, *template_idx);
             to_infer.parts[*to_infer_idx] = template_part.clone();
             *to_infer_idx += 1;
             for insert_idx in (*template_idx + 1)..template_end_idx {
                 to_infer.parts.insert(*to_infer_idx, template_parts[insert_idx].clone());
                 *to_infer_idx += 1;
+            }
             *template_idx = template_end_idx;
             // Note: by definition the LHS was Unknown and the RHS traversed a
             // full subtree.
             return Some(-1);
+        }
         None
+    }
     /// Call that checks if the `to_check` part is compatible with the `infer`
     /// part. This essentially implements `infer_part_for_single_type` but skips
     /// over the matching parts.
     fn check_part_for_single_type(
         to_check_parts: &[InferenceTypePart], to_check_idx: &mut usize,
         template_parts: &[InferenceTypePart], template_idx: &mut usize
     ) -> Option<i32> {
         use InferenceTypePart as ITP;
         let to_check_part = &to_check_parts[*to_check_idx];
         let template_part = &template_parts[*template_idx];
         // Checking programmer errors
         debug_assert_ne!(to_check_part, template_part);
         debug_assert!(!to_check_part.is_marker(), "marker encountered in 'to_check part'");
         debug_assert!(!template_part.is_marker(), "marker encountered in 'template part'");
         if to_check_part.may_be_inferred_from(template_part) {
             let depth_change = to_check_part.depth_change();
             debug_assert_eq!(depth_change, template_part.depth_change());
             *to_check_idx += 1;
             *template_idx += 1;
             return Some(depth_change);
+        }
         if *to_check_part == ITP::Unknown {
             *to_check_idx += 1;
             *template_idx = Self::find_subtree_end_idx(template_parts, *template_idx);
             // By definition LHS and RHS had depth change of -1
             return Some(-1);
+        }
         None
+    }
     /// Attempts to infer types between two `InferenceType` instances. This
     /// function is unsafe as it accepts pointers to work around Rust's
     /// borrowing rules. The caller must ensure that the pointers are distinct.
     unsafe fn infer_subtrees_for_both_types(
         type_a: *mut InferenceType, start_idx_a: usize,
         type_b: *mut InferenceType, start_idx_b: usize
     ) -> DualInferenceResult {
         use InferenceTypePart as ITP;
         debug_assert!(!std::ptr::eq(type_a, type_b), "same inference types");
         let type_a = &mut *type_a;
         let type_b = &mut *type_b;
         let mut modified_a = false;
         let mut modified_b = false;
         let mut idx_a = start_idx_a;
         let mut idx_b = start_idx_b;
         let mut depth = 1;
         while depth > 0 {
             // Advance indices if we encounter markers or equal parts
             let part_a = &type_a.parts[idx_a];
             let part_b = &type_b.parts[idx_b];
             if part_a == part_b {
                 depth += part_a.depth_change();
                 debug_assert_eq!(depth, part_b.depth_change());
                 let depth_change = part_a.depth_change();
                 depth += depth_change;
                 debug_assert_eq!(depth_change, part_b.depth_change());
                 idx_a += 1;
                 idx_b += 1;
                 continue;
+            }
             if let ITP::Marker(_) = part_a { idx_a += 1; continue; }
             if let ITP::Marker(_) = part_b { idx_b += 1; continue; }
             // Types are not equal and are both not markers
             if let Some(depth_change) = Self::infer_part_for_single_type(type_a, &mut idx_a, &type_b.parts, &mut idx_b) {
                 depth += depth_change;
                 modified_a = true;
                 continue;
+            }
             if let Some(depth_change) = Self::infer_part_for_single_type(type_b, &mut idx_b, &type_a.parts, &mut idx_a) {
                 depth += depth_change;
                 modified_b = true;
                 continue;
+            }
             // And can also not be inferred in any way: types must be incompatible
             return DualInferenceResult::Incompatible;
+        }
         if modified_a { type_a.recompute_is_done(); }
         if modified_b { type_b.recompute_is_done(); }
         // If here then we completely inferred the subtrees.
         match (modified_a, modified_b) {
             (false, false) => DualInferenceResult::Neither,
             (false, true) => DualInferenceResult::Second,
             (true, false) => DualInferenceResult::First,
             (true, true) => DualInferenceResult::Both
+        }
+    }
     /// Attempts to infer the first subtree based on the template. Like
     /// `infer_subtrees_for_both_types`, but now only applying inference to
     /// `to_infer` based on the type information in `template`.
     /// Secondary use is to make sure that a type follows a certain template.
     fn infer_subtree_for_single_type(
         to_infer: &mut InferenceType, mut to_infer_idx: usize,
         template: &[InferenceTypePart], mut template_idx: usize,
     ) -> SingleInferenceResult {
         let mut modified = false;
         let mut depth = 1;
         while depth > 0 {
             let to_infer_part = &to_infer.parts[to_infer_idx];
             let template_part = &template[template_idx];
             if to_infer_part == template_part {
                 depth += to_infer_part.depth_change();
                 debug_assert_eq!(depth, template_part.depth_change());
                 let depth_change = to_infer_part.depth_change();
                 depth += depth_change;
                 debug_assert_eq!(depth_change, template_part.depth_change());
                 to_infer_idx += 1;
                 template_idx += 1;
                 continue;
+            }
             if to_infer_part.is_marker() { to_infer_idx += 1; continue; }
             if template_part.is_marker() { template_idx += 1; continue; }
             // Types are not equal and not markers. So check if we can infer
             // anything
             if let Some(depth_change) = Self::infer_part_for_single_type(
                 to_infer, &mut to_infer_idx, template, &mut template_idx
             ) {
                 depth += depth_change;
                 modified = true;
                 continue;
+            }
             // We cannot infer anything, but the template may still be
             // compatible with the type we're inferring
             if let Some(depth_change) = Self::check_part_for_single_type(
                 template, &mut template_idx, &to_infer.parts, &mut to_infer_idx
             ) {
                 depth += depth_change;
                 continue;
+            }
             return SingleInferenceResult::Incompatible
+        }
         return if modified {
             to_infer.recompute_is_done();
             SingleInferenceResult::Modified
         } else {
             SingleInferenceResult::Unmodified
+        }
+    }
     /// Checks if both types are compatible, doesn't perform any inference
     fn check_subtrees(
         type_parts_a: &[InferenceTypePart], start_idx_a: usize,
         type_parts_b: &[InferenceTypePart], start_idx_b: usize
     ) -> bool {
         let mut depth = 1;
         let mut idx_a = start_idx_a;
         let mut idx_b = start_idx_b;
         while depth > 0 {
             let part_a = &type_parts_a[idx_a];
             let part_b = &type_parts_b[idx_b];
             if part_a == part_b {
                 depth += part_a.depth_change();
                 debug_assert_eq!(depth, part_b.depth_change());
                 let depth_change = part_a.depth_change();
                 depth += depth_change;
                 debug_assert_eq!(depth_change, part_b.depth_change());
                 idx_a += 1;
                 idx_b += 1;
                 continue;
+            }
             if part_a.is_marker() { idx_a += 1; continue; }
             if part_b.is_marker() { idx_b += 1; continue; }
             if let Some(depth_change) = Self::check_part_for_single_type(
                 type_parts_a, &mut idx_a, type_parts_b, &mut idx_b
             ) {
                 depth += depth_change;
                 continue;
+            }
             if let Some(depth_change) = Self::check_part_for_single_type(
                 type_parts_b, &mut idx_b, type_parts_a, &mut idx_a
             ) {
                 depth += depth_change;
                 continue;
+            }
             return false;
+        }
         true
+    }
     /// Returns a human-readable version of the type. Only use for debugging
     /// or returning errors (since it allocates a string).
     /// Performs the conversion of the inference type into a concrete type.
     /// By calling this function you must make sure that no unspecified types
     /// (e.g. Unknown or IntegerLike) exist in the type.
     fn write_concrete_type(&self, concrete_type: &mut ConcreteType) {
         use InferenceTypePart as ITP;
         use ConcreteTypePart as CTP;
         debug_assert!(concrete_type.parts.is_empty());
         concrete_type.parts.reserve(self.parts.len());
         for part in &self.parts {
             let converted_part = match part {
                 ITP::Marker(_) => { continue; },
                 ITP::Unknown | ITP::NumberLike | ITP::IntegerLike | ITP::ArrayLike | ITP::PortLike => {
                     debug_assert!(false, "Attempted to convert inference type part {:?} into concrete type", part);
                     unreachable!();
                 },
                 ITP::Void => CTP::Void,
                 ITP::Message => CTP::Message,
                 ITP::Bool => CTP::Bool,
                 ITP::Byte => CTP::Byte,
                 ITP::Short => CTP::Short,
                 ITP::Int => CTP::Int,
                 ITP::Long => CTP::Long,
                 ITP::String => CTP::String,
                 ITP::Array => CTP::Array,
                 ITP::Slice => CTP::Slice,
                 ITP::Input => CTP::Input,
                 ITP::Output => CTP::Output,
                 ITP::Instance(id, num) => CTP::Instance(*id, *num),
             };
             concrete_type.parts.push(converted_part);
+        }
+    }
     /// Writes a human-readable version of the type to a string. Mostly a
     /// function for interior use.
     fn write_display_name(
         buffer: &mut String, heap: &Heap, parts: &[InferenceTypePart], mut idx: usize
     ) -> usize {
         use InferenceTypePart as ITP;
         match &parts[idx] {
             ITP::Marker(_) => {},
             ITP::Marker(_) => {
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1)
             },
             ITP::Unknown => buffer.push_str("?"),
             ITP::NumberLike => buffer.push_str("num?"),
             ITP::IntegerLike => buffer.push_str("int?"),
             ITP::ArrayLike => {
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push_str("[?]");
             },
             ITP::PortLike => {
                 buffer.push_str("port?<");
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
+            }
             ITP::Void => buffer.push_str("void"),
             ITP::Message => buffer.push_str("msg"),
             ITP::Bool => buffer.push_str("bool"),
             ITP::Byte => buffer.push_str("byte"),
             ITP::Short => buffer.push_str("short"),
             ITP::Int => buffer.push_str("int"),
             ITP::Long => buffer.push_str("long"),
             ITP::String => buffer.push_str("str"),
             ITP::Array => {
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push_str("[]");
             },
             ITP::Slice => {
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push_str("[..]");
             },
             ITP::Input => {
                 buffer.push_str("in<");
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
             },
             ITP::Output => {
                 buffer.push_str("out<");
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
             },
             ITP::Instance(definition_id, num_sub) => {
                 let definition = &heap[*definition_id];
                 buffer.push_str(&String::from_utf8_lossy(&definition.identifier().value));
                 if *num_sub > 0 {
                     buffer.push('<');
                     idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                     for _sub_idx in 1..*num_sub {
                         buffer.push_str(", ");
                         idx = Self::write_display_name(buffer, heap, parts, idx + 1);
+                    }
                     buffer.push('>');
+                }
             },
+        }
         idx
+    }
     /// Returns the display name of a (part of) the type tree. Will allocate a
     /// string.
     fn partial_display_name(heap: &Heap, parts: &[InferenceTypePart]) -> String {
         let mut buffer = String::with_capacity(parts.len() * 6);
         Self::write_display_name(&mut buffer, heap, parts, 0);
         buffer
+    }
     /// Returns the display name of the full type tree. Will allocate a string.
     fn display_name(&self, heap: &Heap) -> String {
         Self::partial_display_name(heap, &self.parts)
+    }
+}
 /// Iterator over the subtrees that follow a marker in an `InferenceType`
 /// instance. Returns immutable slices over the internal parts
 struct InferenceTypeMarkerIter<'a> {
     parts: &'a [InferenceTypePart],
     idx: usize,
+}
 impl<'a> InferenceTypeMarkerIter<'a> {
     fn new(parts: &'a [InferenceTypePart]) -> Self {
         Self{ parts, idx: 0 }
+    }
+}
 impl<'a> Iterator for InferenceTypeMarkerIter<'a> {
     type Item = (usize, &'a [InferenceTypePart]);
     fn next(&mut self) -> Option<Self::Item> {
         // Iterate until we find a marker
         while self.idx < self.parts.len() {
             if let InferenceTypePart::Marker(marker) = self.parts[self.idx] {
                 // Found a marker, find the subtree end
                 let start_idx = self.idx + 1;
                 let end_idx = InferenceType::find_subtree_end_idx(self.parts, start_idx);
                 // Modify internal index, then return items
                 self.idx = end_idx;
                 return Some((marker, &self.parts[start_idx..end_idx]))
+            }
             self.idx += 1;
+        }
         None
+    }
+}
 #[derive(PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq)]
 enum DualInferenceResult {
     Neither,        // neither argument is clarified
     First,          // first argument is clarified using the second one
     Second,         // second argument is clarified using the first one
     Both,           // both arguments are clarified
     Incompatible,   // types are incompatible: programmer error
+}
 impl DualInferenceResult {
     fn modified_any(&self) -> bool {
         match self {
             DualInferenceResult::First | DualInferenceResult::Second | DualInferenceResult::Both => true,
             _ => false
+        }
+    }
     fn modified_lhs(&self) -> bool {
         match self {
             DualInferenceResult::First | DualInferenceResult::Both => true,
             _ => false
+        }
+    }
     fn modified_rhs(&self) -> bool {
         match self {
             DualInferenceResult::Second | DualInferenceResult::Both => true,
             _ => false
+        }
+    }
+}
 #[derive(PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq)]
 enum SingleInferenceResult {
     Unmodified,
     Modified,
     Incompatible
+}
 enum DefinitionType{
     None,
     Component(ComponentId),
     Function(FunctionId),
+}
 pub(crate) struct ResolveQueueElement {
     pub(crate) root_id: RootId,
     pub(crate) definition_id: DefinitionId,
     pub(crate) monomorph_types: Vec<ConcreteType>,
+}
 pub(crate) type ResolveQueue = Vec<ResolveQueueElement>;
 /// This particular visitor will recurse depth-first into the AST and ensures
 /// that all expressions have the appropriate types. At the moment this implies:
 ///
 ///     - Type checking arguments to unary and binary operators.
 ///     - Type checking assignment, indexing, slicing and select expressions.
 ///     - Checking arguments to functions and component instantiations.
 ///
 /// This will be achieved by slowly descending into the AST. At any given
 /// expression we may depend on
 /// that all expressions have the appropriate types.
 pub(crate) struct TypeResolvingVisitor {
     // Current definition we're typechecking.
     definition_type: DefinitionType,
     poly_vars: Vec<ConcreteType>,
     // Buffers for iteration over substatements and subexpressions
     stmt_buffer: Vec<StatementId>,
     expr_buffer: Vec<ExpressionId>,
     // If instantiating a monomorph of a polymorphic proctype, then we store the
     // values of the polymorphic values here. There should be as many, and in
     // the same order as, in the definition's polyargs.
     polyvars: Vec<ConcreteType>,
     // Mapping from parser type to inferred type. We attempt to continue to
     // specify these types until we're stuck or we've fully determined the type.
     var_types: HashMap<VariableId, VarData>,      // types of variables
     expr_types: HashMap<ExpressionId, InferenceType>,   // types of expressions
     extra_data: HashMap<ExpressionId, ExtraData>,       // data for function call inference
     // Keeping track of which expressions need to be reinferred because the
     // expressions they're linked to made progression on an associated type
     expr_queued: HashSet<ExpressionId>,
+}
 // TODO: @rename used for calls and struct literals, maybe union literals?
 struct ExtraData {
     /// Progression of polymorphic variables (if any)
     poly_vars: Vec<InferenceType>,
     /// Progression of types of call arguments or struct members
     embedded: Vec<InferenceType>,
     returned: InferenceType,
+}
 struct VarData {
     var_type: InferenceType,
     used_at: Vec<ExpressionId>,
+}
 impl TypeResolvingVisitor {
     pub(crate) fn new() -> Self {
         TypeResolvingVisitor{
             definition_type: DefinitionType::None,
             poly_vars: Vec::new(),
             stmt_buffer: Vec::with_capacity(STMT_BUFFER_INIT_CAPACITY),
             expr_buffer: Vec::with_capacity(EXPR_BUFFER_INIT_CAPACITY),
             polyvars: Vec::new(),
             var_types: HashMap::new(),
             expr_types: HashMap::new(),
             extra_data: HashMap::new(),
             expr_queued: HashSet::new(),
+        }
+    }
     // TODO: @cleanup Unsure about this, maybe a pattern will arise after
     //  a while.
     pub(crate) fn queue_module_definitions(ctx: &Ctx, queue: &mut ResolveQueue) {
         let root_id = ctx.module.root_id;
         let root = &ctx.heap.protocol_descriptions[root_id];
         for definition_id in &root.definitions {
             let definition = &ctx.heap[*definition_id];
             match definition {
                 Definition::Function(definition) => {
                     if definition.poly_vars.is_empty() {
                         queue.push(ResolveQueueElement{
                             root_id,
                             definition_id: *definition_id,
                             monomorph_types: Vec::new(),
                         })
+                    }
                 },
                 Definition::Component(definition) => {
                     if definition.poly_vars.is_empty() {
                         queue.push(ResolveQueueElement{
                             root_id,
                             definition_id: *definition_id,
                             monomorph_types: Vec::new(),
                         })
+                    }
                 },
                 Definition::Enum(_) | Definition::Struct(_) => {},
+            }
+        }
+    }
     pub(crate) fn handle_module_definition(
         &mut self, ctx: &mut Ctx, queue: &mut ResolveQueue, element: ResolveQueueElement
     ) -> VisitorResult {
         // Visit the definition
         debug_assert_eq!(ctx.module.root_id, element.root_id);
         self.visit_definition(ctx, element.definition_id)?;
         // Keep resolving types
         self.resolve_types(ctx, queue)?;
         Ok(())
+    }
     fn reset(&mut self) {
         self.definition_type = DefinitionType::None;
         self.poly_vars.clear();
         self.stmt_buffer.clear();
         self.expr_buffer.clear();
         self.polyvars.clear();
         self.var_types.clear();
         self.expr_types.clear();
         self.extra_data.clear();
         self.expr_queued.clear();
+    }
+}
 impl Visitor2 for TypeResolvingVisitor {
     // Definitions
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentId) -> VisitorResult {
         self.reset();
         self.definition_type = DefinitionType::Component(id);
         let comp_def = &ctx.heap[id];
-        debug_assert_eq!(comp_def.poly_vars.len(), self.polyvars.len(), "component polyvars do not match imposed polyvars");
+        debug_assert_eq!(comp_def.poly_vars.len(), self.poly_vars.len(), "component polyvars do not match imposed polyvars");
         for param_id in comp_def.parameters.clone() {
             let param = &ctx.heap[param_id];
             let var_type = self.determine_inference_type_from_parser_type(ctx, param.parser_type, true);
             debug_assert!(var_type.is_done, "expected component arguments to be concrete types");
             self.var_types.insert(param_id.upcast(), VarData{ var_type, used_at: Vec::new() });
+        }
         let body_stmt_id = ctx.heap[id].body;
         self.visit_stmt(ctx, body_stmt_id)
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionId) -> VisitorResult {
         self.reset();
         self.definition_type = DefinitionType::Function(id);
         let func_def = &ctx.heap[id];
-        debug_assert_eq!(func_def.poly_vars.len(), self.polyvars.len(), "function polyvars do not match imposed polyvars");
+        debug_assert_eq!(func_def.poly_vars.len(), self.poly_vars.len(), "function polyvars do not match imposed polyvars");
         for param_id in func_def.parameters.clone() {
             let param = &ctx.heap[param_id];
             let var_type = self.determine_inference_type_from_parser_type(ctx, param.parser_type, true);
             debug_assert!(var_type.is_done, "expected function arguments to be concrete types");
             self.var_types.insert(param_id.upcast(), VarData{ var_type, used_at: Vec::new() });
+        }
         let body_stmt_id = ctx.heap[id].body;
         self.visit_stmt(ctx, body_stmt_id)
+    }
     // Statements
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         // Transfer statements for traversal
         let block = &ctx.heap[id];
         for stmt_id in block.statements.clone() {
             self.visit_stmt(ctx, stmt_id);
+            self.visit_stmt(ctx, stmt_id)?;
+        }
         Ok(())
+    }
     fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {
         let memory_stmt = &ctx.heap[id];
         let local = &ctx.heap[memory_stmt.variable];
         let var_type = self.determine_inference_type_from_parser_type(ctx, local.parser_type, true);
         self.var_types.insert(memory_stmt.variable.upcast(), VarData{ var_type, used_at: Vec::new() });
         let expr_id = memory_stmt.initial;
         self.visit_expr(ctx, expr_id)?;
         Ok(())
+    }
     fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {
         let channel_stmt = &ctx.heap[id];
         let from_local = &ctx.heap[channel_stmt.from];
         let from_var_type = self.determine_inference_type_from_parser_type(ctx, from_local.parser_type, true);
         self.var_types.insert(from_local.this.upcast(), VarData{ var_type: from_var_type, used_at: Vec::new() });
         let to_local = &ctx.heap[channel_stmt.to];
         let to_var_type = self.determine_inference_type_from_parser_type(ctx, to_local.parser_type, true);
         self.var_types.insert(to_local.this.upcast(), VarData{ var_type: to_var_type, used_at: Vec::new() });
         Ok(())
+    }
     fn visit_labeled_stmt(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> VisitorResult {
         let labeled_stmt = &ctx.heap[id];
         let substmt_id = labeled_stmt.body;
         self.visit_stmt(ctx, substmt_id)
+    }
     fn visit_if_stmt(&mut self, ctx: &mut Ctx, id: IfStatementId) -> VisitorResult {
         let if_stmt = &ctx.heap[id];
         let true_body_id = if_stmt.true_body;
         let false_body_id = if_stmt.false_body;
         let test_expr_id = if_stmt.test;
         self.visit_expr(ctx, test_expr_id)?;
         self.visit_stmt(ctx, true_body_id)?;
         self.visit_stmt(ctx, false_body_id)?;
         Ok(())
+    }
     fn visit_while_stmt(&mut self, ctx: &mut Ctx, id: WhileStatementId) -> VisitorResult {
         let while_stmt = &ctx.heap[id];
         let body_id = while_stmt.body;
         let test_expr_id = while_stmt.test;
         self.visit_expr(ctx, test_expr_id)?;
         self.visit_stmt(ctx, body_id)?;
         Ok(())
+    }
     fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {
         let sync_stmt = &ctx.heap[id];
         let body_id = sync_stmt.body;
         self.visit_stmt(ctx, body_id)
+    }
     fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {
         let return_stmt = &ctx.heap[id];
         let expr_id = return_stmt.expression;
         self.visit_expr(ctx, expr_id)
+    }
     fn visit_assert_stmt(&mut self, ctx: &mut Ctx, id: AssertStatementId) -> VisitorResult {
         let assert_stmt = &ctx.heap[id];
         let test_expr_id = assert_stmt.expression;
         self.visit_expr(ctx, test_expr_id)
+    }
     fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {
         let new_stmt = &ctx.heap[id];
         let call_expr_id = new_stmt.expression;
         self.visit_call_expr(ctx, call_expr_id)
+    }
     fn visit_expr_stmt(&mut self, ctx: &mut Ctx, id: ExpressionStatementId) -> VisitorResult {
         let expr_stmt = &ctx.heap[id];
         let subexpr_id = expr_stmt.expression;
         self.visit_expr(ctx, subexpr_id)
+    }
     // Expressions
     fn visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let assign_expr = &ctx.heap[id];
         let left_expr_id = assign_expr.left;
         let right_expr_id = assign_expr.right;
         self.visit_expr(ctx, left_expr_id)?;
         self.visit_expr(ctx, right_expr_id)?;
         self.progress_assignment_expr(ctx, id)
+    }
     fn visit_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let conditional_expr = &ctx.heap[id];
         let test_expr_id = conditional_expr.test;
         let true_expr_id = conditional_expr.true_expression;
         let false_expr_id = conditional_expr.false_expression;
         self.expr_types.insert(test_expr_id, InferenceType::new(false, true, vec![InferenceTypePart::Bool]));
         self.visit_expr(ctx, test_expr_id)?;
         self.visit_expr(ctx, true_expr_id)?;
         self.visit_expr(ctx, false_expr_id)?;
         self.progress_conditional_expr(ctx, id)
+    }
     fn visit_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let binary_expr = &ctx.heap[id];
         let lhs_expr_id = binary_expr.left;
         let rhs_expr_id = binary_expr.right;
         self.visit_expr(ctx, lhs_expr_id)?;
         self.visit_expr(ctx, rhs_expr_id)?;
         self.progress_binary_expr(ctx, id)
+    }
     fn visit_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let unary_expr = &ctx.heap[id];
         let arg_expr_id = unary_expr.expression;
         self.visit_expr(ctx, arg_expr_id)?;
         self.progress_unary_expr(ctx, id)
+    }
     fn visit_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let indexing_expr = &ctx.heap[id];
         let subject_expr_id = indexing_expr.subject;
         let index_expr_id = indexing_expr.index;
         self.visit_expr(ctx, subject_expr_id)?;
         self.visit_expr(ctx, index_expr_id)?;
         self.progress_indexing_expr(ctx, id)
+    }
     fn visit_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let slicing_expr = &ctx.heap[id];
         let subject_expr_id = slicing_expr.subject;
         let from_expr_id = slicing_expr.from_index;
         let to_expr_id = slicing_expr.to_index;
         self.visit_expr(ctx, subject_expr_id)?;
         self.visit_expr(ctx, from_expr_id)?;
         self.visit_expr(ctx, to_expr_id)?;
         self.progress_slicing_expr(ctx, id)
+    }
     fn visit_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let select_expr = &ctx.heap[id];
         let subject_expr_id = select_expr.subject;
         self.visit_expr(ctx, subject_expr_id)?;
         self.progress_select_expr(ctx, id)
+    }
     fn visit_array_expr(&mut self, ctx: &mut Ctx, id: ArrayExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let array_expr = &ctx.heap[id];
         // TODO: @performance
         for element_id in array_expr.elements.clone().into_iter() {
             self.visit_expr(ctx, element_id)?;
+        }
         self.progress_array_expr(ctx, id)
+    }
     fn visit_constant_expr(&mut self, ctx: &mut Ctx, id: ConstantExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         self.progress_constant_expr(ctx, id)
+    }
     fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         self.insert_initial_call_polymorph_data(ctx, id);
         // TODO: @performance
         let call_expr = &ctx.heap[id];
         for arg_expr_id in call_expr.arguments.clone() {
             self.visit_expr(ctx, arg_expr_id)?;
+        }
         self.progress_call_expr(ctx, id)
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let var_expr = &ctx.heap[id];
         debug_assert!(var_expr.declaration.is_some());
         let var_data = self.var_types.get_mut(var_expr.declaration.as_ref().unwrap()).unwrap();
         var_data.used_at.push(upcast_id);
         self.progress_variable_expr(ctx, id)
+    }
+}
 macro_rules! debug_assert_expr_ids_unique_and_known {
     // Base case for a single expression ID
     ($resolver:ident, $id:ident) => {
         if cfg!(debug_assertions) {
             $resolver.expr_types.contains_key(&$id);
+        }
     };
     // Base case for two expression IDs
     ($resolver:ident, $id1:ident, $id2:ident) => {
         debug_assert_ne!($id1, $id2);
         debug_assert_expr_ids_unique_and_known!($resolver, $id1);
         debug_assert_expr_ids_unique_and_known!($resolver, $id2);
     };
     // Generic case
     ($resolver:ident, $id1:ident, $id2:ident, $($tail:ident),+) => {
         debug_assert_ne!($id1, $id2);
         debug_assert_expr_ids_unique_and_known!($resolver, $id1);
         debug_assert_expr_ids_unique_and_known!($resolver, $id2, $($tail),+);
     };
+}
 macro_rules! debug_assert_ptrs_distinct {
     // Base case
     ($ptr1:ident, $ptr2:ident) => {
         debug_assert!(!std::ptr::eq($ptr1, $ptr2));
     };
     // Generic case
     ($ptr1:ident, $ptr2:ident, $($tail:ident),+) => {
         debug_assert_ptrs_distinct!($ptr1, $ptr2);
         debug_assert_ptrs_distinct!($ptr2, $($tail),+);
     };
+}
 enum TypeConstraintResult {
     Progress, // Success: Made progress in applying constraints
     NoProgess, // Success: But did not make any progress in applying constraints
     ErrExprType, // Error: Expression type did not match the argument(s) of the expression type
     ErrArgType, // Error: Expression argument types did not match
 impl TypeResolvingVisitor {
     fn resolve_types(&mut self, ctx: &mut Ctx, queue: &mut ResolveQueue) -> Result<(), ParseError2> {
         // Keep inferring until we can no longer make any progress
         println!("DEBUG: Resolve queue is {:?}", &self.expr_queued);
         while let Some(next_expr_id) = self.expr_queued.iter().next() {
             let next_expr_id = *next_expr_id;
             self.expr_queued.remove(&next_expr_id);
             self.progress_expr(ctx, next_expr_id)?;
+        }
         // Should have inferred everything
         for (expr_id, expr_type) in self.expr_types.iter() {
             if !expr_type.is_done {
                 let mut buffer = std::fs::File::create("type_debug.txt").unwrap();
                 use crate::protocol::ast_printer::ASTWriter;
                 let mut w = ASTWriter::new();
                 w.write_ast(&mut buffer, &ctx.heap);
                 // TODO: Auto-inference of integerlike types
                 let expr = &ctx.heap[*expr_id];
                 return Err(ParseError2::new_error(
                     &ctx.module.source, expr.position(),
                     &format!(
                         "Could not fully infer the type of this expression (got '{}')",
                         expr_type.display_name(&ctx.heap)
+                    )
                 ))
+            }
             let concrete_type = ctx.heap[*expr_id].get_type_mut();
             expr_type.write_concrete_type(concrete_type);
+        }
         // Check all things we need to monomorphize
         // TODO: Struct/enum/union monomorphization
         for (call_expr_id, extra_data) in self.extra_data.iter() {
             if extra_data.poly_vars.is_empty() { continue; }
             // We have a polymorph
             let mut monomorph_types = Vec::with_capacity(extra_data.poly_vars.len());
             for (poly_idx, poly_type) in extra_data.poly_vars.iter().enumerate() {
                 if !poly_type.is_done {
                     // TODO: Single clean function for function signatures and polyvars.
                     // TODO: Better error message
                     let expr = &ctx.heap[*call_expr_id];
                     return Err(ParseError2::new_error(
                         &ctx.module.source, expr.position(),
                         &format!(
                             "Could not fully infer the type of polymorphic variable {} of this expression (got '{}')",
                             poly_idx, poly_type.display_name(&ctx.heap)
+                        )
                     ))
+                }
                 let mut concrete_type = ConcreteType::default();
                 poly_type.write_concrete_type(&mut concrete_type);
                 monomorph_types.insert(poly_idx, concrete_type);
+            }
             // Resolve to call expression's definition
             let call_expr = if let Expression::Call(call_expr) = &ctx.heap[*call_expr_id] {
                 call_expr
             } else {
                 todo!("implement different kinds of polymorph expressions");
             };
             if let Method::Symbolic(symbolic) = &call_expr.method {
                 let definition_id = symbolic.definition.unwrap();
                 let root_id = ctx.types
                     .get_base_definition(&definition_id)
                     .unwrap()
                     .ast_root;
                 queue.push(ResolveQueueElement{
                     root_id,
                     definition_id,
                     monomorph_types,
                 })
+            }
+        }
         // Finally, if the currently resolved definition is a monomoprh, then we
         // add it to the type table
         if !self.poly_vars.is_empty() {
             let definition_id = match &self.definition_type {
                 DefinitionType::None => unreachable!(),
                 DefinitionType::Function(id) => id.upcast(),
                 DefinitionType::Component(id) => id.upcast(),
             };
             ctx.types.instantiate_monomorph(&definition_id, &self.poly_vars)
+        }
         Ok(())
+    }
     fn progress_expr(&mut self, ctx: &mut Ctx, id: ExpressionId) -> Result<(), ParseError2> {
         match &ctx.heap[id] {
             Expression::Assignment(expr) => {
                 let id = expr.this;
                 self.progress_assignment_expr(ctx, id)
             },
             Expression::Conditional(expr) => {
                 let id = expr.this;
                 self.progress_conditional_expr(ctx, id)
             },
             Expression::Binary(expr) => {
                 let id = expr.this;
                 self.progress_binary_expr(ctx, id)
             },
             Expression::Unary(expr) => {
                 let id = expr.this;
                 self.progress_unary_expr(ctx, id)
             },
             Expression::Indexing(expr) => {
                 let id = expr.this;
                 self.progress_indexing_expr(ctx, id)
             },
             Expression::Slicing(expr) => {
                 let id = expr.this;
                 self.progress_slicing_expr(ctx, id)
             },
             Expression::Select(expr) => {
                 let id = expr.this;
                 self.progress_select_expr(ctx, id)
             },
             Expression::Array(expr) => {
                 let id = expr.this;
                 self.progress_array_expr(ctx, id)
             },
             Expression::Constant(expr) => {
                 let id = expr.this;
                 self.progress_constant_expr(ctx, id)
             },
             Expression::Call(expr) => {
                 let id = expr.this;
                 self.progress_call_expr(ctx, id)
             },
             Expression::Variable(expr) => {
                 let id = expr.this;
                 self.progress_variable_expr(ctx, id)
+            }
+        }
+    }
 impl TypeResolvingVisitor {
     fn progress_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> Result<(), ParseError2> {
         use AssignmentOperator as AO;
         // TODO: Assignable check
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_expr_id = expr.left;
         let arg2_expr_id = expr.right;
         let progress_base = match expr.operation {
             AO::Set =>
                 false,
             AO::Multiplied | AO::Divided | AO::Added | AO::Subtracted =>
                 self.apply_forced_constraint(ctx, upcast_id, &NUMBERLIKE_TEMPLATE)?,
             AO::Remained | AO::ShiftedLeft | AO::ShiftedRight |
             AO::BitwiseAnded | AO::BitwiseXored | AO::BitwiseOred =>
                 self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?,
         };
         let (progress_expr, progress_arg1, progress_arg2) = self.apply_equal3_constraint(
             ctx, upcast_id, arg1_expr_id, arg2_expr_id, 0
         )?;
         if progress_base || progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg1 { self.queue_expr(arg1_expr_id); }
         if progress_arg2 { self.queue_expr(arg2_expr_id); }
         Ok(())
+    }
     fn progress_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> Result<(), ParseError2> {
         // Note: test expression type is already enforced
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_expr_id = expr.true_expression;
         let arg2_expr_id = expr.false_expression;
         let (progress_expr, progress_arg1, progress_arg2) = self.apply_equal3_constraint(
             ctx, upcast_id, arg1_expr_id, arg2_expr_id, 0
         )?;
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg1 { self.queue_expr(arg1_expr_id); }
         if progress_arg2 { self.queue_expr(arg2_expr_id); }
         Ok(())
+    }
     fn progress_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> Result<(), ParseError2> {
         // Note: our expression type might be fixed by our parent, but we still
         // need to make sure it matches the type associated with our operation.
         use BinaryOperator as BO;
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_id = expr.left;
         let arg2_id = expr.right;
         let (progress_expr, progress_arg1, progress_arg2) = match expr.operation {
             BO::Concatenate => {
                 // Arguments may be arrays/slices, output is always an array
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &ARRAY_TEMPLATE)?;
                 let progress_arg1 = self.apply_forced_constraint(ctx, arg1_id, &ARRAYLIKE_TEMPLATE)?;
                 let progress_arg2 = self.apply_forced_constraint(ctx, arg2_id, &ARRAYLIKE_TEMPLATE)?;
                 // If they're all arraylike, then we want the subtype to match
                 let (subtype_expr, subtype_arg1, subtype_arg2) =
                     self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 1)?;
                 (progress_expr || subtype_expr, progress_arg1 || subtype_arg1, progress_arg2 || subtype_arg2)
             },
             BO::LogicalOr | BO::LogicalAnd => {
                 // Forced boolean on all
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg1 = self.apply_forced_constraint(ctx, arg1_id, &BOOL_TEMPLATE)?;
                 let progress_arg2 = self.apply_forced_constraint(ctx, arg2_id, &BOOL_TEMPLATE)?;
                 (progress_expr, progress_arg1, progress_arg2)
             },
             BO::BitwiseOr | BO::BitwiseXor | BO::BitwiseAnd | BO::Remainder | BO::ShiftLeft | BO::ShiftRight => {
                 // All equal of integer type
                 let progress_base = self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg1, progress_arg2) =
                     self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg1, progress_base || progress_arg2)
             },
             BO::Equality | BO::Inequality | BO::LessThan | BO::GreaterThan | BO::LessThanEqual | BO::GreaterThanEqual => {
                 // Equal2 on args, forced boolean output
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg_base = self.apply_forced_constraint(ctx, arg1_id, &NUMBERLIKE_TEMPLATE)?;
                 let (progress_arg1, progress_arg2) =
                     self.apply_equal2_constraint(ctx, upcast_id, arg1_id, 0, arg2_id, 0)?;
                 (progress_expr, progress_arg_base || progress_arg1, progress_arg_base || progress_arg2)
             },
             BO::Add | BO::Subtract | BO::Multiply | BO::Divide => {
                 // All equal of number type
                 let progress_base = self.apply_forced_constraint(ctx, upcast_id, &NUMBERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg1, progress_arg2) =
                     self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg1, progress_base || progress_arg2)
             },
         };
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg1 { self.queue_expr(arg1_id); }
         if progress_arg2 { self.queue_expr(arg2_id); }
         Ok(())
+    }
     fn progress_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> Result<(), ParseError2> {
         use UnaryOperation as UO;
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg_id = expr.expression;
         let (progress_expr, progress_arg) = match expr.operation {
             UO::Positive | UO::Negative => {
                 // Equal types of numeric class
                 let progress_base = self.apply_forced_constraint(ctx, upcast_id, &NUMBERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg) =
                     self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, arg_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg)
             },
             UO::BitwiseNot | UO::PreIncrement | UO::PreDecrement | UO::PostIncrement | UO::PostDecrement => {
                 // Equal types of integer class
                 let progress_base = self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg) =
                     self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, arg_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg)
             },
             UO::LogicalNot => {
                 // Both booleans
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 (progress_expr, progress_arg)
+            }
         };
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg { self.queue_expr(arg_id); }
         Ok(())
+    }
     fn progress_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let subject_id = expr.subject;
         let index_id = expr.index;
         // Make sure subject is arraylike and index is integerlike
         let progress_subject_base = self.apply_forced_constraint(ctx, subject_id, &ARRAYLIKE_TEMPLATE)?;
         let progress_index = self.apply_forced_constraint(ctx, index_id, &INTEGERLIKE_TEMPLATE)?;
         // Make sure if output is of T then subject is Array<T>
         let (progress_expr, progress_subject) =
             self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, subject_id, 1)?;
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_subject_base || progress_subject { self.queue_expr(subject_id); }
         if progress_index { self.queue_expr(index_id); }
         Ok(())
+    }
     fn progress_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let subject_id = expr.subject;
         let from_id = expr.from_index;
         let to_id = expr.to_index;
         // Make sure subject is arraylike and indices are of equal integerlike
         let progress_subject_base = self.apply_forced_constraint(ctx, subject_id, &ARRAYLIKE_TEMPLATE)?;
         let progress_idx_base = self.apply_forced_constraint(ctx, from_id, &INTEGERLIKE_TEMPLATE)?;
         let (progress_from, progress_to) = self.apply_equal2_constraint(ctx, upcast_id, from_id, 0, to_id, 0)?;
         // Make sure if output is of T then subject is Array<T>
         let (progress_expr, progress_subject) =
             self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, subject_id, 1)?;
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_subject_base || progress_subject { self.queue_expr(subject_id); }
         if progress_idx_base || progress_from { self.queue_expr(from_id); }
         if progress_idx_base || progress_to { self.queue_expr(to_id); }
         Ok(())
+    }
     fn progress_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let subject_id = expr.subject;
         let (progress_subject, progress_expr) = match &expr.field {
             Field::Length => {
                 let progress_subject = self.apply_forced_constraint(ctx, subject_id, &ARRAYLIKE_TEMPLATE)?;
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?;
                 (progress_subject, progress_expr)
             },
             Field::Symbolic(_field) => {
                 todo!("implement select expr for symbolic fields");
+            }
         };
         if progress_subject { self.queue_expr(subject_id); }
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         Ok(())
+    }
     fn progress_array_expr(&mut self, ctx: &mut Ctx, id: ArrayExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let expr_elements = expr.elements.clone(); // TODO: @performance
         // All elements should have an equal type
         let progress = self.apply_equal_n_constraint(ctx, upcast_id, &expr_elements)?;
         let mut any_progress = false;
         for (progress_arg, arg_id) in progress.iter().zip(expr_elements.iter()) {
             if *progress_arg {
                 any_progress = true;
                 self.queue_expr(*arg_id);
+            }
+        }
         // And the output should be an array of the element types
         let mut expr_progress = self.apply_forced_constraint(ctx, upcast_id, &ARRAY_TEMPLATE)?;
         if !expr_elements.is_empty() {
             let first_arg_id = expr_elements[0];
             let (inner_expr_progress, arg_progress) = self.apply_equal2_constraint(
                 ctx, upcast_id, upcast_id, 1, first_arg_id, 0
             )?;
             expr_progress = expr_progress || inner_expr_progress;
             // Note that if the array type progressed the type of the arguments,
             // then we should enqueue this progression function again
             // TODO: @fix Make apply_equal_n accept a start idx as well
             if arg_progress { self.queue_expr(upcast_id); }
+        }
         if expr_progress { self.queue_expr_parent(ctx, upcast_id); }
         Ok(())
+    }
     fn progress_constant_expr(&mut self, ctx: &mut Ctx, id: ConstantExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let template = match &expr.value {
             Constant::Null => &MESSAGE_TEMPLATE,
             Constant::Integer(_) => &INTEGERLIKE_TEMPLATE,
             Constant::True | Constant::False => &BOOL_TEMPLATE,
             Constant::Character(_) => todo!("character literals")
         };
         let progress = self.apply_forced_constraint(ctx, upcast_id, template)?;
         if progress { self.queue_expr_parent(ctx, upcast_id); }
         Ok(())
+    }
     // TODO: @cleanup, see how this can be cleaned up once I implement
     //  polymorphic struct/enum/union literals. These likely follow the same
     //  pattern as here.
     fn progress_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> Result<(), ParseError2> {
         println!("DEBUG: Processing call {}", id.0.index);
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let extra = self.extra_data.get_mut(&upcast_id).unwrap();
         // Check if we can make progress using the arguments and/or return types
         // while keeping track of the polyvars we've extended
         let mut poly_progress = HashSet::new();
         debug_assert_eq!(extra.embedded.len(), expr.arguments.len());
         let mut poly_infer_error = false;
         for (arg_idx, arg_id) in expr.arguments.clone().into_iter().enumerate() {
             let signature_type = &mut extra.embedded[arg_idx];
             let argument_type: *mut _ = self.expr_types.get_mut(&arg_id).unwrap();
             let (progress_sig, progress_arg) = Self::apply_equal2_constraint_types(
                 ctx, upcast_id, signature_type, 0, argument_type, 0
             )?;
             println!("DEBUG Arg  {}: {} <--> {}", arg_idx, signature_type.display_name(&ctx.heap), unsafe{&*argument_type}.display_name(&ctx.heap));
             if progress_sig {
                 // Progressed signature, so also apply inference to the
                 // polymorph types using the markers
                 debug_assert!(signature_type.has_marker, "progress on signature argument type without markers");
                 for (poly_idx, poly_section) in signature_type.marker_iter() {
                     let polymorph_type = &mut extra.poly_vars[poly_idx];
                     match Self::apply_forced_constraint_types(
                         polymorph_type, 0, poly_section, 0
                     ) {
                         Ok(true) => { poly_progress.insert(poly_idx); },
                         Ok(false) => {},
                         Err(()) => { poly_infer_error = true; }
+                    }
                     println!("DEBUG Poly {}: {} <--> {}", poly_idx, polymorph_type.display_name(&ctx.heap), InferenceType::partial_display_name(&ctx.heap, poly_section));
+                }
+            }
             if progress_arg {
                 // Progressed argument expression
                 self.expr_queued.insert(arg_id);
+            }
+        }
         // Do the same for the return type
         let signature_type = &mut extra.returned;
         let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();
         let (progress_sig, progress_expr) = Self::apply_equal2_constraint_types(
             ctx, upcast_id, signature_type, 0, expr_type, 0
         )?;
         println!("DEBUG Ret  {} <--> {}", signature_type.display_name(&ctx.heap), unsafe{&*expr_type}.display_name(&ctx.heap));
         if progress_sig {
             // As above: apply inference to polyargs as well
             debug_assert!(signature_type.has_marker, "progress on signature return type without markers");
             for (poly_idx, poly_section) in signature_type.marker_iter() {
                 let polymorph_type = &mut extra.poly_vars[poly_idx];
                 match Self::apply_forced_constraint_types(
                     polymorph_type, 0, poly_section, 0
                 ) {
                     Ok(true) => { poly_progress.insert(poly_idx); },
                     Ok(false) => {},
                     Err(()) => { poly_infer_error = true; }
+                }
                 println!("DEBUG Poly {}: {} <--> {}", poly_idx, polymorph_type.display_name(&ctx.heap), InferenceType::partial_display_name(&ctx.heap, poly_section));
+            }
+        }
         if progress_expr {
             if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {
                 self.expr_queued.insert(parent_id);
+            }
+        }
         // If we had an error in the polymorphic variable's inference, then we
         // need to provide a human readable error: find a pair of inference
         // types in the arguments/return type that do not agree on the
         // polymorphic variable's type
         if poly_infer_error { return Err(self.construct_poly_arg_error(ctx, id)) }
         // If we did not have an error in the polymorph inference above, then
         // reapplying the polymorph type to each argument type and the return
         // type should always succeed.
         // TODO: @performance If the algorithm is changed to be more "on demand
         //  argument re-evaluation", instead of "all-argument re-evaluation",
         //  then this is no longer true
         for poly_idx in poly_progress.into_iter() {
             // For each polymorphic argument: first extend the signature type,
             // then reapply the equal2 constraint to the expressions
             let poly_type = &extra.poly_vars[poly_idx];
             for (arg_idx, sig_type) in extra.embedded.iter_mut().enumerate() {
                 let mut seek_idx = 0;
                 let mut modified_sig = false;
                 while let Some((start_idx, end_idx)) = sig_type.find_subtree_idx_for_marker(poly_idx, seek_idx) {
                     let modified_at_marker = Self::apply_forced_constraint_types(
                         sig_type, start_idx, &poly_type.parts, 0
                     ).unwrap();
                     modified_sig = modified_sig || modified_at_marker;
                     seek_idx = end_idx;
+                }
                 if !modified_sig { continue; }
                 // Part of signature was modified, so update expression used as
                 // argument as well
                 let arg_expr_id = expr.arguments[arg_idx];
                 let arg_type: *mut _ = self.expr_types.get_mut(&arg_expr_id).unwrap();
                 let (progress_arg, _) = Self::apply_equal2_constraint_types(
                     ctx, arg_expr_id, arg_type, 0, sig_type, 0
                 ).expect("no inference error at argument type");
                 if progress_arg { self.expr_queued.insert(arg_expr_id); }
+            }
             // Again: do the same for the return type
             let sig_type = &mut extra.returned;
             let mut seek_idx = 0;
             let mut modified_sig = false;
             while let Some((start_idx, end_idx)) = sig_type.find_subtree_idx_for_marker(poly_idx, seek_idx) {
                 let modified_at_marker = Self::apply_forced_constraint_types(
                     sig_type, start_idx, &poly_type.parts, 0
                 ).unwrap();
                 modified_sig = modified_sig || modified_at_marker;
                 seek_idx = end_idx;
+            }
             if modified_sig {
                 let ret_type = self.expr_types.get_mut(&upcast_id).unwrap();
                 let (progress_ret, _) = Self::apply_equal2_constraint_types(
                     ctx, upcast_id, ret_type, 0, sig_type, 0
                 ).expect("no inference error at return type");
                 if progress_ret {
                     if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {
                         self.expr_queued.insert(parent_id);
+                    }
+                }
+            }
+        }
         Ok(())
+    }
     fn progress_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let var_expr = &ctx.heap[id];
         let var_id = var_expr.declaration.unwrap();
         // Retrieve shared variable type and expression type and apply inference
         let var_data = self.var_types.get_mut(&var_id).unwrap();
         let expr_type = self.expr_types.get_mut(&upcast_id).unwrap();
         let infer_res = unsafe{ InferenceType::infer_subtrees_for_both_types(
             &mut var_data.var_type as *mut _, 0, expr_type, 0
         ) };
         if infer_res == DualInferenceResult::Incompatible {
             let var_decl = &ctx.heap[var_id];
             return Err(ParseError2::new_error(
                 &ctx.module.source, var_decl.position(),
                 &format!(
                     "Conflicting types for this variable, previously assigned the type '{}'",
                     var_data.var_type.display_name(&ctx.heap)
+                )
             ).with_postfixed_info(
                 &ctx.module.source, var_expr.position,
                 &format!(
                     "But inferred to have incompatible type '{}' here",
                     expr_type.display_name(&ctx.heap)
+                )
             ))
+        }
         let progress_var = infer_res.modified_lhs();
         let progress_expr = infer_res.modified_rhs();
         if progress_var {
             for other_expr in var_data.used_at.iter() {
                 if *other_expr != upcast_id {
                     self.expr_queued.insert(*other_expr);
+                }
+            }
+        }
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         Ok(())
+    }
     fn queue_expr_parent(&mut self, ctx: &Ctx, expr_id: ExpressionId) {
         if let ExpressionParent::Expression(parent_expr_id, _) = &ctx.heap[expr_id].parent() {
             self.expr_queued.insert(*parent_expr_id);
+        }
+    }
     fn queue_expr(&mut self, expr_id: ExpressionId) {
         self.expr_queued.insert(expr_id);
+    }
     /// Applies a forced type constraint: the type associated with the supplied
     /// expression will be molded into the provided "template". The template may
     /// be fully specified (e.g. a bool) or contain "inference" variables (e.g.
     /// an array of T)
     fn apply_forced_constraint(
         &mut self, ctx: &mut Ctx, expr_id: ExpressionId, template: &[InferenceTypePart]
     ) -> Result<bool, ParseError2> {
         debug_assert_expr_ids_unique_and_known!(self, expr_id);
         let expr_type = self.expr_types.get_mut(&expr_id).unwrap();
         match InferenceType::infer_subtree_for_single_type(expr_type, 0, template, 0) {
             SingleInferenceResult::Modified => Ok(true),
             SingleInferenceResult::Unmodified => Ok(false),
             SingleInferenceResult::Incompatible => Err(
                 self.construct_template_type_error(ctx, expr_id, template)
+            )
+        }
+    }
     fn apply_forced_constraint_types(
         to_infer: *mut InferenceType, to_infer_start_idx: usize,
         template: &[InferenceTypePart], template_start_idx: usize
     ) -> Result<bool, ()> {
         match InferenceType::infer_subtree_for_single_type(
             unsafe{ &mut *to_infer }, to_infer_start_idx,
             template, template_start_idx
         ) {
             SingleInferenceResult::Modified => Ok(true),
             SingleInferenceResult::Unmodified => Ok(false),
             SingleInferenceResult::Incompatible => Err(()),
+        }
+    }
     /// Applies a type constraint that expects the two provided types to be
     /// equal. We attempt to make progress in inferring the types. If the call
     /// is successful then the composition of all types are made equal.
     /// The "parent" `expr_id` is provided to construct errors.
     fn apply_equal2_constraint(
         &mut self, ctx: &Ctx, expr_id: ExpressionId,
         arg1_id: ExpressionId, arg1_start_idx: usize,
         arg2_id: ExpressionId, arg2_start_idx: usize
     ) -> Result<(bool, bool), ParseError2> {
         debug_assert_expr_ids_unique_and_known!(self, arg1_id, arg2_id);
         let arg1_type: *mut _ = self.expr_types.get_mut(&arg1_id).unwrap();
         let arg2_type: *mut _ = self.expr_types.get_mut(&arg2_id).unwrap();
         let infer_res = unsafe{ InferenceType::infer_subtrees_for_both_types(
             arg1_type, arg1_start_idx,
             arg2_type, arg2_start_idx
         ) };
         if infer_res == DualInferenceResult::Incompatible {
             return Err(self.construct_arg_type_error(ctx, expr_id, arg1_id, arg2_id));
+        }
         Ok((infer_res.modified_lhs(), infer_res.modified_rhs()))
+    }
     fn apply_equal2_constraint_types(
         ctx: &Ctx, expr_id: ExpressionId,
         type1: *mut InferenceType, type1_start_idx: usize,
         type2: *mut InferenceType, type2_start_idx: usize
     ) -> Result<(bool, bool), ParseError2> {
         debug_assert_ptrs_distinct!(type1, type2);
         let infer_res = unsafe {
             InferenceType::infer_subtrees_for_both_types(
                 type1, type1_start_idx,
                 type2, type2_start_idx
+            )
         };
         if infer_res == DualInferenceResult::Incompatible {
             return Err(ParseError2::new_error(
                 &ctx.module.source, ctx.heap[expr_id].position(),
                 "TODO: Write me, apply_equal2_constraint_types"
             ));
+        }
         Ok((infer_res.modified_lhs(), infer_res.modified_rhs()))
+    }
     /// Applies a type constraint that expects all three provided types to be
     /// equal. In case we can make progress in inferring the types then we
     /// attempt to do so. If the call is successful then the composition of all
     /// types is made equal.
     fn apply_equal3_constraint(
         &mut self, ctx: &Ctx, expr_id: ExpressionId,
         arg1_id: ExpressionId, arg2_id: ExpressionId,
         start_idx: usize
     ) -> Result<(bool, bool, bool), ParseError2> {
         // Safety: all expression IDs are always distinct, and we do not modify
         //  the container
         debug_assert_expr_ids_unique_and_known!(self, expr_id, arg1_id, arg2_id);
         let expr_type: *mut _ = self.expr_types.get_mut(&expr_id).unwrap();
         let arg1_type: *mut _ = self.expr_types.get_mut(&arg1_id).unwrap();
         let arg2_type: *mut _ = self.expr_types.get_mut(&arg2_id).unwrap();
         let expr_res = unsafe{
             InferenceType::infer_subtrees_for_both_types(expr_type, start_idx, arg1_type, start_idx)
         };
         if expr_res == DualInferenceResult::Incompatible {
             return Err(self.construct_expr_type_error(ctx, expr_id, arg1_id));
+        }
         let args_res = unsafe{
             InferenceType::infer_subtrees_for_both_types(arg1_type, start_idx, arg2_type, start_idx) };
         if args_res == DualInferenceResult::Incompatible {
             return Err(self.construct_arg_type_error(ctx, expr_id, arg1_id, arg2_id));
+        }
         // If all types are compatible, but the second call caused the arg1_type
         // to be expanded, then we must also assign this to expr_type.
         let mut progress_expr = expr_res.modified_lhs();
         let mut progress_arg1 = expr_res.modified_rhs();
         let mut progress_arg2 = args_res.modified_rhs();
         if args_res.modified_lhs() {
             unsafe {
                 let end_idx = InferenceType::find_subtree_end_idx(&(*arg2_type).parts, start_idx);
                 let subtree = &((*arg2_type).parts[start_idx..end_idx]);
                 (*expr_type).replace_subtree(start_idx, subtree);
+            }
             progress_expr = true;
             progress_arg1 = true;
+        }
         Ok((progress_expr, progress_arg1, progress_arg2))
+    }
     // TODO: @optimize Since we only deal with a single type this might be done
     //  a lot more efficiently, methinks (disregarding the allocations here)
     fn apply_equal_n_constraint(
         &mut self, ctx: &Ctx, expr_id: ExpressionId, args: &[ExpressionId],
     ) -> Result<Vec<bool>, ParseError2> {
         // Early exit
         match args.len() {
 => return Ok(vec!()),         // nothing to progress
 => return Ok(vec![false]),    // only one type, so nothing to infer
             _ => {}
+        }
         let mut progress = Vec::new();
         progress.resize(args.len(), false);
         // Do pairwise inference, keep track of the last entry we made progress
         // on. Once done we need to update everything to the most-inferred type.
         let mut arg_iter = args.iter();
         let mut last_arg_id = *arg_iter.next().unwrap();
         let mut last_lhs_progressed = 0;
         let mut lhs_arg_idx = 0;
         while let Some(next_arg_id) = arg_iter.next() {
             let arg1_type: *mut _ = self.expr_types.get_mut(&last_arg_id).unwrap();
             let arg2_type: *mut _ = self.expr_types.get_mut(next_arg_id).unwrap();
             let res = unsafe {
                 InferenceType::infer_subtrees_for_both_types(arg1_type, 0, arg2_type, 0)
             };
             if res == DualInferenceResult::Incompatible {
                 return Err(self.construct_arg_type_error(ctx, expr_id, last_arg_id, *next_arg_id));
+            }
             if res.modified_lhs() {
                 // We re-inferred something on the left hand side, so everything
                 // up until now should be re-inferred.
                 progress[lhs_arg_idx] = true;
                 last_lhs_progressed = lhs_arg_idx;
+            }
             progress[lhs_arg_idx + 1] = res.modified_rhs();
             last_arg_id = *next_arg_id;
             lhs_arg_idx += 1;
+        }
         // Re-infer everything. Note that we do not need to re-infer the type
         // exactly at `last_lhs_progressed`, but only everything up to it.
         let last_type: *mut _ = self.expr_types.get_mut(args.last().unwrap()).unwrap();
         for arg_idx in 0..last_lhs_progressed {
             let arg_type: *mut _ = self.expr_types.get_mut(&args[arg_idx]).unwrap();
             unsafe{
                 (*arg_type).replace_subtree(0, &(*last_type).parts);
+            }
             progress[arg_idx] = true;
+        }
         Ok(progress)
+    }
     /// Determines the `InferenceType` for the expression based on the
     /// expression parent. Note that if the parent is another expression, we do
     /// not take special action, instead we let parent expressions fix the type
     /// of subexpressions before they have a chance to call this function.
     /// Hence: if the expression type is already set, this function doesn't do
     /// anything.
     fn insert_initial_expr_inference_type(
         &mut self, ctx: &mut Ctx, expr_id: ExpressionId
     ) -> Result<(), ParseError2> {
         use ExpressionParent as EP;
         use InferenceTypePart as ITP;
         let expr = &ctx.heap[expr_id];
         let inference_type = match expr.parent() {
             EP::None =>
                 // Should have been set by linker
                 unreachable!(),
             EP::Memory(_) | EP::ExpressionStmt(_) | EP::Expression(_, _) =>
                 // Determined during type inference
                 InferenceType::new(false, false, vec![ITP::Unknown]),
             EP::If(_) | EP::While(_) | EP::Assert(_) =>
                 // Must be a boolean
                 InferenceType::new(false, true, vec![ITP::Bool]),
             EP::Return(_) =>
                 // Must match the return type of the function
                 if let DefinitionType::Function(func_id) = self.definition_type {
                     let return_parser_type_id = ctx.heap[func_id].return_type;
                     self.determine_inference_type_from_parser_type(ctx, return_parser_type_id, true)
                 } else {
                     // Cannot happen: definition always set upon body traversal
                     // and "return" calls in components are illegal.
                     unreachable!();
                 },
             EP::New(_) =>
                 // Must be a component call, which we assign a "Void" return
                 // type
                 InferenceType::new(false, true, vec![ITP::Void]),
         };
         match self.expr_types.entry(expr_id) {
             Entry::Vacant(vacant) => {
                 vacant.insert(inference_type);
             },
             Entry::Occupied(mut preexisting) => {
                 // We already have an entry, this happens if our parent fixed
                 // our type (e.g. we're used in a conditional expression's test)
                 // but we have a different type.
                 // TODO: Is this ever called? Seems like it can't
                 debug_assert!(false, "I am actually called, my ID is {}", expr_id.index);
                 let old_type = preexisting.get_mut();
                 if let SingleInferenceResult::Incompatible = InferenceType::infer_subtree_for_single_type(
                     old_type, 0, &inference_type.parts, 0
                 ) {
                     return Err(self.construct_expr_type_error(ctx, expr_id, expr_id))
+                }
+            }
+        }
         Ok(())
+    }
     fn insert_initial_call_polymorph_data(
         &mut self, ctx: &mut Ctx, call_id: CallExpressionId
     ) {
         use InferenceTypePart as ITP;
         // Note: the polymorph variables may be partially specified and may
         // contain references to the wrapping definition's (i.e. the proctype
         // we are currently visiting) polymorphic arguments.
         //
         // The arguments of the call may refer to polymorphic variables in the
         // definition of the function we're calling, not of the wrapping
         // definition. We insert markers in these inferred types to be able to
         // map them back and forth to the polymorphic arguments of the function
         // we are calling.
         let call = &ctx.heap[call_id];
         debug_assert!(!call.poly_args.is_empty());
         // Handle the polymorphic variables themselves
         let mut poly_vars = Vec::with_capacity(call.poly_args.len());
         for poly_arg_type_id in call.poly_args.clone() { // TODO: @performance
             poly_vars.push(self.determine_inference_type_from_parser_type(ctx, poly_arg_type_id, true));
+        }
         // Handle the arguments
         // TODO: @cleanup: Maybe factor this out for reuse in the validator/linker, should also
         //  make the code slightly more robust.
         let (embedded_types, return_type) = match &call.method {
             Method::Create => {
                 // Not polymorphic
                 unreachable!("insert initial polymorph data for builtin 'create()' call")
             },
             Method::Fires => {
                 // bool fires<T>(PortLike<T> arg)
+                (
                     vec![InferenceType::new(true, false, vec![ITP::PortLike, ITP::Marker(0), ITP::Unknown])],
                     InferenceType::new(false, true, vec![ITP::Bool])
+                )
             },
             Method::Get => {
                 // T get<T>(input<T> arg)
+                (
                     vec![InferenceType::new(true, false, vec![ITP::Input, ITP::Marker(0), ITP::Unknown])],
                     InferenceType::new(true, false, vec![ITP::Marker(0), ITP::Unknown])
+                )
             },
             Method::Put => {
                 // void Put<T>(output<T> port, T msg)
+                (
                     vec![
                         InferenceType::new(true, false, vec![ITP::Output, ITP::Marker(0), ITP::Unknown]),
                         InferenceType::new(true, false, vec![ITP::Marker(0), ITP::Unknown])
                     ],
                     InferenceType::new(false, true, vec![ITP::Void])
+                )
+            }
             Method::Symbolic(symbolic) => {
                 let definition = &ctx.heap[symbolic.definition.unwrap()];
                 match definition {
                     Definition::Component(definition) => {
                         let mut parameter_types = Vec::with_capacity(definition.parameters.len());
                         for param_id in definition.parameters.clone() {
                             let param = &ctx.heap[param_id];
                             let param_parser_type_id = param.parser_type;
                             parameter_types.push(self.determine_inference_type_from_parser_type(ctx, param_parser_type_id, false));
+                        }
                         (parameter_types, InferenceType::new(false, true, vec![InferenceTypePart::Void]))
                     },
                     Definition::Function(definition) => {
                         let mut parameter_types = Vec::with_capacity(definition.parameters.len());
                         for param_id in definition.parameters.clone() {
                             let param = &ctx.heap[param_id];
                             let param_parser_type_id = param.parser_type;
                             parameter_types.push(self.determine_inference_type_from_parser_type(ctx, param_parser_type_id, false));
+                        }
                         let return_type = self.determine_inference_type_from_parser_type(ctx, definition.return_type, false);
                         (parameter_types, return_type)
                     },
                     Definition::Struct(_) | Definition::Enum(_) => {
                         unreachable!("insert initial polymorph data for struct/enum");
+                    }
+                }
+            }
         };
         self.extra_data.insert(call_id.upcast(), ExtraData {
             poly_vars,
             embedded: embedded_types,
             returned: return_type
         });
+    }
     /// Determines the initial InferenceType from the provided ParserType. This
     /// may be called with two kinds of intentions:
     /// 1. To resolve a ParserType within the body of a function, or on
     ///     polymorphic arguments to calls/instantiations within that body. This
     ///     means that the polymorphic variables are known and can be replaced
     ///     with the monomorph we're instantiating.
     /// 2. To resolve a ParserType on a called function's definition or on
     ///     an instantiated datatype's members. This means that the polymorphic
     ///     arguments inside those ParserTypes refer to the polymorphic
     ///     variables in the called/instantiated type's definition.
     /// In the second case we place InferenceTypePart::Marker instances such
     /// that we can perform type inference on the polymorphic variables.
     fn determine_inference_type_from_parser_type(
         &mut self, ctx: &Ctx, parser_type_id: ParserTypeId,
         parser_type_in_body: bool
     ) -> InferenceType {
         use ParserTypeVariant as PTV;
         use InferenceTypePart as ITP;
         let mut to_consider = VecDeque::with_capacity(16);
         to_consider.push_back(parser_type_id);
         let mut infer_type = Vec::new();
         let mut has_inferred = false;
         let mut has_markers = false;
         while !to_consider.is_empty() {
             let parser_type_id = to_consider.pop_front().unwrap();
             let parser_type = &ctx.heap[parser_type_id];
             match &parser_type.variant {
                 PTV::Message => { infer_type.push(ITP::Message); },
                 PTV::Bool => { infer_type.push(ITP::Bool); },
                 PTV::Byte => { infer_type.push(ITP::Byte); },
                 PTV::Short => { infer_type.push(ITP::Short); },
                 PTV::Int => { infer_type.push(ITP::Int); },
                 PTV::Long => { infer_type.push(ITP::Long); },
                 PTV::String => { infer_type.push(ITP::String); },
                 PTV::IntegerLiteral => { unreachable!("integer literal type on variable type"); },
                 PTV::Inferred => {
                     infer_type.push(ITP::Unknown);
                     has_inferred = true;
                 },
                 PTV::Array(subtype_id) => {
                     infer_type.push(ITP::Array);
                     to_consider.push_front(*subtype_id);
                 },
                 PTV::Input(subtype_id) => {
                     infer_type.push(ITP::Input);
                     to_consider.push_front(*subtype_id);
                 },
                 PTV::Output(subtype_id) => {
                     infer_type.push(ITP::Output);
                     to_consider.push_front(*subtype_id);
                 },
                 PTV::Symbolic(symbolic) => {
                     debug_assert!(symbolic.variant.is_some(), "symbolic variant not yet determined");
                     match symbolic.variant.as_ref().unwrap() {
                         SymbolicParserTypeVariant::PolyArg(_, arg_idx) => {
                             // Retrieve concrete type of argument and add it to
                             // the inference type.
                             let arg_idx = *arg_idx;
                             debug_assert!(symbolic.poly_args.is_empty()); // TODO: @hkt
                             if parser_type_in_body {
                                 debug_assert!(arg_idx < self.polyvars.len());
                                 for concrete_part in &self.polyvars[arg_idx].v {
                                 debug_assert!(arg_idx < self.poly_vars.len());
                                 for concrete_part in &self.poly_vars[arg_idx].parts {
                                     infer_type.push(ITP::from(*concrete_part));
+                                }
                             } else {
                                 has_markers = true;
                                 has_inferred = true;
                                 infer_type.push(ITP::Marker(arg_idx));
                                 infer_type.push(ITP::Unknown);
+                            }
                         },
                         SymbolicParserTypeVariant::Definition(definition_id) => {
                             // TODO: @cleanup
                             if cfg!(debug_assertions) {
                                 let definition = &ctx.heap[*definition_id];
                                 debug_assert!(definition.is_struct() || definition.is_enum()); // TODO: @function_ptrs
                                 let num_poly = match definition {
                                     Definition::Struct(v) => v.poly_vars.len(),
                                     Definition::Enum(v) => v.poly_vars.len(),
                                     _ => unreachable!(),
                                 };
                                 debug_assert_eq!(symbolic.poly_args.len(), num_poly);
+                            }
                             infer_type.push(ITP::Instance(*definition_id, symbolic.poly_args.len()));
                             let mut poly_arg_idx = symbolic.poly_args.len();
                             while poly_arg_idx > 0 {
                                 poly_arg_idx -= 1;
                                 to_consider.push_front(symbolic.poly_args[poly_arg_idx]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
         InferenceType::new(has_markers, !has_inferred, infer_type)
+    }
     /// Construct an error when an expression's type does not match. This
     /// happens if we infer the expression type from its arguments (e.g. the
     /// expression type of an addition operator is the type of the arguments)
     /// But the expression type was already set due to our parent (e.g. an
     /// "if statement" or a "logical not" always expecting a boolean)
     fn construct_expr_type_error(
         &self, ctx: &Ctx, expr_id: ExpressionId, arg_id: ExpressionId
     ) -> ParseError2 {
         // TODO: Expand and provide more meaningful information for humans
         let expr = &ctx.heap[expr_id];
         let arg_expr = &ctx.heap[arg_id];
         let expr_type = self.expr_types.get(&expr_id).unwrap();
         let arg_type = self.expr_types.get(&arg_id).unwrap();
         return ParseError2::new_error(
             &ctx.module.source, expr.position(),
             &format!(
                 "Incompatible types: this expression expected a '{}'",
                 expr_type.display_name(&ctx.heap)
+            )
         ).with_postfixed_info(
             &ctx.module.source, arg_expr.position(),
             &format!(
                 "But this expression yields a '{}'",
                 arg_type.display_name(&ctx.heap)
+            )
+        )
+    }
     fn construct_arg_type_error(
         &self, ctx: &Ctx, expr_id: ExpressionId,
         arg1_id: ExpressionId, arg2_id: ExpressionId
     ) -> ParseError2 {
         let expr = &ctx.heap[expr_id];
         let arg1 = &ctx.heap[arg1_id];
         let arg2 = &ctx.heap[arg2_id];
         let arg1_type = self.expr_types.get(&arg1_id).unwrap();
         let arg2_type = self.expr_types.get(&arg2_id).unwrap();
         return ParseError2::new_error(
             &ctx.module.source, expr.position(),
             "Incompatible types: cannot apply this expression"
         ).with_postfixed_info(
             &ctx.module.source, arg1.position(),
             &format!(
                 "Because this expression has type '{}'",
                 arg1_type.display_name(&ctx.heap)
+            )
         ).with_postfixed_info(
             &ctx.module.source, arg2.position(),
             &format!(
                 "But this expression has type '{}'",
                 arg2_type.display_name(&ctx.heap)
+            )
+        )
+    }
     fn construct_template_type_error(
         &self, ctx: &Ctx, expr_id: ExpressionId, template: &[InferenceTypePart]
     ) -> ParseError2 {
         let expr = &ctx.heap[expr_id];
         let expr_type = self.expr_types.get(&expr_id).unwrap();
         return ParseError2::new_error(
             &ctx.module.source, expr.position(),
             &format!(
                 "Incompatible types: got a '{}' but expected a '{}'",
                 expr_type.display_name(&ctx.heap),
                 InferenceType::partial_display_name(&ctx.heap, template)
+            )
+        )
+    }
     /// Constructs a human interpretable error in the case that type inference
     /// on a polymorphic variable to a function call failed. This may only be
     /// caused by a pair of inference types (which may come from arguments or
     /// the return type) having two different inferred values for that
     /// polymorphic variable.
     ///
     /// So we find this pair (which may be a argument type or return type
     /// conflicting with itself) and construct the error using it.
     fn construct_poly_arg_error(
         &self, ctx: &Ctx, call_id: CallExpressionId
     ) -> ParseError2 {
         // Helper function to check for polymorph mismatch between two inference
         // types.
         fn has_poly_mismatch<'a>(type_a: &'a InferenceType, type_b: &'a InferenceType) -> Option<(usize, &'a [InferenceTypePart], &'a [InferenceTypePart])> {
             if !type_a.has_marker || !type_b.has_marker {
                 return None
+            }
             for (marker_a, section_a) in type_a.marker_iter() {
                 for (marker_b, section_b) in type_b.marker_iter() {
                     if marker_a != marker_b {
                         // Not the same polymorphic variable
                         continue;
+                    }
                     if !InferenceType::check_subtrees(section_a, 0, section_b, 0) {
                         // Not compatible
                         return Some((marker_a, section_a, section_b))
+                    }
+                }
+            }
             None
+        }
         // Helpers function to retrieve polyvar name and function name
         fn get_poly_var_and_func_name(ctx: &Ctx, poly_var_idx: usize, expr: &CallExpression) -> (String, String) {
             match &expr.method {
                 Method::Create => unreachable!(),
                 Method::Fires => (String::from('T'), String::from("fires")),
                 Method::Get => (String::from('T'), String::from("get")),
                 Method::Put => (String::from('T'), String::from("put")),
                 Method::Symbolic(symbolic) => {
                     let definition = &ctx.heap[symbolic.definition.unwrap()];
                     let poly_var = match definition {
                         Definition::Struct(_) | Definition::Enum(_) => unreachable!(),
                         Definition::Function(definition) => {
                             String::from_utf8_lossy(&definition.poly_vars[poly_var_idx].value).to_string()
                         },
                         Definition::Component(definition) => {
                             String::from_utf8_lossy(&definition.poly_vars[poly_var_idx].value).to_string()
+                        }
                     };
                     let func_name = String::from_utf8_lossy(&symbolic.identifier.value).to_string();
                     (poly_var, func_name)
+                }
+            }
+        }
         // Helper function to construct initial error
         fn construct_main_error(ctx: &Ctx, poly_var_idx: usize, expr: &CallExpression) -> ParseError2 {
             let (poly_var, func_name) = get_poly_var_and_func_name(ctx, poly_var_idx, expr);
             return ParseError2::new_error(
                 &ctx.module.source, expr.position(),
                 &format!(
                     "Conflicting type for polymorphic variable '{}' of '{}'",
                     poly_var, func_name
+                )
+            )
+        }
         // Actual checking
         let extra = self.extra_data.get(&call_id.upcast()).unwrap();
         let expr = &ctx.heap[call_id];
         // - check return type with itself
         if let Some((poly_idx, section_a, section_b)) = has_poly_mismatch(&extra.returned, &extra.returned) {
             return construct_main_error(ctx, poly_idx, expr)
                 .with_postfixed_info(
                     &ctx.module.source, expr.position(),
                     &format!(
                         "The return type inferred the conflicting types '{}' and '{}'",
                         InferenceType::partial_display_name(&ctx.heap, section_a),
                         InferenceType::partial_display_name(&ctx.heap, section_b)
+                    )
+                )
+        }
         // - check arguments with each other argument and with return type
         for (arg_a_idx, arg_a) in extra.embedded.iter().enumerate() {
             for (arg_b_idx, arg_b) in extra.embedded.iter().enumerate() {
                 if arg_b_idx > arg_a_idx {
                     break;
+                }
                 if let Some((poly_idx, section_a, section_b)) = has_poly_mismatch(&arg_a, &arg_b) {
                     let error = construct_main_error(ctx, poly_idx, expr);
                     if arg_a_idx == arg_b_idx {
                         // Same argument
                         let arg = &ctx.heap[expr.arguments[arg_a_idx]];
                         return error.with_postfixed_info(
                             &ctx.module.source, arg.position(),
                             &format!(
                                 "This argument inferred the conflicting types '{}' and '{}'",
                                 InferenceType::partial_display_name(&ctx.heap, section_a),
                                 InferenceType::partial_display_name(&ctx.heap, section_b)
+                            )
+                        )
                     } else {
                         let arg_a = &ctx.heap[expr.arguments[arg_a_idx]];
                         let arg_b = &ctx.heap[expr.arguments[arg_b_idx]];
                         return error.with_postfixed_info(
                             &ctx.module.source, arg_a.position(),
                             &format!(
                                 "This argument inferred it to '{}'",
                                 InferenceType::partial_display_name(&ctx.heap, section_a)
+                            )
                         ).with_postfixed_info(
                             &ctx.module.source, arg_b.position(),
                             &format!(
                                 "While this argument inferred it to '{}'",
                                 InferenceType::partial_display_name(&ctx.heap, section_b)
+                            )
+                        )
+                    }
+                }
+            }
             // Check with return type
             if let Some((poly_idx, section_arg, section_ret)) = has_poly_mismatch(arg_a, &extra.returned) {
                 let arg = &ctx.heap[expr.arguments[arg_a_idx]];
                 return construct_main_error(ctx, poly_idx, expr)
                     .with_postfixed_info(
                         &ctx.module.source, arg.position(),
                         &format!(
                             "This argument inferred it to '{}'",
                             InferenceType::partial_display_name(&ctx.heap, section_arg)
+                        )
+                    )
                     .with_postfixed_info(
                         &ctx.module.source, expr.position,
                         &format!(
                             "While the return type inferred it to '{}'",
                             InferenceType::partial_display_name(&ctx.heap, section_ret)
+                        )
+                    )
+            }
+        }
         unreachable!("construct_poly_arg_error without actual error found?")
+    }
+}
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::protocol::arena::Id;
     use InferenceTypePart as ITP;
     use InferenceType as IT;
     #[test]
     fn test_single_part_inference() {
         // lhs argument inferred from rhs
         let pairs = [
             (ITP::NumberLike, ITP::Byte),
             (ITP::IntegerLike, ITP::Int),
             (ITP::Unknown, ITP::Message),
             (ITP::Unknown, ITP::String)
         ];
         for (lhs, rhs) in pairs.iter() {
             // Using infer-both
             let mut lhs_type = IT::new(false, false, vec![lhs.clone()]);
             let mut rhs_type = IT::new(false, true, vec![rhs.clone()]);
             let result = unsafe{ IT::infer_subtrees_for_both_types(
                 &mut lhs_type, 0, &mut rhs_type, 0
             ) };
             assert_eq!(DualInferenceResult::First, result);
             assert_eq!(lhs_type.parts, rhs_type.parts);
             // Using infer-single
             let mut lhs_type = IT::new(false, false, vec![lhs.clone()]);
             let mut rhs_type = IT::new(false, true, vec![rhs.clone()]);
             let result = unsafe{ IT::infer_subtree_for_single_type(
                 &mut lhs_type, 0, &rhs_type.parts, 0
             ) };
             assert_eq!(SingleInferenceResult::Modified, result);
             assert_eq!(lhs_type.parts, rhs_type.parts);
+        }
+    }
     #[test]
     fn test_multi_part_inference() {
         let pairs = [
             (vec![ITP::ArrayLike, ITP::NumberLike], vec![ITP::Slice, ITP::Byte]),
             (vec![ITP::Unknown], vec![ITP::Input, ITP::Array, ITP::String]),
             (vec![ITP::PortLike, ITP::Int], vec![ITP::Input, ITP::Int]),
             (vec![ITP::Unknown], vec![ITP::Output, ITP::Int]),
+            (
                 vec![ITP::Instance(Id::new(0), 2), ITP::Input, ITP::Unknown, ITP::Output, ITP::Unknown],
                 vec![ITP::Instance(Id::new(0), 2), ITP::Input, ITP::Array, ITP::Int, ITP::Output, ITP::Int]
+            )
         ];
         for (lhs, rhs) in pairs.iter() {
             let mut lhs_type = IT::new(false, false, lhs.clone());
             let mut rhs_type = IT::new(false, false, rhs.clone());
             let result = unsafe{ IT::infer_subtrees_for_both_types(
                 &mut lhs_type, 0, &mut rhs_type, 0
             ) };
             assert_eq!(DualInferenceResult::First, result);
             assert_eq!(lhs_type.parts, rhs_type.parts);
             let mut lhs_type = IT::new(false, false, lhs.clone());
             let mut rhs_type = IT::new(false, false, rhs.clone());
             let result = unsafe{ IT::infer_subtree_for_single_type(
                 &mut lhs_type, 0, &rhs_type.parts, 0
             ) };
             assert_eq!(SingleInferenceResult::Modified, result);
             assert_eq!(lhs_type.parts, rhs_type.parts)
+        }
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/type_table.rs

➞

Show inline comments

 /**
 TypeTable
 Contains the type table: a datastructure that, when compilation succeeds,
 contains a concrete type definition for each AST type definition. In general
 terms the type table will go through the following phases during the compilation
 process:
 . The base type definitions are resolved after the parser phase has
         finished. This implies that the AST is fully constructed, but not yet
         annotated.
 . With the base type definitions resolved, the validation/linker phase will
         use the type table (together with the symbol table) to disambiguate
         terms (e.g. does an expression refer to a variable, an enum, a constant,
         etc.)
 . During the type checking/inference phase the type table is used to ensure
         that the AST contains valid use of types in expressions and statements.
         At the same time type inference will find concrete instantiations of
         polymorphic types, these will be stored in the type table as monomorphed
         instantiations of a generic type.
 . After type checking and inference (and possibly when constructing byte
         code) the type table will construct a type graph and solidify each
         non-polymorphic type and monomorphed instantiations of polymorphic types
         into concrete types.
 So a base type is defined by its (optionally polymorphic) representation in the
 AST. A concrete type has concrete types for each of the polymorphic arguments. A
 struct, enum or union may have polymorphic arguments but not actually be a
 polymorphic type. This happens when the polymorphic arguments are not used in
 the type definition itself. Similarly for functions/components: but here we just
 check the arguments/return type of the signature.
 Apart from base types and concrete types, we also use the term "embedded type"
 for types that are embedded within another type, such as a type of a struct
 struct field or of a union variant. Embedded types may themselves have
 polymorphic arguments and therefore form an embedded type tree.
 NOTE: for now a polymorphic definition of a function/component is illegal if the
     polymorphic arguments are not used in the arguments/return type. It should
     be legal, but we disallow it for now.
 TODO: Allow potentially cyclic datatypes and reject truly cyclic datatypes.
 TODO: Allow for the full potential of polymorphism
 TODO: Detect "true" polymorphism: for datatypes like structs/enum/unions this
     is simple. For functions we need to check the entire body. Do it here? Or
     do it somewhere else?
 TODO: Do we want to check fn argument collision here, or in validation phase?
 TODO: Make type table an on-demand thing instead of constructing all base types.
 TODO: Cleanup everything, feels like a lot can be written cleaner and with less
     assumptions on each function call.
 // TODO: Review all comments
 */
 use std::fmt::{Formatter, Result as FmtResult};
 use std::collections::{HashMap, VecDeque};
 use crate::protocol::ast::*;
 use crate::protocol::parser::symbol_table::{SymbolTable, Symbol};
 use crate::protocol::inputsource::*;
 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 => "enum",
             TypeClass::Struct => "struct",
             TypeClass::Function => "function",
             TypeClass::Component => "component",
+        }
+    }
     pub(crate) fn is_data_type(&self) -> bool {
         *self == TypeClass::Enum || *self == TypeClass::Union || *self == TypeClass::Struct
+    }
     pub(crate) fn is_proc_type(&self) -> bool {
         *self == TypeClass::Function || *self == TypeClass::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_args: Vec<PolyArg>,
     pub(crate) is_polymorph: bool,
     pub(crate) is_pointerlike: bool,
     pub(crate) monomorphs: Vec<u32>, // TODO: ?
     // TODO: @optimize
     pub(crate) monomorphs: Vec<Vec<ConcreteType>>,
+}
 pub enum DefinedTypeVariant {
     Enum(EnumType),
     Union(UnionType),
     Struct(StructType),
     Function(FunctionType),
     Component(ComponentType)
+}
 pub struct PolyArg {
     identifier: Identifier,
     /// Whether the polymorphic argument is used directly in the definition of
     /// the type (not including bodies of function/component types)
     is_in_use: bool,
+}
 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
+        }
+    }
+}
 /// `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 {
     variants: Vec<EnumVariant>,
     representation: PrimitiveType,
+}
 // TODO: Also support maximum u64 value
 pub struct EnumVariant {
     identifier: Identifier,
     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.
 pub struct UnionType {
     variants: Vec<UnionVariant>,
     tag_representation: PrimitiveType
+}
 pub struct UnionVariant {
     identifier: Identifier,
     parser_type: Option<ParserTypeId>,
     tag_value: i64,
+}
 pub struct StructType {
     fields: Vec<StructField>,
+}
 pub struct StructField {
     identifier: Identifier,
     parser_type: ParserTypeId,
+}
 pub struct FunctionType {
     pub return_type: ParserTypeId,
     pub arguments: Vec<FunctionArgument>
+}
 pub struct ComponentType {
     variant: ComponentVariant,
     arguments: Vec<FunctionArgument>
+}
 pub struct FunctionArgument {
     identifier: Identifier,
     parser_type: ParserTypeId,
+}
 //------------------------------------------------------------------------------
 // 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();
+    }
+}
 #[derive(Copy, Clone)]
 pub(crate) enum ConcreteTypeVariant {
     // No subtypes
     Message,
     Bool,
     Byte,
     Short,
     Int,
     Long,
     String,
     // One subtype
     Array,
     Slice,
     Input,
     Output,
     // Multiple subtypes (definition of thing and number of poly args)
     Instance(DefinitionId, usize)
+}
 pub(crate) struct ConcreteType {
     // serialized version (interpret as serialized depth-first tree, with
     // variant indicating the number of children (subtypes))
     pub(crate) v: Vec<ConcreteTypeVariant>
+}
 /// Result from attempting to resolve a `ParserType` using the symbol table and
 /// the type table.
 enum ResolveResult {
     /// ParserType is a builtin type
     BuiltIn,
     /// ParserType points to a polymorphic argument, contains the index of the
     /// polymorphic argument in the outermost definition (e.g. we may have
     /// structs nested three levels deep, but in the innermost struct we can
     /// only use the polyargs that are specified in the type definition of the
     /// outermost struct).
     PolyArg(usize),
     /// 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))
+}
 pub(crate) 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,
     /// Iterator over `parser type`s during the process where `parser types` are
     /// resolved into a `(module, definition)` tuple.
     parser_type_iter: VecDeque<ParserTypeId>,
+}
 pub(crate) struct TypeCtx<'a> {
     symbols: &'a SymbolTable,
     heap: &'a mut Heap,
     modules: &'a [LexedModule]
+}
 impl<'a> TypeCtx<'a> {
     pub(crate) fn new(symbols: &'a SymbolTable, heap: &'a mut Heap, modules: &'a [LexedModule]) -> Self {
         Self{ symbols, heap, modules }
+    }
+}
 impl TypeTable {
     /// Construct a new type table without any resolved types. Types will be
     /// resolved on-demand.
     pub(crate) fn new(ctx: &mut TypeCtx) -> Result<Self, ParseError2> {
         // Make sure we're allowed to cast root_id to index into ctx.modules
         if cfg!(debug_assertions) {
             for (index, module) in ctx.modules.iter().enumerate() {
                 debug_assert_eq!(index, module.root_id.index as usize);
+            }
+        }
         // Use context to guess hashmap size
         let reserve_size = ctx.heap.definitions.len();
         let mut table = Self{
             lookup: HashMap::with_capacity(reserve_size),
             iter: TypeIterator::new(),
             parser_type_iter: VecDeque::with_capacity(64),
         };
         // TODO: @cleanup Rework this hack
         for root_idx in 0..ctx.modules.len() {
             let last_definition_idx = ctx.heap[ctx.modules[root_idx].root_id].definitions.len();
             for definition_idx in 0..last_definition_idx {
                 let definition_id = ctx.heap[ctx.modules[root_idx].root_id].definitions[definition_idx];
                 table.resolve_base_definition(ctx, definition_id)?;
+            }
+        }
         debug_assert_eq!(table.lookup.len(), reserve_size, "mismatch in reserved size of type table");
         Ok(table)
+    }
     /// 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)
+    }
     /// Instantiates a monomorph for a given base definition.
     pub(crate) fn instantiate_monomorph(&mut self, definition_id: &DefinitionId, monomorph: &Vec<ConcreteType>) {
         debug_assert!(
             self.lookup.contains_key(definition_id),
             "attempting to instantiate monomorph of definition unknown to type table"
         );
         let definition = self.lookup.get_mut(definition_id).unwrap();
         debug_assert_eq!(
             monomorph.len(), definition.poly_args.len(),
             "attempting to instantiate monomorph with {} types, but definition requires {}",
             monomorph.len(), definition.poly_args.len()
         );
         definition.monomorphs.push(monomorph.clone())
+    }
     /// 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, ctx: &mut TypeCtx, definition_id: DefinitionId) -> Result<(), ParseError2> {
         // Check if we have already resolved the base definition
         if self.lookup.contains_key(&definition_id) { return Ok(()); }
         let root_id = Self::find_root_id(ctx, definition_id);
         self.iter.reset(root_id, definition_id);
         while let Some((root_id, definition_id)) = self.iter.top() {
             // We have a type to resolve
             let definition = &ctx.heap[definition_id];
             let can_pop_breadcrumb = match definition {
                 // TODO: @cleanup Borrow rules hax
                 Definition::Enum(_) => self.resolve_base_enum_definition(ctx, root_id, definition_id),
                 Definition::Struct(_) => self.resolve_base_struct_definition(ctx, root_id, definition_id),
                 Definition::Component(_) => self.resolve_base_component_definition(ctx, root_id, definition_id),
                 Definition::Function(_) => self.resolve_base_function_definition(ctx, root_id, definition_id),
             }?;
             // 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();
+            }
+        }
         // We must have resolved the type
         debug_assert!(self.lookup.contains_key(&definition_id), "base type not resolved");
         Ok(())
+    }
     /// 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, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result<bool, ParseError2> {
         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();
         // Check if the enum should be implemented as a classic enumeration or
         // a tagged union. Keep track of variant index for error messages. Make
         // sure all embedded types are resolved.
         let mut first_tag_value = None;
         let mut first_int_value = None;
         for variant in &definition.variants {
             match &variant.value {
                 EnumVariantValue::None => {},
                 EnumVariantValue::Integer(_) => if first_int_value.is_none() {
                     first_int_value = Some(variant.position);
                 },
                 EnumVariantValue::Type(variant_type_id) => {
                     if first_tag_value.is_none() {
                         first_tag_value = Some(variant.position);
+                    }
                     // Check if the embedded type needs to be resolved
                     let resolve_result = self.resolve_base_parser_type(ctx, &definition.poly_vars, root_id, *variant_type_id)?;
                     if !self.ingest_resolve_result(ctx, resolve_result)? {
                         return Ok(false)
+                    }
+                }
+            }
+        }
         if first_tag_value.is_some() && first_int_value.is_some() {
             // Not illegal, but useless and probably a programmer mistake
             let module_source = &ctx.modules[root_id.index as usize].source;
             let tag_pos = first_tag_value.unwrap();
             let int_pos = first_int_value.unwrap();
             return Err(
                 ParseError2::new_error(
                     module_source, definition.position,
                     "Illegal combination of enum integer variant(s) and enum union variant(s)"
+                )
                     .with_postfixed_info(module_source, int_pos, "Assigning an integer value here")
                     .with_postfixed_info(module_source, tag_pos, "Embedding a type in a union variant here")
             );
+        }
         // Enumeration is legal
         if first_tag_value.is_some() {
             // Implement as a tagged union
             // 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 parser_type = match &variant.value {
                     EnumVariantValue::None => {
                         None
                     },
                     EnumVariantValue::Type(parser_type_id) => {
                         // Type should be resolvable, we checked this above
                         Some(*parser_type_id)
                     },
                     EnumVariantValue::Integer(_) => {
                         debug_assert!(false, "Encountered `Integer` variant after asserting enum is a discriminated union");
                         unreachable!();
+                    }
                 };
                 variants.push(UnionVariant{
                     identifier: variant.identifier.clone(),
                     parser_type,
                     tag_value,
                 })
+            }
             // Ensure union names and polymorphic args do not conflict
             self.check_identifier_collision(
                 ctx, root_id, &variants, |variant| &variant.identifier, "enum variant"
             )?;
             self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;
             let mut poly_args = self.create_initial_poly_args(&definition.poly_vars);
             for variant in &variants {
                 if let Some(embedded) = variant.parser_type {
                     self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, embedded)?;
+                }
+            }
             let is_polymorph = poly_args.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,
                     tag_representation: Self::enum_tag_type(-1, tag_value),
                 }),
                 poly_args,
                 is_polymorph,
                 is_pointerlike: false, // TODO: @cyclic_types
                 monomorphs: Vec::new()
             });
         } else {
             // Implement as a regular enum
             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,
                         });
                     },
                     EnumVariantValue::Type(_) => {
                         debug_assert!(false, "Encountered `Type` variant after asserting enum is not a discriminated union");
                         unreachable!();
+                    }
+                }
                 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(
                 ctx, root_id, &variants, |variant| &variant.identifier, "enum variant"
             )?;
             self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;
             // Note: although we cannot have embedded type dependent on the
             // polymorphic variables, they might still be present as tokens
             let definition_id = definition.this.upcast();
             self.lookup.insert(definition_id, DefinedType {
                 ast_root: root_id,
                 ast_definition: definition_id,
                 definition: DefinedTypeVariant::Enum(EnumType{
                     variants,
                     representation: Self::enum_tag_type(min_enum_value, max_enum_value)
                 }),
                 poly_args: self.create_initial_poly_args(&definition.poly_vars),
                 is_polymorph: false,
                 is_pointerlike: false,
                 monomorphs: Vec::new()
             });
+        }
         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, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result<bool, ParseError2> {
         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(ctx, &definition.poly_vars, root_id, field_definition.parser_type)?;
             if !self.ingest_resolve_result(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,
             })
+        }
         // And make sure no conflicts exist in field names and/or polymorphic args
         self.check_identifier_collision(
             ctx, root_id, &fields, |field| &field.identifier, "struct field"
         )?;
         self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;
         // Construct representation of polymorphic arguments
         let mut poly_args = self.create_initial_poly_args(&definition.poly_vars);
         for field in &fields {
             self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, field.parser_type)?;
+        }
         let is_polymorph = poly_args.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,
             }),
             poly_args,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic
             monomorphs: Vec::new(),
         });
         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, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result<bool, ParseError2> {
         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();
         let return_type = definition.return_type;
         // Check the return type
         let resolve_result = self.resolve_base_parser_type(
             ctx, &definition.poly_vars, root_id, definition.return_type
         )?;
         if !self.ingest_resolve_result(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(
                 ctx, &definition.poly_vars, root_id, param.parser_type
             )?;
             if !self.ingest_resolve_result(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,
             })
+        }
         // Check conflict of argument and polyarg identifiers
         self.check_identifier_collision(
             ctx, root_id, &arguments, |arg| &arg.identifier, "function argument"
         )?;
         self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;
         // Construct polymorphic arguments
         let mut poly_args = self.create_initial_poly_args(&definition.poly_vars);
         let return_type_id = definition.return_type;
         self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, return_type_id)?;
         for argument in &arguments {
             self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, argument.parser_type)?;
+        }
         let is_polymorph = poly_args.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_type,
                 arguments,
             }),
             poly_args,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic
             monomorphs: Vec::new(),
         });
         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, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result<bool, ParseError2> {
         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(
                 ctx, &definition.poly_vars, root_id, param.parser_type
             )?;
             if !self.ingest_resolve_result(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
             })
+        }
         // Check conflict of argument and polyarg identifiers
         self.check_identifier_collision(
             ctx, root_id, &arguments, |arg| &arg.identifier, "component argument"
         )?;
         self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;
         // Construct polymorphic arguments
         let mut poly_args = self.create_initial_poly_args(&definition.poly_vars);
         for argument in &arguments {
             self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, argument.parser_type)?;
+        }
         let is_polymorph = poly_args.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,
             }),
             poly_args,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic
             monomorphs: Vec::new(),
         });
         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, ctx: &TypeCtx, result: ResolveResult) -> Result<bool, ParseError2> {
         match result {
             ResolveResult::BuiltIn | ResolveResult::PolyArg(_) => 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 mut error = ParseError2::new_error(
                         &ctx.modules[root_id.index as usize].source, ctx.heap[definition_id].position(),
                         "Evaluating this type definition results in a cyclic type"
                     );
                     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"
                         };
                         error = error.with_postfixed_info(
                             &ctx.modules[root_id.index as usize].source,
                             ctx.heap[*definition_id].position(), 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)
+                }
+            }
+        }
+    }
     /// Each type definition may consist of several embedded subtypes. This
     /// function checks whether that embedded type is a builtin, a direct
     /// reference to a polymorphic argument, or an (un)resolved type definition.
     /// If the embedded type's symbol cannot be found then this function returns
     /// an error.
     ///
     /// If the embedded type is resolved, then one always receives the type's
     /// (module, definition) tuple. If any of the types in the embedded type's
     /// tree is not yet resolved, then one may receive a (module, definition)
     /// tuple that does not correspond to the `parser_type_id` passed into this
     /// function.
     fn resolve_base_parser_type(&mut self, ctx: &TypeCtx, poly_vars: &Vec<Identifier>, root_id: RootId, parser_type_id: ParserTypeId) -> Result<ResolveResult, ParseError2> {
         use ParserTypeVariant as PTV;
         // Prepping iterator
         self.parser_type_iter.clear();
         self.parser_type_iter.push_back(parser_type_id);
         // Result for the very first time we resolve a
         let mut resolve_result = None;
         let mut set_resolve_result = |v: ResolveResult| {
             if resolve_result.is_none() { resolve_result = Some(v); }
         };
         'resolve_loop: while let Some(parser_type_id) = self.parser_type_iter.pop_back() {
             let parser_type = &ctx.heap[parser_type_id];
             match &parser_type.variant {
                 // Builtin types. An array is a builtin as it is implemented as a
                 // couple of pointers, so we do not require the subtype to be fully
                 // resolved. Similar for input/output ports.
                 PTV::Array(_) | PTV::Input(_) | PTV::Output(_) | PTV::Message |
                 PTV::Bool | PTV::Byte | PTV::Short | PTV::Int | PTV::Long |
                 PTV::String => {
                     set_resolve_result(ResolveResult::BuiltIn);
                 },
                 // IntegerLiteral types and the inferred marker are not allowed in
                 // definitions of types
                 PTV::IntegerLiteral |
                 PTV::Inferred => {
                     debug_assert!(false, "Encountered illegal ParserTypeVariant within type definition");
                     unreachable!();
                 },
                 // Symbolic type, make sure its base type, and the base types
                 // of all members of the embedded type tree are resolved. We
                 // don't care about monomorphs yet.
                 PTV::Symbolic(symbolic) => {
                     // Check if the symbolic type is one of the definition's
                     // polymorphic arguments. If so then we can halt the
                     // execution
                     for (poly_arg_idx, poly_arg) in poly_vars.iter().enumerate() {
                         if poly_arg.value == symbolic.identifier.value {
                             set_resolve_result(ResolveResult::PolyArg(poly_arg_idx));
                             continue 'resolve_loop;
+                        }
+                    }
                     // Lookup the definition in the symbol table
                     let symbol = ctx.symbols.resolve_namespaced_symbol(root_id, &symbolic.identifier);
                     if symbol.is_none() {
                         return Err(ParseError2::new_error(
                             &ctx.modules[root_id.index as usize].source, symbolic.identifier.position,
                             "Could not resolve type"
                         ))
+                    }
                     let (symbol_value, mut ident_iter) = symbol.unwrap();
                     match symbol_value.symbol {
                         Symbol::Namespace(_) => {
                             // Reference to a namespace instead of a type
                             return if ident_iter.num_remaining() == 0 {
                                 Err(ParseError2::new_error(
                                     &ctx.modules[root_id.index as usize].source, symbolic.identifier.position,
                                     "Expected a type, got a module name"
                                 ))
                             } else {
                                 let next_identifier = ident_iter.next().unwrap();
                                 Err(ParseError2::new_error(
                                     &ctx.modules[root_id.index as usize].source, symbolic.identifier.position,
                                     &format!("Could not find symbol '{}' with this module", String::from_utf8_lossy(next_identifier))
                                 ))
+                            }
                         },
                         Symbol::Definition((root_id, definition_id)) => {
                             let definition = &ctx.heap[definition_id];
                             if ident_iter.num_remaining() > 0 {
                                 // Namespaced identifier is longer than the type
                                 // we found. Return the appropriate message
                                 return if definition.is_struct() || definition.is_enum() {
                                     Err(ParseError2::new_error(
                                         &ctx.modules[root_id.index as usize].source, symbolic.identifier.position,
                                         &format!(
                                             "Unknown type '{}', did you mean to use '{}'?",
                                             String::from_utf8_lossy(&symbolic.identifier.value),
                                             String::from_utf8_lossy(&definition.identifier().value)
+                                        )
                                     ))
                                 } else {
                                     Err(ParseError2::new_error(
                                         &ctx.modules[root_id.index as usize].source, symbolic.identifier.position,
                                         "Unknown type"
                                     ))
+                                }
+                            }
                             // Found a match, make sure it is a datatype
                             if !(definition.is_struct() || definition.is_enum()) {
                                 return Err(ParseError2::new_error(
                                     &ctx.modules[root_id.index as usize].source, symbolic.identifier.position,
                                     "Embedded types must be datatypes (structs or enums)"
                                 ))
+                            }
                             // Found a struct/enum definition
                             if !self.lookup.contains_key(&definition_id) {
                                 // Type is not yet resoled, immediately return
                                 // this
                                 return Ok(ResolveResult::Unresolved((root_id, definition_id)));
+                            }
                             // Type is resolved, so set as result, but continue
                             // iterating over the parser types in the embedded
                             // type's tree
                             set_resolve_result(ResolveResult::Resolved((root_id, definition_id)));
                             // Note: because we're resolving parser types, not
                             // embedded types, we're parsing a tree, so we can't
                             // get stuck in a cyclic loop.
                             for poly_arg_type_id in &symbolic.poly_args {
                                 self.parser_type_iter.push_back(*poly_arg_type_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())
+    }
     fn create_initial_poly_args(&self, poly_args: &[Identifier]) -> Vec<PolyArg> {
         poly_args
             .iter()
             .map(|v| PolyArg{ identifier: v.clone(), is_in_use: false })
             .collect()
+    }
     /// This function modifies the passed `poly_args` by checking the embedded
     /// type tree. This should be called after `resolve_base_parser_type` is
     /// called on each node in this tree: we assume that each symbolic type was
     /// resolved to either a polymorphic arg or a definition.
     ///
     /// This function will also make sure that if the embedded type has
     /// polymorphic variables itself, that the number of polymorphic variables
     /// matches the number of arguments in the associated definition.
     ///
     /// Finally, for all embedded types (which includes function/component
     /// arguments and return types) in type definitions we will modify the AST
     /// when the embedded type is a polymorphic variable or points to another
     /// user-defined type.
     fn check_and_resolve_embedded_type_and_modify_poly_args(
         &mut self, ctx: &mut TypeCtx,
         type_definition_id: DefinitionId, poly_args: &mut [PolyArg],
         root_id: RootId, embedded_type_id: ParserTypeId,
     ) -> Result<(), ParseError2> {
         use ParserTypeVariant as PTV;
         self.parser_type_iter.clear();
         self.parser_type_iter.push_back(embedded_type_id);
         'type_loop: while let Some(embedded_type_id) = self.parser_type_iter.pop_back() {
             let embedded_type = &mut ctx.heap[embedded_type_id];
             match &mut embedded_type.variant {
                 PTV::Message | PTV::Bool |
                 PTV::Byte | PTV::Short | PTV::Int | PTV::Long |
                 PTV::String => {
                     // Builtins, no modification/iteration required
                 },
                 PTV::IntegerLiteral | PTV::Inferred => {
                     // TODO: @hack Allowed for now so we can continue testing
                     //  the parser/lexer
                     // debug_assert!(false, "encountered illegal parser type during ParserType/PolyArg modification");
                     // unreachable!();
                 },
                 PTV::Array(subtype_id) |
                 PTV::Input(subtype_id) |
                 PTV::Output(subtype_id) => {
                     // Outer type is fixed, but inner type might be symbolix
                     self.parser_type_iter.push_back(*subtype_id);
                 },
                 PTV::Symbolic(symbolic) => {
                     for (poly_arg_idx, poly_arg) in poly_args.iter_mut().enumerate() {
                         if poly_arg.identifier.value == symbolic.identifier.value {
                             poly_arg.is_in_use = true;
                             // TODO: If we allow higher-kinded types in the future,
                             //  then we can't continue here, but must resolve the
                             //  polyargs as well
                             debug_assert!(symbolic.poly_args.is_empty(), "got polymorphic arguments to a polymorphic variable");
                             debug_assert!(symbolic.variant.is_none(), "symbolic parser type's variant already resolved");
                             symbolic.variant = Some(SymbolicParserTypeVariant::PolyArg(type_definition_id, poly_arg_idx));
                             continue 'type_loop;
+                        }
+                    }
                     // Must match a definition
                     let symbol = ctx.symbols.resolve_namespaced_symbol(root_id, &symbolic.identifier);
                     debug_assert!(symbol.is_some(), "could not resolve symbolic parser type when determining poly args");
                     let (symbol, ident_iter) = symbol.unwrap();
                     debug_assert_eq!(ident_iter.num_remaining(), 0, "no exact symbol match when determining poly args");
                     let (_root_id, definition_id) = symbol.as_definition().unwrap();
                     // Must be a struct, enum, or union
                     let defined_type = self.lookup.get(&definition_id).unwrap();
                     if cfg!(debug_assertions) {
                         let type_class = defined_type.definition.type_class();
                         debug_assert!(
                             type_class == TypeClass::Struct || type_class == TypeClass::Enum || type_class == TypeClass::Union,
                             "embedded type's class is not struct, enum or union"
                         );
+                    }
                     if symbolic.poly_args.len() != defined_type.poly_args.len() {
                         // Mismatch in number of polymorphic arguments. This is
                         // not allowed in type definitions (no inference is
                         // allowed within type definitions, only in bodies of
                         // functions/components).
                         let module_source = &ctx.modules[root_id.index as usize].source;
                         let number_args_msg = if defined_type.poly_args.is_empty() {
                             String::from("is not polymorphic")
                         } else {
                             format!("accepts {} polymorphic arguments", defined_type.poly_args.len())
                         };
                         return Err(ParseError2::new_error(
                             module_source, symbolic.identifier.position,
                             &format!(
                                 "The type '{}' {}, but {} polymorphic arguments were provided",
                                 String::from_utf8_lossy(&symbolic.identifier.value),
                                 number_args_msg, symbolic.poly_args.len()
+                            )
                         ));
+                    }
                     self.parser_type_iter.extend(&symbolic.poly_args);
                     debug_assert!(symbolic.variant.is_none(), "symbolic parser type's variant already resolved");
                     symbolic.variant = Some(SymbolicParserTypeVariant::Definition(definition_id));
+                }
+            }
+        }
         // All nodes in the embedded type tree were valid
         Ok(())
+    }
     /// Go through a list of identifiers and ensure that all identifiers have
     /// unique names
     fn check_identifier_collision<T: Sized, F: Fn(&T) -> &Identifier>(
         &self, ctx: &TypeCtx, root_id: RootId, items: &[T], getter: F, item_name: &'static str
     ) -> Result<(), ParseError2> {
         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.value == other_item_ident.value {
                     let module_source = &ctx.modules[root_id.index as usize].source;
                     return Err(ParseError2::new_error(
                         module_source, item_ident.position, &format!("This {} is defined more than once", item_name)
                     ).with_postfixed_info(
                         module_source, other_item_ident.position, &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, ctx: &TypeCtx, root_id: RootId, poly_args: &[Identifier]
     ) -> Result<(), ParseError2> {
         // 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.value == other_poly_arg.value {
                     let module_source = &ctx.modules[root_id.index as usize].source;
                     return Err(ParseError2::new_error(
                         module_source, poly_arg.position,
                         "This polymorphic argument is defined more than once"
                     ).with_postfixed_info(
                         module_source, other_poly_arg.position,
                         "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.resolve_symbol(root_id, &poly_arg.value) {
                 // We have a conflict
                 let module_source = &ctx.modules[root_id.index as usize].source;
                 return Err(ParseError2::new_error(
                     module_source, poly_arg.position,
                     "This polymorphic argument conflicts with another symbol"
                 ).with_postfixed_info(
                     module_source, symbol.position,
                     "It conflicts due to this symbol"
                 ));
+            }
+        }
         // All arguments are fine
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Small utilities
     //--------------------------------------------------------------------------
     fn enum_tag_type(min_tag_value: i64, max_tag_value: i64) -> PrimitiveType {
         // TODO: @consistency tag values should be handled correctly
         debug_assert!(min_tag_value < max_tag_value);
         let abs_max_value = min_tag_value.abs().max(max_tag_value.abs());
         if abs_max_value <= u8::max_value() as i64 {
             PrimitiveType::Byte
         } else if abs_max_value <= u16::max_value() as i64 {
             PrimitiveType::Short
         } else if abs_max_value <= u32::max_value() as i64 {
             PrimitiveType::Int
         } else {
             PrimitiveType::Long
+        }
+    }
     fn find_root_id(ctx: &TypeCtx, definition_id: DefinitionId) -> RootId {
         // TODO: Keep in lookup or something
         for module in ctx.modules {
             let root_id = module.root_id;
             let root = &ctx.heap[root_id];
             for module_definition_id in root.definitions.iter() {
                 if *module_definition_id == definition_id {
                     return root_id
+                }
+            }
+        }
         debug_assert!(false, "DefinitionId without corresponding RootId");
         unreachable!();
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/visitor_linker.rs

➞

Show inline comments

 use crate::protocol::ast::*;
 use crate::protocol::inputsource::*;
 use crate::protocol::parser::{
     symbol_table::*,
     type_table::*,
     utils::*,
 };
 use super::visitor::{
     STMT_BUFFER_INIT_CAPACITY,
     EXPR_BUFFER_INIT_CAPACITY,
     TYPE_BUFFER_INIT_CAPACITY,
     Ctx,
     Visitor2,
     VisitorResult
 };
 #[derive(PartialEq, Eq)]
 enum DefinitionType {
     None,
     Primitive(ComponentId),
     Composite(ComponentId),
     Function(FunctionId)
+}
 impl DefinitionType {
     fn is_primitive(&self) -> bool { if let Self::Primitive(_) = self { true } else { false } }
     fn is_composite(&self) -> bool { if let Self::Composite(_) = self { true } else { false } }
     fn is_function(&self) -> bool { if let Self::Function(_) = self { true } else { false } }
+}
 /// This particular visitor will go through the entire AST in a recursive manner
 /// and check if all statements and expressions are legal (e.g. no "return"
 /// statements in component definitions), and will link certain AST nodes to
 /// their appropriate targets (e.g. goto statements, or function calls).
 ///
 /// This visitor will not perform control-flow analysis (e.g. making sure that
 /// each function actually returns) and will also not perform type checking. So
 /// the linking of function calls and component instantiations will be checked
 /// and linked to the appropriate definitions, but the return types and/or
 /// arguments will not be checked for validity.
 ///
 /// The visitor visits each statement in a block in a breadth-first manner
 /// first. We are thereby sure that we have found all variables/labels in a
 /// particular block. In this phase nodes may queue statements for insertion
 /// (e.g. the insertion of an `EndIf` statement for a particular `If`
 /// statement). These will be inserted after visiting every node, after which
 /// the visitor recurses into each statement in a block.
 ///
 /// Because of this scheme expressions will not be visited in the breadth-first
 /// pass.
 pub(crate) struct ValidityAndLinkerVisitor {
     /// `in_sync` is `Some(id)` if the visitor is visiting the children of a
     /// synchronous statement. A single value is sufficient as nested
     /// synchronous statements are not allowed
     in_sync: Option<SynchronousStatementId>,
     /// `in_while` contains the last encountered `While` statement. This is used
     /// to resolve unlabeled `Continue`/`Break` statements.
     in_while: Option<WhileStatementId>,
     // Traversal state: current scope (which can be used to find the parent
     // scope), the definition variant we are considering, and whether the
     // visitor is performing breadthwise block statement traversal.
     cur_scope: Option<Scope>,
     def_type: DefinitionType,
     performing_breadth_pass: bool,
     // Parent expression (the previous stmt/expression we visited that could be
     // used as an expression parent)
     expr_parent: ExpressionParent,
     // Keeping track of relative position in block in the breadth-first pass.
     // May not correspond to block.statement[index] if any statements are
     // inserted after the breadth-pass
     relative_pos_in_block: u32,
     // Single buffer of statement IDs that we want to traverse in a block.
     // Required to work around Rust borrowing rules and to prevent constant
     // cloning of vectors.
     statement_buffer: Vec<StatementId>,
     // Another buffer, now with expression IDs, to prevent constant cloning of
     // vectors while working around rust's borrowing rules
     expression_buffer: Vec<ExpressionId>,
     // Yet another buffer, now with parser type IDs, similar to above
     parser_type_buffer: Vec<ParserTypeId>,
     // Statements to insert after the breadth pass in a single block
     insert_buffer: Vec<(u32, StatementId)>,
+}
 impl ValidityAndLinkerVisitor {
     pub(crate) fn new() -> Self {
         Self{
             in_sync: None,
             in_while: None,
             cur_scope: None,
             expr_parent: ExpressionParent::None,
             def_type: DefinitionType::None,
             performing_breadth_pass: false,
             relative_pos_in_block: 0,
             statement_buffer: Vec::with_capacity(STMT_BUFFER_INIT_CAPACITY),
             expression_buffer: Vec::with_capacity(EXPR_BUFFER_INIT_CAPACITY),
             parser_type_buffer: Vec::with_capacity(TYPE_BUFFER_INIT_CAPACITY),
             insert_buffer: Vec::with_capacity(32),
+        }
+    }
     fn reset_state(&mut self) {
         self.in_sync = None;
         self.in_while = None;
         self.cur_scope = None;
         self.expr_parent = ExpressionParent::None;
         self.def_type = DefinitionType::None;
         self.relative_pos_in_block = 0;
         self.performing_breadth_pass = false;
         self.statement_buffer.clear();
         self.expression_buffer.clear();
         self.parser_type_buffer.clear();
         self.insert_buffer.clear();
+    }
     /// Debug call to ensure that we didn't make any mistakes in any of the
     /// employed buffers
     fn check_post_definition_state(&self) {
         debug_assert!(self.statement_buffer.is_empty());
         debug_assert!(self.expression_buffer.is_empty());
         debug_assert!(self.parser_type_buffer.is_empty());
         debug_assert!(self.insert_buffer.is_empty());
+    }
+}
 impl Visitor2 for ValidityAndLinkerVisitor {
     //--------------------------------------------------------------------------
     // Definition visitors
     //--------------------------------------------------------------------------
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentId) -> VisitorResult {
         self.reset_state();
         self.def_type = match &ctx.heap[id].variant {
             ComponentVariant::Primitive => DefinitionType::Primitive(id),
             ComponentVariant::Composite => DefinitionType::Composite(id),
         };
         self.cur_scope = Some(Scope::Definition(id.upcast()));
         self.expr_parent = ExpressionParent::None;
         // Visit types of parameters
         debug_assert!(self.parser_type_buffer.is_empty());
         let comp_def = &ctx.heap[id];
         self.parser_type_buffer.extend(
             comp_def.parameters
                 .iter()
                 .map(|id| ctx.heap[*id].parser_type)
         );
         let num_types = self.parser_type_buffer.len();
         for idx in 0..num_types {
             self.visit_parser_type(ctx, self.parser_type_buffer[idx])?;
+        }
         self.parser_type_buffer.clear();
         // Visit statements in component body
         let body_id = ctx.heap[id].body;
         self.performing_breadth_pass = true;
         self.visit_stmt(ctx, body_id)?;
         self.performing_breadth_pass = false;
         self.visit_stmt(ctx, body_id)?;
         self.check_post_definition_state();
         Ok(())
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionId) -> VisitorResult {
         self.reset_state();
         // Set internal statement indices
         self.def_type = DefinitionType::Function(id);
         self.cur_scope = Some(Scope::Definition(id.upcast()));
         self.expr_parent = ExpressionParent::None;
         // Visit types of parameters
         debug_assert!(self.parser_type_buffer.is_empty());
         let func_def = &ctx.heap[id];
         self.parser_type_buffer.extend(
             func_def.parameters
                 .iter()
                 .map(|id| ctx.heap[*id].parser_type)
         );
         self.parser_type_buffer.push(func_def.return_type);
         let num_types = self.parser_type_buffer.len();
         for idx in 0..num_types {
             self.visit_parser_type(ctx, self.parser_type_buffer[idx])?;
+        }
         self.parser_type_buffer.clear();
         // Visit statements in function body
         let body_id = ctx.heap[id].body;
         self.performing_breadth_pass = true;
         self.visit_stmt(ctx, body_id)?;
         self.performing_breadth_pass = false;
         self.visit_stmt(ctx, body_id)?;
         self.check_post_definition_state();
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Statement visitors
     //--------------------------------------------------------------------------
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         self.visit_block_stmt_with_hint(ctx, id, None)
+    }
     fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let variable_id = ctx.heap[id].variable;
             self.checked_local_add(ctx, self.relative_pos_in_block, variable_id)?;
         } else {
             let variable_id = ctx.heap[id].variable;
             let parser_type_id = ctx.heap[variable_id].parser_type;
             self.visit_parser_type(ctx, parser_type_id);
+            self.visit_parser_type(ctx, parser_type_id)?;
             debug_assert_eq!(self.expr_parent, ExpressionParent::None);
             self.expr_parent = ExpressionParent::Memory(id);
             self.visit_expr(ctx, ctx.heap[id].initial)?;
             self.expr_parent = ExpressionParent::None;
+        }
         Ok(())
+    }
     fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let (from_id, to_id) = {
                 let stmt = &ctx.heap[id];
                 (stmt.from, stmt.to)
             };
             self.checked_local_add(ctx, self.relative_pos_in_block, from_id)?;
             self.checked_local_add(ctx, self.relative_pos_in_block, to_id)?;
         } else {
             let chan_stmt = &ctx.heap[id];
             let from_type_id = ctx.heap[chan_stmt.from].parser_type;
             let to_type_id = ctx.heap[chan_stmt.to].parser_type;
             self.visit_parser_type(ctx, from_type_id)?;
             self.visit_parser_type(ctx, to_type_id)?;
+        }
         Ok(())
+    }
     fn visit_labeled_stmt(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             // Add label to block lookup
             self.checked_label_add(ctx, id)?;
             // Modify labeled statement itself
             let labeled = &mut ctx.heap[id];
             labeled.relative_pos_in_block = self.relative_pos_in_block;
             labeled.in_sync = self.in_sync.clone();
+        }
         let body_id = ctx.heap[id].body;
         self.visit_stmt(ctx, body_id)?;
         Ok(())
+    }
     fn visit_if_stmt(&mut self, ctx: &mut Ctx, id: IfStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let position = ctx.heap[id].position;
             let end_if_id = ctx.heap.alloc_end_if_statement(|this| {
                 EndIfStatement {
                     this,
                     start_if: id,
                     position,
                     next: None,
+                }
             });
             let stmt = &mut ctx.heap[id];
             stmt.end_if = Some(end_if_id);
             self.insert_buffer.push((self.relative_pos_in_block + 1, end_if_id.upcast()));
         } else {
             // Traverse expression and bodies
             let (test_id, true_id, false_id) = {
                 let stmt = &ctx.heap[id];
                 (stmt.test, stmt.true_body, stmt.false_body)
             };
             debug_assert_eq!(self.expr_parent, ExpressionParent::None);
             self.expr_parent = ExpressionParent::If(id);
             self.visit_expr(ctx, test_id)?;
             self.expr_parent = ExpressionParent::None;
             self.visit_stmt(ctx, true_id)?;
             self.visit_stmt(ctx, false_id)?;
+        }
         Ok(())
+    }
     fn visit_while_stmt(&mut self, ctx: &mut Ctx, id: WhileStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let position = ctx.heap[id].position;
             let end_while_id = ctx.heap.alloc_end_while_statement(|this| {
                 EndWhileStatement {
                     this,
                     start_while: id,
                     position,
                     next: None,
+                }
             });
             let stmt = &mut ctx.heap[id];
             stmt.end_while = Some(end_while_id);
             stmt.in_sync = self.in_sync.clone();
             self.insert_buffer.push((self.relative_pos_in_block + 1, end_while_id.upcast()));
         } else {
             let (test_id, body_id) = {
                 let stmt = &ctx.heap[id];
                 (stmt.test, stmt.body)
             };
             let old_while = self.in_while.replace(id);
             debug_assert_eq!(self.expr_parent, ExpressionParent::None);
             self.expr_parent = ExpressionParent::While(id);
             self.visit_expr(ctx, test_id)?;
             self.expr_parent = ExpressionParent::None;
             self.visit_stmt(ctx, body_id)?;
             self.in_while = old_while;
+        }
         Ok(())
+    }
     fn visit_break_stmt(&mut self, ctx: &mut Ctx, id: BreakStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             // Should be able to resolve break statements with a label in the
             // breadth pass, no need to do after resolving all labels
             let target_end_while = {
                 let stmt = &ctx.heap[id];
                 let target_while_id = self.resolve_break_or_continue_target(ctx, stmt.position, &stmt.label)?;
                 let target_while = &ctx.heap[target_while_id];
                 debug_assert!(target_while.end_while.is_some());
                 target_while.end_while.unwrap()
             };
             let stmt = &mut ctx.heap[id];
             stmt.target = Some(target_end_while);
+        }
         Ok(())
+    }
     fn visit_continue_stmt(&mut self, ctx: &mut Ctx, id: ContinueStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let target_while_id = {
                 let stmt = &ctx.heap[id];
                 self.resolve_break_or_continue_target(ctx, stmt.position, &stmt.label)?
             };
             let stmt = &mut ctx.heap[id];
             stmt.target = Some(target_while_id)
+        }
         Ok(())
+    }
     fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             // Check for validity of synchronous statement
             let cur_sync_position = ctx.heap[id].position;
             if self.in_sync.is_some() {
                 // Nested synchronous statement
                 let old_sync = &ctx.heap[self.in_sync.unwrap()];
                 return Err(
                     ParseError2::new_error(&ctx.module.source, cur_sync_position, "Illegal nested synchronous statement")
                         .with_postfixed_info(&ctx.module.source, old_sync.position, "It is nested in this synchronous statement")
                 );
+            }
             if !self.def_type.is_primitive() {
                 return Err(ParseError2::new_error(
                     &ctx.module.source, cur_sync_position,
                     "Synchronous statements may only be used in primitive components"
                 ));
+            }
             // Append SynchronousEnd pseudo-statement
             let sync_end_id = ctx.heap.alloc_end_synchronous_statement(|this| EndSynchronousStatement{
                 this,
                 position: cur_sync_position,
                 start_sync: id,
                 next: None,
             });
             let sync_start = &mut ctx.heap[id];
             sync_start.end_sync = Some(sync_end_id);
             self.insert_buffer.push((self.relative_pos_in_block + 1, sync_end_id.upcast()));
         } else {
             let sync_body = ctx.heap[id].body;
             let old = self.in_sync.replace(id);
             self.visit_stmt_with_hint(ctx, sync_body, Some(id))?;
             self.in_sync = old;
+        }
         Ok(())
+    }
     fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let stmt = &ctx.heap[id];
             if !self.def_type.is_function() {
                 return Err(
                     ParseError2::new_error(&ctx.module.source, stmt.position, "Return statements may only appear in function bodies")
                 );
+            }
         } else {
             // If here then we are within a function
             debug_assert_eq!(self.expr_parent, ExpressionParent::None);
             self.expr_parent = ExpressionParent::Return(id);
             self.visit_expr(ctx, ctx.heap[id].expression)?;
             self.expr_parent = ExpressionParent::None;
+        }
         Ok(())
+    }
     fn visit_assert_stmt(&mut self, ctx: &mut Ctx, id: AssertStatementId) -> VisitorResult {
         let stmt = &ctx.heap[id];
         if self.performing_breadth_pass {
             if self.def_type.is_function() {
                 // TODO: We probably want to allow this. Mark the function as
                 //  using asserts, and then only allow calls to these functions
                 //  within components. Such a marker will cascade through any
                 //  functions that then call an asserting function
                 return Err(
                     ParseError2::new_error(&ctx.module.source, stmt.position, "Illegal assert statement in a function")
                 );
+            }
             // We are in a component of some sort, but we also need to be within a
             // synchronous statement
             if self.in_sync.is_none() {
                 return Err(
                     ParseError2::new_error(&ctx.module.source, stmt.position, "Illegal assert statement outside of a synchronous block")
                 );
+            }
         } else {
             debug_assert_eq!(self.expr_parent, ExpressionParent::None);
             let expr_id = stmt.expression;
             self.expr_parent = ExpressionParent::Assert(id);
             self.visit_expr(ctx, expr_id)?;
             self.expr_parent = ExpressionParent::None;
+        }
         Ok(())
+    }
     fn visit_goto_stmt(&mut self, ctx: &mut Ctx, id: GotoStatementId) -> VisitorResult {
         if !self.performing_breadth_pass {
             // Must perform goto label resolving after the breadth pass, this
             // way we are able to find all the labels in current and outer
             // scopes.
             let target_id = self.find_label(ctx, &ctx.heap[id].label)?;
             ctx.heap[id].target = Some(target_id);
             let target = &ctx.heap[target_id];
             if self.in_sync != target.in_sync {
                 // We can only goto the current scope or outer scopes. Because
                 // nested sync statements are not allowed so if the value does
                 // not match, then we must be inside a sync scope
                 debug_assert!(self.in_sync.is_some());
                 let goto_stmt = &ctx.heap[id];
                 let sync_stmt = &ctx.heap[self.in_sync.unwrap()];
                 return Err(
                     ParseError2::new_error(&ctx.module.source, goto_stmt.position, "Goto may not escape the surrounding synchronous block")
                         .with_postfixed_info(&ctx.module.source, target.position, "This is the target of the goto statement")
                         .with_postfixed_info(&ctx.module.source, sync_stmt.position, "Which will jump past this statement")
                 );
+            }
+        }
         Ok(())
+    }
     fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {
         // Link the call expression following the new statement
         if self.performing_breadth_pass {
             // TODO: Cleanup error messages, can be done cleaner
             // Make sure new statement occurs within a composite component
             let call_expr_id = ctx.heap[id].expression;
             if !self.def_type.is_composite() {
                 let new_stmt = &ctx.heap[id];
                 return Err(
                     ParseError2::new_error(&ctx.module.source, new_stmt.position, "Instantiating components may only be done in composite components")
                 );
+            }
             // No fancy recursive parsing, must be followed by a call expression
             let definition_id = {
                 let call_expr = &ctx.heap[call_expr_id];
                 if let Method::Symbolic(symbolic) = &call_expr.method {
                     let found_symbol = self.find_symbol_of_type(
                         ctx.module.root_id, &ctx.symbols, &ctx.types,
                         &symbolic.identifier, TypeClass::Component
                     );
                     match found_symbol {
                         FindOfTypeResult::Found(definition_id) => definition_id,
                         FindOfTypeResult::TypeMismatch(got_type_class) => {
                             return Err(ParseError2::new_error(
                                 &ctx.module.source, symbolic.identifier.position,
                                 &format!("New must instantiate a component, this identifier points to a {}", got_type_class)
                             ))
                         },
                         FindOfTypeResult::NotFound => {
                             return Err(ParseError2::new_error(
                                 &ctx.module.source, symbolic.identifier.position,
                                 "Could not find a defined component with this name"
                             ))
+                        }
+                    }
                 } else {
                     return Err(
                         ParseError2::new_error(&ctx.module.source, call_expr.position, "Must instantiate a component")
                     );
+                }
             };
             // Modify new statement's symbolic call to point to the appropriate
             // definition.
             let call_expr = &mut ctx.heap[call_expr_id];
             match &mut call_expr.method {
                 Method::Symbolic(method) => method.definition = Some(definition_id),
                 _ => unreachable!()
+            }
         } else {
             // Performing depth pass. The function definition should have been
             // resolved in the breadth pass, now we recurse to evaluate the
             // arguments
             // TODO: @cleanup Maybe just call `visit_call_expr`?
             let call_expr_id = ctx.heap[id].expression;
             let call_expr = &mut ctx.heap[call_expr_id];
             call_expr.parent = ExpressionParent::New(id);
             let old_num_exprs = self.expression_buffer.len();
             self.expression_buffer.extend(&call_expr.arguments);
             let new_num_exprs = self.expression_buffer.len();
             let old_expr_parent = self.expr_parent;
             for arg_expr_idx in old_num_exprs..new_num_exprs {
                 let arg_expr_id = self.expression_buffer[arg_expr_idx];
                 self.expr_parent = ExpressionParent::Expression(call_expr_id.upcast(), arg_expr_idx as u32);
                 self.visit_expr(ctx, arg_expr_id)?;
+            }
             self.expression_buffer.truncate(old_num_exprs);
             self.expr_parent = old_expr_parent;
+        }
         Ok(())
+    }
     fn visit_expr_stmt(&mut self, ctx: &mut Ctx, id: ExpressionStatementId) -> VisitorResult {
         if !self.performing_breadth_pass {
             let expr_id = ctx.heap[id].expression;
             debug_assert_eq!(self.expr_parent, ExpressionParent::None);
             self.expr_parent = ExpressionParent::ExpressionStmt(id);
             self.visit_expr(ctx, expr_id)?;
             self.expr_parent = ExpressionParent::None;
+        }
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Expression visitors
     //--------------------------------------------------------------------------
     fn visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let upcast_id = id.upcast();
         let assignment_expr = &mut ctx.heap[id];
         let left_expr_id = assignment_expr.left;
         let right_expr_id = assignment_expr.right;
         let old_expr_parent = self.expr_parent;
         assignment_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, left_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, right_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let upcast_id = id.upcast();
         let conditional_expr = &mut ctx.heap[id];
         let test_expr_id = conditional_expr.test;
         let true_expr_id = conditional_expr.true_expression;
         let false_expr_id = conditional_expr.false_expression;
         let old_expr_parent = self.expr_parent;
         conditional_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, test_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, true_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 2);
         self.visit_expr(ctx, false_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let upcast_id = id.upcast();
         let binary_expr = &mut ctx.heap[id];
         let left_expr_id = binary_expr.left;
         let right_expr_id = binary_expr.right;
         let old_expr_parent = self.expr_parent;
         binary_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, left_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, right_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let unary_expr = &mut ctx.heap[id];
         let expr_id = unary_expr.expression;
         let old_expr_parent = self.expr_parent;
         unary_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(id.upcast(), 0);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let upcast_id = id.upcast();
         let indexing_expr = &mut ctx.heap[id];
         let subject_expr_id = indexing_expr.subject;
         let index_expr_id = indexing_expr.index;
         let old_expr_parent = self.expr_parent;
         indexing_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, subject_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, index_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let upcast_id = id.upcast();
         let slicing_expr = &mut ctx.heap[id];
         let subject_expr_id = slicing_expr.subject;
         let from_expr_id = slicing_expr.from_index;
         let to_expr_id = slicing_expr.to_index;
         let old_expr_parent = self.expr_parent;
         slicing_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, subject_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, from_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 2);
         self.visit_expr(ctx, to_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let select_expr = &mut ctx.heap[id];
         let expr_id = select_expr.subject;
         let old_expr_parent = self.expr_parent;
         select_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(id.upcast(), 0);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_array_expr(&mut self, ctx: &mut Ctx, id: ArrayExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let upcast_id = id.upcast();
         let array_expr = &mut ctx.heap[id];
         let old_num_exprs = self.expression_buffer.len();
         self.expression_buffer.extend(&array_expr.elements);
         let new_num_exprs = self.expression_buffer.len();
         let old_expr_parent = self.expr_parent;
         array_expr.parent = old_expr_parent;
         for field_expr_idx in old_num_exprs..new_num_exprs {
             let field_expr_id = self.expression_buffer[field_expr_idx];
             self.expr_parent = ExpressionParent::Expression(upcast_id, field_expr_idx as u32);
             self.visit_expr(ctx, field_expr_id)?;
+        }
         self.expression_buffer.truncate(old_num_exprs);
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_constant_expr(&mut self, ctx: &mut Ctx, id: ConstantExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let constant_expr = &mut ctx.heap[id];
         constant_expr.parent = self.expr_parent;
         Ok(())
+    }
     fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let call_expr = &mut ctx.heap[id];
         let num_expr_args = call_expr.arguments.len();
         // Resolve the method to the appropriate definition and check the
         // legality of the particular method call.
         // TODO: @cleanup Unify in some kind of signature call, see similar
         //  cleanup comments with this `match` format.
         let num_definition_args;
         match &mut call_expr.method {
             Method::Create => {
                 num_definition_args = 1;
             },
             Method::Fires => {
                 if !self.def_type.is_primitive() {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'fires' may only occur in primitive component definitions"
                     ));
+                }
                 if self.in_sync.is_none() {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'fires' may only occur inside synchronous blocks"
                     ));
+                }
                 num_definition_args = 1;
             },
             Method::Get => {
                 if !self.def_type.is_primitive() {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'get' may only occur in primitive component definitions"
                     ));
+                }
                 if self.in_sync.is_none() {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'get' may only occur inside synchronous blocks"
                     ));
+                }
                 num_definition_args = 1;
             },
             Method::Put => {
                 if !self.def_type.is_primitive() {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'put' may only occur in primitive component definitions"
                     ));
+                }
                 if self.in_sync.is_none() {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'put' may only occur inside synchronous blocks"
                     ));
+                }
                 num_definition_args = 2;
+            }
             Method::Symbolic(symbolic) => {
                 // Find symbolic method
                 let found_symbol = self.find_symbol_of_type(
                     ctx.module.root_id, &ctx.symbols, &ctx.types,
                     &symbolic.identifier, TypeClass::Function
                 );
                 let definition_id = match found_symbol {
                     FindOfTypeResult::Found(definition_id) => definition_id,
                     FindOfTypeResult::TypeMismatch(got_type_class) => {
                         return Err(ParseError2::new_error(
                             &ctx.module.source, symbolic.identifier.position,
                             &format!("Only functions can be called, this identifier points to a {}", got_type_class)
                         ))
                     },
                     FindOfTypeResult::NotFound => {
                         return Err(ParseError2::new_error(
                             &ctx.module.source, symbolic.identifier.position,
                             &format!("Could not find a function with this name")
                         ))
+                    }
                 };
                 symbolic.definition = Some(definition_id);
                 match &ctx.types.get_base_definition(&definition_id).unwrap().definition {
                     DefinedTypeVariant::Function(definition) => {
                         num_definition_args = definition.arguments.len();
                     },
                     _ => unreachable!(),
+                }
+            }
+        }
         // Check the poly args and the number of variables in the call
         // expression
         self.visit_call_poly_args(ctx, id)?;
         let call_expr = &mut ctx.heap[id];
         if num_expr_args != num_definition_args {
             return Err(ParseError2::new_error(
                 &ctx.module.source, call_expr.position,
                 &format!(
                     "This call expects {} arguments, but {} were provided",
                     num_definition_args, num_expr_args
+                )
             ));
+        }
         // Recurse into all of the arguments and set the expression's parent
         let upcast_id = id.upcast();
         let old_num_exprs = self.expression_buffer.len();
         self.expression_buffer.extend(&call_expr.arguments);
         let new_num_exprs = self.expression_buffer.len();
         let old_expr_parent = self.expr_parent;
         call_expr.parent = old_expr_parent;
         for arg_expr_idx in old_num_exprs..new_num_exprs {
             let arg_expr_id = self.expression_buffer[arg_expr_idx];
             self.expr_parent = ExpressionParent::Expression(upcast_id, arg_expr_idx as u32);
             self.visit_expr(ctx, arg_expr_id)?;
+        }
         self.expression_buffer.truncate(old_num_exprs);
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let var_expr = &ctx.heap[id];
         let variable_id = self.find_variable(ctx, self.relative_pos_in_block, &var_expr.identifier)?;
         let var_expr = &mut ctx.heap[id];
         var_expr.declaration = Some(variable_id);
         var_expr.parent = self.expr_parent;
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // ParserType visitors
     //--------------------------------------------------------------------------
     fn visit_parser_type(&mut self, ctx: &mut Ctx, id: ParserTypeId) -> VisitorResult {
         let old_num_types = self.parser_type_buffer.len();
         match self.visit_parser_type_without_buffer_cleanup(ctx, id) {
             Ok(_) => {
                 debug_assert_eq!(self.parser_type_buffer.len(), old_num_types);
                 Ok(())
             },
             Err(err) => {
                 self.parser_type_buffer.truncate(old_num_types);
                 Err(err)
+            }
+        }
+    }
+}
 enum FindOfTypeResult {
     // Identifier was exactly matched, type matched as well
     Found(DefinitionId),
     // Identifier was matched, but the type differs from the expected one
     TypeMismatch(&'static str),
     // Identifier could not be found
     NotFound,
+}
 impl ValidityAndLinkerVisitor {
     //--------------------------------------------------------------------------
     // Special traversal
     //--------------------------------------------------------------------------
     /// Will visit a statement with a hint about its wrapping statement. This is
     /// used to distinguish block statements with a wrapping synchronous
     /// statement from normal block statements.
     fn visit_stmt_with_hint(&mut self, ctx: &mut Ctx, id: StatementId, hint: Option<SynchronousStatementId>) -> VisitorResult {
         if let Statement::Block(block_stmt) = &ctx.heap[id] {
             let block_id = block_stmt.this;
             self.visit_block_stmt_with_hint(ctx, block_id, hint)
         } else {
             self.visit_stmt(ctx, id)
+        }
+    }
     fn visit_block_stmt_with_hint(&mut self, ctx: &mut Ctx, id: BlockStatementId, hint: Option<SynchronousStatementId>) -> VisitorResult {
         if self.performing_breadth_pass {
             // Performing a breadth pass, so don't traverse into the statements
             // of the block.
             return Ok(())
+        }
         // Set parent scope and relative position in the parent scope. Remember
         // these values to set them back to the old values when we're done with
         // the traversal of the block's statements.
         let body = &mut ctx.heap[id];
         body.parent_scope = self.cur_scope.clone();
         body.relative_pos_in_parent = self.relative_pos_in_block;
         let old_scope = self.cur_scope.replace(match hint {
             Some(sync_id) => Scope::Synchronous((sync_id, id)),
             None => Scope::Regular(id),
         });
         let old_relative_pos = self.relative_pos_in_block;
         // Copy statement IDs into buffer
         let old_num_stmts = self.statement_buffer.len();
+        {
             let body = &ctx.heap[id];
             self.statement_buffer.extend_from_slice(&body.statements);
+        }
         let new_num_stmts = self.statement_buffer.len();
         // Perform the breadth-first pass. Its main purpose is to find labeled
         // statements such that we can find the `goto`-targets immediately when
         // performing the depth pass
         self.performing_breadth_pass = true;
         for stmt_idx in old_num_stmts..new_num_stmts {
             self.relative_pos_in_block = (stmt_idx - old_num_stmts) as u32;
             self.visit_stmt(ctx, self.statement_buffer[stmt_idx])?;
+        }
         if !self.insert_buffer.is_empty() {
             let body = &mut ctx.heap[id];
             for (insert_idx, (pos, stmt)) in self.insert_buffer.drain(..).enumerate() {
                 body.statements.insert(pos as usize + insert_idx, stmt);
+            }
+        }
         // And the depth pass. Because we're not actually visiting any inserted
         // nodes because we're using the statement buffer, we may safely use the
         // relative_pos_in_block counter.
         self.performing_breadth_pass = false;
         for stmt_idx in old_num_stmts..new_num_stmts {
             self.relative_pos_in_block = (stmt_idx - old_num_stmts) as u32;
             self.visit_stmt(ctx, self.statement_buffer[stmt_idx])?;
+        }
         self.cur_scope = old_scope;
         self.relative_pos_in_block = old_relative_pos;
         // Pop statement buffer
         debug_assert!(self.insert_buffer.is_empty(), "insert buffer not empty after depth pass");
         self.statement_buffer.truncate(old_num_stmts);
         Ok(())
+    }
     /// Visits a particular ParserType in the AST and resolves temporary and
     /// implicitly inferred types into the appropriate tree. Note that a
     /// ParserType node is a tree. Only call this function on the root node of
     /// that tree to prevent doing work more than once.
     fn visit_parser_type_without_buffer_cleanup(&mut self, ctx: &mut Ctx, id: ParserTypeId) -> VisitorResult {
         use ParserTypeVariant as PTV;
         debug_assert!(!self.performing_breadth_pass);
         let init_num_types = self.parser_type_buffer.len();
         self.parser_type_buffer.push(id);
         'resolve_loop: while self.parser_type_buffer.len() > init_num_types {
             let parser_type_id = self.parser_type_buffer.pop().unwrap();
             let parser_type = &ctx.heap[parser_type_id];
             let (symbolic_pos, symbolic_variant, num_inferred_to_allocate) = match &parser_type.variant {
                 PTV::Message | PTV::Bool |
                 PTV::Byte | PTV::Short | PTV::Int | PTV::Long |
                 PTV::String |
                 PTV::IntegerLiteral | PTV::Inferred => {
                     // Builtin types or types that do not require recursion
                     continue 'resolve_loop;
                 },
                 PTV::Array(subtype_id) |
                 PTV::Input(subtype_id) |
                 PTV::Output(subtype_id) => {
                     // Requires recursing
                     self.parser_type_buffer.push(*subtype_id);
                     continue 'resolve_loop;
                 },
                 PTV::Symbolic(symbolic) => {
                     // Retrieve poly_vars from function/component definition to
                     // match against.
                     let (definition_id, poly_vars) = match self.def_type {
                         DefinitionType::None => unreachable!(),
                         DefinitionType::Primitive(id) => (id.upcast(), &ctx.heap[id].poly_vars),
                         DefinitionType::Composite(id) => (id.upcast(), &ctx.heap[id].poly_vars),
                         DefinitionType::Function(id) => (id.upcast(), &ctx.heap[id].poly_vars),
                     };
                     let mut symbolic_variant = None;
                     for (poly_var_idx, poly_var) in poly_vars.iter().enumerate() {
                         if symbolic.identifier.value == poly_var.value {
                             // Type refers to a polymorphic variable.
                             // TODO: @hkt Maybe allow higher-kinded types?
                             if !symbolic.poly_args.is_empty() {
                                 return Err(ParseError2::new_error(
                                     &ctx.module.source, symbolic.identifier.position,
                                     "Polymorphic arguments to a polymorphic variable (higher-kinded types) are not allowed (yet)"
                                 ));
+                            }
                             symbolic_variant = Some(SymbolicParserTypeVariant::PolyArg(definition_id, poly_var_idx));
+                        }
+                    }
                     if let Some(symbolic_variant) = symbolic_variant {
                         // Identifier points to a symbolic type
                         (symbolic.identifier.position, symbolic_variant, 0)
                     } else {
                         // Must be a user-defined type, otherwise an error
                         let found_type = find_type_definition(
                             &ctx.symbols, &ctx.types, ctx.module.root_id, &symbolic.identifier
                         ).as_parse_error(&ctx.module.source)?;
                         symbolic_variant = Some(SymbolicParserTypeVariant::Definition(found_type.ast_definition));
                         // TODO: @function_ptrs: Allow function pointers at some
                         //  point in the future
                         if found_type.definition.type_class().is_proc_type() {
                             return Err(ParseError2::new_error(
                                 &ctx.module.source, symbolic.identifier.position,
                                 &format!(
                                     "This identifier points to a {} type, expected a datatype",
                                     found_type.definition.type_class()
+                                )
                             ));
+                        }
                         // If the type is polymorphic then we have two cases: if
                         // the programmer did not specify the polyargs then we
                         // assume we're going to infer all of them. Otherwise we
                         // make sure that they match in count.
                         if !found_type.poly_args.is_empty() && symbolic.poly_args.is_empty() {
                             // All inferred
+                            (
                                 symbolic.identifier.position,
                                 SymbolicParserTypeVariant::Definition(found_type.ast_definition),
                                 found_type.poly_args.len()
+                            )
                         } else if symbolic.poly_args.len() != found_type.poly_args.len() {
                             return Err(ParseError2::new_error(
                                 &ctx.module.source, symbolic.identifier.position,
                                 &format!(
                                     "Expected {} polymorphic arguments (or none, to infer them), but {} were specified",
                                     found_type.poly_args.len(), symbolic.poly_args.len()
+                                )
                             ))
                         } else {
                             // If here then the type is not polymorphic, or all
                             // types are properly specified by the user.
                             for specified_poly_arg in &symbolic.poly_args {
                                 self.parser_type_buffer.push(*specified_poly_arg);
+                            }
+                            (
                                 symbolic.identifier.position,
                                 SymbolicParserTypeVariant::Definition(found_type.ast_definition),
+                            )
+                        }
+                    }
+                }
             };
             // If here then type is symbolic, perform a mutable borrow to set
             // the target of the symbolic type.
             for _ in 0..num_inferred_to_allocate {
                 // TODO: @hack, not very user friendly to manually allocate
                 //  `inferred` ParserTypes with the InputPosition of the
                 //  symbolic type's identifier.
                 // We reuse the `parser_type_buffer` to temporarily store these
                 // and we'll take them out later
                 self.parser_type_buffer.push(ctx.heap.alloc_parser_type(|this| ParserType{
                     this,
                     pos: symbolic_pos,
                     variant: ParserTypeVariant::Inferred,
                 }));
+            }
             if let PTV::Symbolic(symbolic) = &mut ctx.heap[id].variant {
                 for _ in 0..num_inferred_to_allocate {
                     symbolic.poly_args.push(self.parser_type_buffer.pop().unwrap());
+                }
                 symbolic.variant = Some(symbolic_variant);
             } else {
                 unreachable!();
+            }
+        }
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Utilities
     //--------------------------------------------------------------------------
     /// Adds a local variable to the current scope. It will also annotate the
     /// `Local` in the AST with its relative position in the block.
     fn checked_local_add(&mut self, ctx: &mut Ctx, relative_pos: u32, id: LocalId) -> Result<(), ParseError2> {
         debug_assert!(self.cur_scope.is_some());
         // Make sure we do not conflict with any global symbols
+        {
             let ident = &ctx.heap[id].identifier;
             if let Some(symbol) = ctx.symbols.resolve_symbol(ctx.module.root_id, &ident.value) {
                 return Err(
                     ParseError2::new_error(&ctx.module.source, ident.position, "Local variable declaration conflicts with symbol")
                         .with_postfixed_info(&ctx.module.source, symbol.position, "Conflicting symbol is found here")
                 );
+            }
+        }
         let local = &mut ctx.heap[id];
         local.relative_pos_in_block = relative_pos;
         // Make sure we do not shadow any variables in any of the scopes. Note
         // that variables in parent scopes may be declared later
         let local = &ctx.heap[id];
         let mut scope = self.cur_scope.as_ref().unwrap();
         let mut local_relative_pos = self.relative_pos_in_block;
         loop {
             debug_assert!(scope.is_block(), "scope is not a block");
             let block = &ctx.heap[scope.to_block()];
             for other_local_id in &block.locals {
                 let other_local = &ctx.heap[*other_local_id];
                 // Position check in case another variable with the same name
                 // is defined in a higher-level scope, but later than the scope
                 // in which the current variable resides.
                 if local.this != *other_local_id &&
                     local_relative_pos >= other_local.relative_pos_in_block &&
                     local.identifier.value == other_local.identifier.value {
                     // Collision within this scope
                     return Err(
                         ParseError2::new_error(&ctx.module.source, local.position, "Local variable name conflicts with another variable")
                             .with_postfixed_info(&ctx.module.source, other_local.position, "Previous variable is found here")
                     );
+                }
+            }
             // Current scope is fine, move to parent scope if any
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();
             if let Scope::Definition(definition_id) = scope {
                 // At outer scope, check parameters of function/component
                 for parameter_id in ctx.heap[*definition_id].parameters() {
                     let parameter = &ctx.heap[*parameter_id];
                     if local.identifier.value == parameter.identifier.value {
                         return Err(
                             ParseError2::new_error(&ctx.module.source, local.position, "Local variable name conflicts with parameter")
                                 .with_postfixed_info(&ctx.module.source, parameter.position, "Parameter definition is found here")
                         );
+                    }
+                }
                 break;
+            }
             // If here, then we are dealing with a block-like parent block
             local_relative_pos = ctx.heap[scope.to_block()].relative_pos_in_parent;
+        }
         // No collisions at all
         let block = &mut ctx.heap[self.cur_scope.as_ref().unwrap().to_block()];
         block.locals.push(id);
         Ok(())
+    }
     /// Finds a variable in the visitor's scope that must appear before the
     /// specified relative position within that block.
     fn find_variable(&self, ctx: &Ctx, mut relative_pos: u32, identifier: &NamespacedIdentifier) -> Result<VariableId, ParseError2> {
         debug_assert!(self.cur_scope.is_some());
         debug_assert!(identifier.num_namespaces > 0);
         // TODO: Update once globals are possible as well
         if identifier.num_namespaces > 1 {
             todo!("Implement namespaced constant seeking")
+        }
         // TODO: May still refer to an alias of a global symbol using a single
         //  identifier in the namespace.
         // No need to use iterator over namespaces if here
         let mut scope = self.cur_scope.as_ref().unwrap();
         loop {
             debug_assert!(scope.is_block());
             let block = &ctx.heap[scope.to_block()];
             for local_id in &block.locals {
                 let local = &ctx.heap[*local_id];
                 if local.relative_pos_in_block < relative_pos && local.identifier.value == identifier.value {
                     return Ok(local_id.upcast());
+                }
+            }
             debug_assert!(block.parent_scope.is_some());
             scope = block.parent_scope.as_ref().unwrap();
             if !scope.is_block() {
                 // Definition scope, need to check arguments to definition
                 match scope {
                     Scope::Definition(definition_id) => {
                         let definition = &ctx.heap[*definition_id];
                         for parameter_id in definition.parameters() {
                             let parameter = &ctx.heap[*parameter_id];
                             if parameter.identifier.value == identifier.value {
                                 return Ok(parameter_id.upcast());
+                            }
+                        }
                     },
                     _ => unreachable!(),
+                }
                 // Variable could not be found
                 return Err(ParseError2::new_error(
                     &ctx.module.source, identifier.position, "This variable is not declared"
                 ));
             } else {
                 relative_pos = block.relative_pos_in_parent;
+            }
+        }
+    }
     /// Adds a particular label to the current scope. Will return an error if
     /// there is another label with the same name visible in the current scope.
     fn checked_label_add(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> Result<(), ParseError2> {
         debug_assert!(self.cur_scope.is_some());
         // Make sure label is not defined within the current scope or any of the
         // parent scope.
         let label = &ctx.heap[id];
         let mut scope = self.cur_scope.as_ref().unwrap();
         loop {
             debug_assert!(scope.is_block(), "scope is not a block");
             let block = &ctx.heap[scope.to_block()];
             for other_label_id in &block.labels {
                 let other_label = &ctx.heap[*other_label_id];
                 if other_label.label.value == label.label.value {
                     // Collision
                     return Err(
                         ParseError2::new_error(&ctx.module.source, label.position, "Label name conflicts with another label")
                             .with_postfixed_info(&ctx.module.source, other_label.position, "Other label is found here")
                     );
+                }
+            }
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();
             if !scope.is_block() {
                 break;
+            }
+        }
         // No collisions
         let block = &mut ctx.heap[self.cur_scope.as_ref().unwrap().to_block()];
         block.labels.push(id);
         Ok(())
+    }
     /// Finds a particular labeled statement by its identifier. Once found it
     /// will make sure that the target label does not skip over any variable
     /// declarations within the scope in which the label was found.
     fn find_label(&self, ctx: &Ctx, identifier: &Identifier) -> Result<LabeledStatementId, ParseError2> {
         debug_assert!(self.cur_scope.is_some());
         let mut scope = self.cur_scope.as_ref().unwrap();
         loop {
             debug_assert!(scope.is_block(), "scope is not a block");
             let relative_scope_pos = ctx.heap[scope.to_block()].relative_pos_in_parent;
             let block = &ctx.heap[scope.to_block()];
             for label_id in &block.labels {
                 let label = &ctx.heap[*label_id];
                 if label.label.value == identifier.value {
                     for local_id in &block.locals {
                         // TODO: Better to do this in control flow analysis, it
                         //  is legal to skip over a variable declaration if it
                         //  is not actually being used. I might be missing
                         //  something here when laying out the bytecode...
                         let local = &ctx.heap[*local_id];
                         if local.relative_pos_in_block > relative_scope_pos && local.relative_pos_in_block < label.relative_pos_in_block {
                             return Err(
                                 ParseError2::new_error(&ctx.module.source, identifier.position, "This target label skips over a variable declaration")
                                     .with_postfixed_info(&ctx.module.source, label.position, "Because it jumps to this label")
                                     .with_postfixed_info(&ctx.module.source, local.position, "Which skips over this variable")
                             );
+                        }
+                    }
                     return Ok(*label_id);
+                }
+            }
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();
             if !scope.is_block() {
                 return Err(ParseError2::new_error(&ctx.module.source, identifier.position, "Could not find this label"));
+            }
+        }
+    }
     /// Finds a particular symbol in the symbol table which must correspond to
     /// a definition of a particular type.
     // Note: root_id, symbols and types passed in explicitly to prevent
     //  borrowing errors
     fn find_symbol_of_type(
         &self, root_id: RootId, symbols: &SymbolTable, types: &TypeTable,
         identifier: &NamespacedIdentifier, expected_type_class: TypeClass
     ) -> FindOfTypeResult {
         // Find symbol associated with identifier
         let symbol = symbols.resolve_namespaced_symbol(root_id, &identifier);
         if symbol.is_none() { return FindOfTypeResult::NotFound; }
         let (symbol, iter) = symbol.unwrap();
         if iter.num_remaining() != 0 { return FindOfTypeResult::NotFound; }
         match &symbol.symbol {
             Symbol::Definition((_, definition_id)) => {
                 // Make sure definition is of the expected type
                 let definition_type = types.get_base_definition(&definition_id);
                 debug_assert!(definition_type.is_some(), "Found symbol '{}' in symbol table, but not in type table", String::from_utf8_lossy(&identifier.value));
                 let definition_type_class = definition_type.unwrap().definition.type_class();
                 if definition_type_class != expected_type_class {
                     FindOfTypeResult::TypeMismatch(definition_type_class.display_name())
                 } else {
                     FindOfTypeResult::Found(*definition_id)
+                }
             },
             Symbol::Namespace(_) => FindOfTypeResult::TypeMismatch("namespace"),
+        }
+    }
     /// This function will check if the provided while statement ID has a block
     /// statement that is one of our current parents.
     fn has_parent_while_scope(&self, ctx: &Ctx, id: WhileStatementId) -> bool {
         debug_assert!(self.cur_scope.is_some());
         let mut scope = self.cur_scope.as_ref().unwrap();
         let while_stmt = &ctx.heap[id];
         loop {
             debug_assert!(scope.is_block());
             let block = scope.to_block();
             if while_stmt.body == block.upcast() {
                 return true;
+            }
             let block = &ctx.heap[block];
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();
             if !scope.is_block() {
                 return false;
+            }
+        }
+    }
     /// This function should be called while dealing with break/continue
     /// statements. It will try to find the targeted while statement, using the
     /// target label if provided. If a valid target is found then the loop's
     /// ID will be returned, otherwise a parsing error is constructed.
     /// The provided input position should be the position of the break/continue
     /// statement.
     fn resolve_break_or_continue_target(&self, ctx: &Ctx, position: InputPosition, label: &Option<Identifier>) -> Result<WhileStatementId, ParseError2> {
         let target = match label {
             Some(label) => {
                 let target_id = self.find_label(ctx, label)?;
                 // Make sure break target is a while statement
                 let target = &ctx.heap[target_id];
                 if let Statement::While(target_stmt) = &ctx.heap[target.body] {
                     // Even though we have a target while statement, the break might not be
                     // present underneath this particular labeled while statement
                     if !self.has_parent_while_scope(ctx, target_stmt.this) {
                         ParseError2::new_error(&ctx.module.source, label.position, "Break statement is not nested under the target label's while statement")
                             .with_postfixed_info(&ctx.module.source, target.position, "The targeted label is found here");
+                    }
                     target_stmt.this
                 } else {
                     return Err(
                         ParseError2::new_error(&ctx.module.source, label.position, "Incorrect break target label, it must target a while loop")
                             .with_postfixed_info(&ctx.module.source, target.position, "The targeted label is found here")
                     );
+                }
             },
             None => {
                 // Use the enclosing while statement, the break must be
                 // nested within that while statement
                 if self.in_while.is_none() {
                     return Err(
                         ParseError2::new_error(&ctx.module.source, position, "Break statement is not nested under a while loop")
                     );
+                }
                 self.in_while.unwrap()
+            }
         };
         // We have a valid target for the break statement. But we need to
         // make sure we will not break out of a synchronous block
+        {
             let target_while = &ctx.heap[target];
             if target_while.in_sync != self.in_sync {
                 // Break is nested under while statement, so can only escape a
                 // sync block if the sync is nested inside the while statement.
                 debug_assert!(self.in_sync.is_some());
                 let sync_stmt = &ctx.heap[self.in_sync.unwrap()];
                 return Err(
                     ParseError2::new_error(&ctx.module.source, position, "Break may not escape the surrounding synchronous block")
                         .with_postfixed_info(&ctx.module.source, target_while.position, "The break escapes out of this loop")
                         .with_postfixed_info(&ctx.module.source, sync_stmt.position, "And would therefore escape this synchronous block")
                 );
+            }
+        }
         Ok(target)
+    }
     fn visit_call_poly_args(&mut self, ctx: &mut Ctx, call_id: CallExpressionId) -> VisitorResult {
         let call_expr = &ctx.heap[call_id];
         // Determine the polyarg signature
         let num_expected_poly_args = match &call_expr.method {
             Method::Create => {
             },
             Method::Fires => {
             },
             Method::Get => {
             },
             Method::Put => {
+            }
             Method::Symbolic(symbolic) => {
                 let definition = &ctx.heap[symbolic.definition.unwrap()];
                 if let Definition::Function(definition) = definition {
                     definition.poly_vars.len()
                 } else {
                     debug_assert!(false, "expected function while visiting call poly args");
                     unreachable!();
+                }
+            }
         };
         // We allow zero polyargs to imply all args are inferred. Otherwise the
         // number of arguments must be equal
         if call_expr.poly_args.is_empty() {
             if num_expected_poly_args != 0 {
                 // Infer all polyargs
                 // TODO: @cleanup Not nice to use method position as implicitly
                 //  inferred parser type pos.
                 let pos = call_expr.position();
                 for _ in 0..num_expected_poly_args {
                     self.parser_type_buffer.push(ctx.heap.alloc_parser_type(|this| ParserType {
                         this,
                         pos,
                         variant: ParserTypeVariant::Inferred,
                     }));
+                }
                 let call_expr = &mut ctx.heap[call_id];
                 call_expr.poly_args.reserve(num_expected_poly_args);
                 for _ in 0..num_expected_poly_args {
                     call_expr.poly_args.push(self.parser_type_buffer.pop().unwrap());
+                }
+            }
             Ok(())
         } else if call_expr.poly_args.len() == num_expected_poly_args {
             // Number of args is not 0, so parse all the specified ParserTypes
             let old_num_types = self.parser_type_buffer.len();
             self.parser_type_buffer.extend(&call_expr.poly_args);
             while self.parser_type_buffer.len() > old_num_types {
                 let parser_type_id = self.parser_type_buffer.pop().unwrap();
                 self.visit_parser_type(ctx, parser_type_id);
+                self.visit_parser_type(ctx, parser_type_id)?;
+            }
             self.parser_type_buffer.truncate(old_num_types);
             Ok(())
         } else {
             return Err(ParseError2::new_error(
                 &ctx.module.source, call_expr.position,
                 &format!(
                     "Expected {} polymorphic arguments (or none, to infer them), but {} were specified",
                     num_expected_poly_args, call_expr.poly_args.len()
+                )
             ));
+        }
+    }
+}
@@ \ No newline at end of file @@

src/runtime/communication.rs

➞

Show inline comments

 use super::*;
 use crate::common::*;
 use core::ops::{Deref, DerefMut};
 // Guard protecting an incrementally unfoldable slice of MapTempGuard elements
 struct MapTempsGuard<'a, K, V>(&'a mut [HashMap<K, V>]);
 // Type protecting a temporary map; At the start and end of the Guard's lifetime, self.0.is_empty() must be true
 struct MapTempGuard<'a, K, V>(&'a mut HashMap<K, V>);
 // Once the synchronous round has begun, this structure manages the
 // native component's speculative branches, one per synchronous batch.
 struct BranchingNative {
     branches: HashMap<Predicate, NativeBranch>,
+}
 // Corresponds to one of the native's synchronous batches during the synchronous round.
 // ports marked for message receipt correspond to entries of
 // (a) `gotten` if they have not received yet,
 // (b) `to_get` if they have already received, with the given payload.
 // The branch corresponds to a component solution IFF to_get is empty.
 #[derive(Clone, Debug)]
 struct NativeBranch {
     index: usize,
     gotten: HashMap<PortId, Payload>,
     to_get: HashSet<PortId>,
+}
 // Manages a protocol component's speculative branches for the duration
 // of the synchronous round.
 #[derive(Debug)]
 struct BranchingProtoComponent {
     branches: HashMap<Predicate, ProtoComponentBranch>,
+}
 // One specualtive branch of a protocol component.
 // `ended` IFF this branch has reached SyncBlocker::SyncBlockEnd before.
 #[derive(Debug, Clone)]
 struct ProtoComponentBranch {
     state: ComponentState,
     inner: ProtoComponentBranchInner,
     ended: bool,
+}
 // A structure wrapping a set of three pointers, making it impossible
 // to miss that they are being setup for `cyclic_drain`.
 struct CyclicDrainer<'a, K: Eq + Hash, V> {
     input: &'a mut HashMap<K, V>,
     swap: &'a mut HashMap<K, V>,
     output: &'a mut HashMap<K, V>,
+}
 // Small convenience trait for extending the stdlib's bool type with
 // an optionlike replace method for increasing brevity.
 trait ReplaceBoolTrue {
     fn replace_with_true(&mut self) -> bool;
+}
 //////////////// IMPL ////////////////////////////
 impl ReplaceBoolTrue for bool {
     fn replace_with_true(&mut self) -> bool {
         let was = *self;
         *self = true;
         !was
+    }
+}
 // CuUndecided provides a mostly immutable view into the ConnectorUnphased structure,
 // making it harder to accidentally mutate its contents in a way that cannot be rolled back.
 impl CuUndecided for ConnectorUnphased {
     fn logger_and_protocol_description(&mut self) -> (&mut dyn Logger, &ProtocolDescription) {
         (&mut *self.logger, &self.proto_description)
+    }
     fn logger_and_protocol_components(
         &mut self,
     ) -> (&mut dyn Logger, &mut HashMap<ComponentId, ComponentState>) {
         (&mut *self.logger, &mut self.proto_components)
+    }
     fn logger(&mut self) -> &mut dyn Logger {
         &mut *self.logger
+    }
     fn proto_description(&self) -> &ProtocolDescription {
         &self.proto_description
+    }
     fn native_component_id(&self) -> ComponentId {
         self.native_component_id
+    }
+}
 impl<'a, K, V> MapTempsGuard<'a, K, V> {
     fn reborrow(&mut self) -> MapTempsGuard<'_, K, V> {
         MapTempsGuard(self.0)
+    }
     fn split_first_mut(self) -> (MapTempGuard<'a, K, V>, MapTempsGuard<'a, K, V>) {
         let (head, tail) = self.0.split_first_mut().expect("Cache exhausted");
         (MapTempGuard::new(head), MapTempsGuard(tail))
+    }
+}
 impl<'a, K, V> MapTempGuard<'a, K, V> {
     fn new(map: &'a mut HashMap<K, V>) -> Self {
         assert!(map.is_empty()); // sanity check
         Self(map)
+    }
+}
 impl<'a, K, V> Drop for MapTempGuard<'a, K, V> {
     fn drop(&mut self) {
         assert!(self.0.is_empty()); // sanity check
+    }
+}
 impl<'a, K, V> Deref for MapTempGuard<'a, K, V> {
     type Target = HashMap<K, V>;
     fn deref(&self) -> &<Self as Deref>::Target {
         self.0
+    }
+}
 impl<'a, K, V> DerefMut for MapTempGuard<'a, K, V> {
     fn deref_mut(&mut self) -> &mut <Self as Deref>::Target {
         self.0
+    }
+}
 impl Connector {
     /// Read the message received by the given port in the previous synchronous round.
     pub fn gotten(&self, port: PortId) -> Result<&Payload, GottenError> {
         use GottenError as Ge;
         if let ConnectorPhased::Communication(comm) = &self.phased {
             match &comm.round_result {
                 Err(_) => Err(Ge::PreviousSyncFailed),
                 Ok(None) => Err(Ge::NoPreviousRound),
                 Ok(Some(round_ok)) => round_ok.gotten.get(&port).ok_or(Ge::PortDidntGet),
+            }
         } else {
             return Err(Ge::NoPreviousRound);
+        }
+    }
     /// Creates a new, empty synchronous batch for the connector and selects it.
     /// Subsequent calls to `put` and `get` with populate the new batch with port operations.
     pub fn next_batch(&mut self) -> Result<usize, WrongStateError> {
         // returns index of new batch
         if let ConnectorPhased::Communication(comm) = &mut self.phased {
             comm.native_batches.push(Default::default());
             Ok(comm.native_batches.len() - 1)
         } else {
             Err(WrongStateError)
+        }
+    }
     fn port_op_access(
         &mut self,
         port: PortId,
         expect_polarity: Polarity,
     ) -> Result<&mut NativeBatch, PortOpError> {
         use PortOpError as Poe;
         let Self { unphased: cu, phased } = self;
         let info = cu.ips.port_info.map.get(&port).ok_or(Poe::UnknownPolarity)?;
         if info.owner != cu.native_component_id {
             return Err(Poe::PortUnavailable);
+        }
         if info.polarity != expect_polarity {
             return Err(Poe::WrongPolarity);
+        }
         match phased {
             ConnectorPhased::Setup { .. } => Err(Poe::NotConnected),
             ConnectorPhased::Communication(comm) => {
                 let batch = comm.native_batches.last_mut().unwrap(); // length >= 1 is invariant
                 Ok(batch)
+            }
+        }
+    }
     /// Add a `put` operation to the connector's currently-selected synchronous batch.
     /// Returns an error if the given port is not owned by the native component,
     /// has the wrong polarity, or is already included in the batch.
     pub fn put(&mut self, port: PortId, payload: Payload) -> Result<(), PortOpError> {
         use PortOpError as Poe;
         let batch = self.port_op_access(port, Putter)?;
         if batch.to_put.contains_key(&port) {
             Err(Poe::MultipleOpsOnPort)
         } else {
             batch.to_put.insert(port, payload);
             Ok(())
+        }
+    }
     /// Add a `get` operation to the connector's currently-selected synchronous batch.
     /// Returns an error if the given port is not owned by the native component,
     /// has the wrong polarity, or is already included in the batch.
     pub fn get(&mut self, port: PortId) -> Result<(), PortOpError> {
         use PortOpError as Poe;
         let batch = self.port_op_access(port, Getter)?;
         if batch.to_get.insert(port) {
             Ok(())
         } else {
             Err(Poe::MultipleOpsOnPort)
+        }
+    }
     /// Participate in the completion of the next synchronous round, in which
     /// the native component will perform the set of prepared operations of exactly one
     /// of the synchronous batches. At the end of the procedure, the synchronous
     /// batches will be reset to a singleton set, whose only element is selected, and empty.
     /// The caller yields control over to the connector runtime to faciltiate the underlying
     /// coordination work until either (a) the round is completed with all components' states
     /// updated accordingly, (b) a distributed failure event resets all components'
     /// states to what they were prior to the sync call, or (c) the sync procedure encounters
     /// an unrecoverable error which ends the call early, and breaks the session and connector's
     /// states irreversably.
     /// Note that the (b) case necessitates the success of a distributed rollback procedure,
     /// which this component may initiate, but cannot guarantee will succeed in time or at all.
     /// consequently, the given timeout duration represents a duration in which the connector
     /// will make a best effort to fail the round and return control flow to the caller.
     pub fn sync(&mut self, timeout: Option<Duration>) -> Result<usize, SyncError> {
         // This method first destructures the connector, and checks for obvious
         // failure cases. The bulk of the behavior continues in `connected_sync`,
         // to minimize indentation, and enable convient ?-style short circuit syntax.
         let Self { unphased: cu, phased } = self;
         match phased {
             ConnectorPhased::Setup { .. } => Err(SyncError::NotConnected),
             ConnectorPhased::Communication(comm) => {
                 match &comm.round_result {
                     Err(SyncError::Unrecoverable(e)) => {
                         log!(cu.logger(), "Attempted to start sync round, but previous error {:?} was unrecoverable!", e);
                         return Err(SyncError::Unrecoverable(e.clone()));
+                    }
                     _ => {}
+                }
                 comm.round_result = Self::connected_sync(cu, comm, timeout);
                 comm.round_index += 1;
                 match &comm.round_result {
                     Ok(None) => unreachable!(),
                     Ok(Some(ok_result)) => Ok(ok_result.batch_index),
                     Err(sync_error) => Err(sync_error.clone()),
+                }
+            }
+        }
+    }
     // Attempts to complete the synchronous round for the given
     // communication-phased connector structure.
     // Modifies components and ports in `cu` IFF the round succeeds.
     #[inline]
     fn connected_sync(
         cu: &mut ConnectorUnphased,
         comm: &mut ConnectorCommunication,
         timeout: Option<Duration>,
     ) -> Result<Option<RoundEndedNative>, SyncError> {
         //////////////////////////////////
         use SyncError as Se;
         //////////////////////////////////
         // Create separate storages for ports and components stored in `cu`,
         // while kicking off the branching of components until the set of
         // components entering their synchronous block is finalized in `branching_proto_components`.
         // This is the last time cu's components and ports are accessed until the round is decided.
         let mut ips = cu.ips.clone();
         let mut branching_proto_components =
             HashMap::<ComponentId, BranchingProtoComponent>::default();
         let mut unrun_components: Vec<(ComponentId, ComponentState)> = cu
             .proto_components
             .iter()
             .map(|(&proto_id, proto)| (proto_id, proto.clone()))
             .collect();
         log!(cu.logger(), "Nonsync running {} proto components...", unrun_components.len());
         // initially, the set of components to run is the set of components stored by `cu`,
         // but they are eventually drained into `branching_proto_components`.
         // Some components exit first, and others are created and put into `unrun_components`.
         while let Some((proto_component_id, mut component)) = unrun_components.pop() {
             log!(
                 cu.logger(),
                 "Nonsync running proto component with ID {:?}. {} to go after this",
                 proto_component_id,
                 unrun_components.len()
             );
             let (logger, proto_description) = cu.logger_and_protocol_description();
             let mut ctx = NonsyncProtoContext {
                 ips: &mut ips,
                 logger,
                 proto_component_id,
                 unrun_components: &mut unrun_components,
             };
             let blocker = component.nonsync_run(&mut ctx, proto_description);
             log!(
                 logger,
                 "proto component {:?} ran to nonsync blocker {:?}",
                 proto_component_id,
                 &blocker
             );
             use NonsyncBlocker as B;
             match blocker {
                 B::ComponentExit => drop(component),
                 B::Inconsistent => return Err(Se::InconsistentProtoComponent(proto_component_id)),
                 B::SyncBlockStart => assert!(branching_proto_components
                     .insert(proto_component_id, BranchingProtoComponent::initial(component))
                     .is_none()), // Some(_) returned IFF some component identifier key is overwritten (BAD!)
+            }
+        }
         log!(
             cu.logger(),
             "All {} proto components are now done with Nonsync phase",
             branching_proto_components.len(),
         );
         // Create temporary structures needed for the synchronous phase of the round
         let mut rctx = RoundCtx {
             ips, // already used previously, now moved into RoundCtx
             solution_storage: {
                 let subtree_id_iter = {
                     // Create an iterator over the identifiers of this
                     // connector's childen in the _solution tree_.
                     // Namely, the native, all locally-managed components,
                     // and all this connector's children in the _consensus tree_ (other connectors).
                     let n = std::iter::once(SubtreeId::LocalComponent(cu.native_component_id));
                     let c = branching_proto_components
                         .keys()
                         .map(|&cid| SubtreeId::LocalComponent(cid));
                     let e = comm
                         .neighborhood
                         .children
                         .iter()
                         .map(|&index| SubtreeId::NetEndpoint { index });
                     n.chain(c).chain(e)
                 };
                 log!(
                     cu.logger,
                     "Children in subtree are: {:?}",
                     DebuggableIter(subtree_id_iter.clone())
                 );
                 SolutionStorage::new(subtree_id_iter)
             },
             spec_var_stream: cu.ips.id_manager.new_spec_var_stream(),
             payload_inbox: Default::default(), // buffer for in-memory payloads to be handled
             deadline: timeout.map(|to| Instant::now() + to),
         };
         log!(cu.logger(), "Round context structure initialized");
         // Prepare the branching native component, involving the conversion
         // of its synchronous batches (user provided) into speculative branches eagerly.
         // As a side effect, send all PUTs with the appropriate predicates.
         // Afterwards, each native component's speculative branch finds a local
         // solution the moment it's received all the messages it's awaiting.
         log!(
             cu.logger(),
             "Translating {} native batches into branches...",
             comm.native_batches.len()
         );
         // Allocate a single speculative variable to distinguish each native branch.
         // This enables native components to have distinct branches with identical
         // FIRING variables.
         let native_spec_var = rctx.spec_var_stream.next();
         log!(cu.logger(), "Native branch spec var is {:?}", native_spec_var);
         let mut branching_native = BranchingNative { branches: Default::default() };
         'native_branches: for ((native_branch, index), branch_spec_val) in
             comm.native_batches.drain(..).zip(0..).zip(SpecVal::iter_domain())
+        {
             let NativeBatch { to_get, to_put } = native_branch;
             // compute the solution predicate to associate with this branch.
             let predicate = {
                 let mut predicate = Predicate::default();
                 // all firing ports have SpecVal::FIRING
                 let firing_iter = to_get.iter().chain(to_put.keys()).copied();
                 log!(
                     cu.logger(),
                     "New native with firing ports {:?}",
                     firing_iter.clone().collect::<Vec<_>>()
                 );
                 let firing_ports: HashSet<PortId> = firing_iter.clone().collect();
                 for port in firing_iter {
                     let var = cu.ips.port_info.spec_var_for(port);
                     predicate.assigned.insert(var, SpecVal::FIRING);
+                }
                 // all silent ports have SpecVal::SILENT
                 for port in cu.ips.port_info.ports_owned_by(cu.native_component_id) {
                     if firing_ports.contains(port) {
                         // this one is FIRING
                         continue;
+                    }
                     let var = cu.ips.port_info.spec_var_for(*port);
                     if let Some(SpecVal::FIRING) = predicate.assigned.insert(var, SpecVal::SILENT) {
                         log!(&mut *cu.logger, "Native branch index={} contains internal inconsistency wrt. {:?}. Skipping", index, var);
                         continue 'native_branches;
+                    }
+                }
                 // this branch is consistent. distinguish it with a unique var:val mapping and proceed
                 predicate.inserted(native_spec_var, branch_spec_val)
             };
             log!(cu.logger(), "Native branch index={:?} has consistent {:?}", index, &predicate);
             // send all outgoing messages (by buffering them)
             for (putter, payload) in to_put {
                 let msg = SendPayloadMsg { predicate: predicate.clone(), payload };
                 log!(
                     cu.logger(),
                     "Native branch {} sending msg {:?} with putter {:?}",
                     index,
                     &msg,
                     putter
                 );
                 // sanity check
                 assert_eq!(Putter, cu.ips.port_info.map.get(&putter).unwrap().polarity);
                 rctx.putter_push(cu, putter, msg);
+            }
             let branch = NativeBranch { index, gotten: Default::default(), to_get };
             if branch.is_ended() {
                 // empty to_get set => already corresponds with a component solution
                 log!(
                     cu.logger(),
                     "Native submitting solution for batch {} with {:?}",
                     index,
                     &predicate
                 );
                 rctx.solution_storage.submit_and_digest_subtree_solution(
                     cu,
                     SubtreeId::LocalComponent(cu.native_component_id),
                     predicate.clone(),
                 );
+            }
             if let Some(_) = branching_native.branches.insert(predicate, branch) {
                 // thanks to the native_spec_var, each batch has a distinct predicate
                 unreachable!()
+            }
+        }
         // restore the invariant: !native_batches.is_empty()
         comm.native_batches.push(Default::default());
         // Call to another big method; keep running this round
         // until a distributed decision is reached!
         log!(cu.logger(), "Searching for decision...");
         let decision = Self::sync_reach_decision(
             cu,
             comm,
             &mut branching_native,
             &mut branching_proto_components,
             &mut rctx,
         )?;
         log!(cu.logger(), "Committing to decision {:?}!", &decision);
         comm.endpoint_manager.udp_endpoints_round_end(&mut *cu.logger(), &decision)?;
         // propagate the decision to children
         let msg = Msg::CommMsg(CommMsg {
             round_index: comm.round_index,
             contents: CommMsgContents::CommCtrl(CommCtrlMsg::Announce {
                 decision: decision.clone(),
             }),
         });
         log!(
             cu.logger(),
             "Announcing decision {:?} through child endpoints {:?}",
             &msg,
             &comm.neighborhood.children
         );
         for &child in comm.neighborhood.children.iter() {
             comm.endpoint_manager.send_to_comms(child, &msg)?;
+        }
         let ret = match decision {
             Decision::Failure => {
                 // untouched port/component fields of `cu` are NOT overwritten.
                 // the result is a rollback.
                 Err(Se::RoundFailure)
+            }
             Decision::Success(predicate) => {
                 // commit changes to component states
                 cu.proto_components.clear();
                 let (logger, proto_components) = cu.logger_and_protocol_components();
                 proto_components.extend(
                     // "flatten" branching components, committing the speculation
                     // consistent with the predicate decided upon.
                     branching_proto_components
                         .into_iter()
                         .map(|(cid, bpc)| (cid, bpc.collapse_with(logger, &predicate))),
                 );
                 // commit changes to ports and id_manager
                 log!(
                     logger,
                     "End round with (updated) component states {:?}",
                     proto_components.keys()
                 );
                 cu.ips = rctx.ips;
                 // consume native
                 let round_ok = branching_native.collapse_with(cu.logger(), &predicate);
                 Ok(Some(round_ok))
+            }
         };
         log!(cu.logger(), "Sync round ending! Cleaning up");
         ret
+    }
     // Once the synchronous round has been started, this procedure
     // routs and handles payloads, receives control messages from neighboring connectors,
     // checks for timeout, and aggregates solutions until a distributed decision is reached.
     // The decision is either a solution (success case), or a distributed timeout rollback (failure case)
     // The final possible outcome is an unrecoverable error, which results from some fundamental misbehavior,
     // a network channel breaking, etc.
     fn sync_reach_decision(
         cu: &mut impl CuUndecided,
         comm: &mut ConnectorCommunication,
         branching_native: &mut BranchingNative,
         branching_proto_components: &mut HashMap<ComponentId, BranchingProtoComponent>,
         rctx: &mut RoundCtx,
     ) -> Result<Decision, UnrecoverableSyncError> {
         // The round is in progress, and now its just a matter of arriving at a decision.
         let mut already_requested_failure = false;
         if branching_native.branches.is_empty() {
             // An unsatisfiable native is the easiest way to detect failure
             log!(cu.logger(), "Native starts with no branches! Failure!");
             match comm.neighborhood.parent {
                 Some(parent) => {
                     if already_requested_failure.replace_with_true() {
                         Self::request_failure(cu, comm, parent)?
                     } else {
                         log!(cu.logger(), "Already requested failure");
+                    }
+                }
                 None => {
                     log!(cu.logger(), "No parent. Deciding on failure");
                     return Ok(Decision::Failure);
+                }
+            }
+        }
         // Create a small set of "workspace" hashmaps, to be passed by-reference into various calls.
         // This is an optimization, avoiding repeated allocation.
         let mut pcb_temps_owner = <[HashMap<Predicate, ProtoComponentBranch>; 3]>::default();
         let mut pcb_temps = MapTempsGuard(&mut pcb_temps_owner);
         let mut bn_temp_owner = <HashMap<Predicate, NativeBranch>>::default();
         // first, we run every protocol component to their sync blocker.
         // Afterwards we establish a loop invariant: no new decision can be reached
         // without handling messages in the buffer or arriving from the network
         log!(
             cu.logger(),
             "Running all {} proto components to their sync blocker...",
             branching_proto_components.len()
         );
         for (&proto_component_id, proto_component) in branching_proto_components.iter_mut() {
             let BranchingProtoComponent { branches } = proto_component;
             // must reborrow to constrain the lifetime of pcb_temps to inside the loop
             let (swap, pcb_temps) = pcb_temps.reborrow().split_first_mut();
             let (blocked, _pcb_temps) = pcb_temps.split_first_mut();
             // initially, no protocol components have .ended==true
             // drain from branches --> blocked
             let cd = CyclicDrainer { input: branches, swap: swap.0, output: blocked.0 };
             BranchingProtoComponent::drain_branches_to_blocked(cd, cu, rctx, proto_component_id)?;
             // swap the blocked branches back
             std::mem::swap(blocked.0, branches);
             if branches.is_empty() {
                 log!(cu.logger(), "{:?} has become inconsistent!", proto_component_id);
                 if let Some(parent) = comm.neighborhood.parent {
                     if already_requested_failure.replace_with_true() {
                         Self::request_failure(cu, comm, parent)?
                     } else {
                         log!(cu.logger(), "Already requested failure");
+                    }
                 } else {
                     log!(cu.logger(), "As the leader, deciding on timeout");
                     return Ok(Decision::Failure);
+                }
+            }
+        }
         log!(cu.logger(), "All proto components are blocked");
         // ...invariant established!
         log!(cu.logger(), "Entering decision loop...");
         comm.endpoint_manager.undelay_all();
         'undecided: loop {
             // handle all buffered messages, sending them through endpoints / feeding them to components
             log!(cu.logger(), "Decision loop! have {} messages to recv", rctx.payload_inbox.len());
             while let Some((getter, send_payload_msg)) = rctx.getter_pop() {
                 let getter_info = rctx.ips.port_info.map.get(&getter).unwrap();
                 let cid = getter_info.owner; // the id of the component owning `getter` port
                 assert_eq!(Getter, getter_info.polarity); // sanity check
                 log!(
                     cu.logger(),
                     "Routing msg {:?} to {:?} via {:?}",
                     &send_payload_msg,
                     getter,
                     &getter_info.route
                 );
                 match getter_info.route {
                     Route::UdpEndpoint { index } => {
                         // this is a message sent over the network through a UDP endpoint
                         let udp_endpoint_ext =
                             &mut comm.endpoint_manager.udp_endpoint_store.endpoint_exts[index];
                         let SendPayloadMsg { predicate, payload } = send_payload_msg;
                         log!(cu.logger(), "Delivering to udp endpoint index={}", index);
                         // UDP mediator messages are buffered until the end of the round,
                         // because they are still speculative
                         udp_endpoint_ext.outgoing_payloads.insert(predicate, payload);
+                    }
                     Route::NetEndpoint { index } => {
                         // this is a message sent over the network as a control message
                         let msg = Msg::CommMsg(CommMsg {
                             round_index: comm.round_index,
                             contents: CommMsgContents::SendPayload(send_payload_msg),
                         });
                         // actually send the message now
                         comm.endpoint_manager.send_to_comms(index, &msg)?;
+                    }
                     Route::LocalComponent if cid == cu.native_component_id() => branching_native
                         .feed_msg(
                             cu,
                             rctx,
                             getter,
                             &send_payload_msg,
                             MapTempGuard::new(&mut bn_temp_owner),
                         ),
                     Route::LocalComponent => {
                         // some other component_id routed locally. must be a protocol component!
                         if let Some(branching_component) = branching_proto_components.get_mut(&cid)
+                        {
                             // The recipient component is still running!
                             // Feed it this message AND run it again until all branches are blocked
                             branching_component.feed_msg(
                                 cu,
                                 rctx,
                                 cid,
                                 getter,
                                 &send_payload_msg,
                                 pcb_temps.reborrow(),
                             )?;
                             if branching_component.branches.is_empty() {
                                 // A solution is impossible! this component has zero branches
                                 // Initiate a rollback
                                 log!(cu.logger(), "{:?} has become inconsistent!", cid);
                                 if let Some(parent) = comm.neighborhood.parent {
                                     if already_requested_failure.replace_with_true() {
                                         Self::request_failure(cu, comm, parent)?
                                     } else {
                                         log!(cu.logger(), "Already requested failure");
+                                    }
                                 } else {
                                     log!(cu.logger(), "As the leader, deciding on timeout");
                                     return Ok(Decision::Failure);
+                                }
+                            }
                         } else {
                             // This case occurs when the component owning `getter` has exited,
                             // but the putter is still running (and sent this message).
                             // we drop the message on the floor, because it cannot be involved
                             // in a solution (requires sending a message over a dead channel!).
                             log!(
                                 cu.logger(),
                                 "Delivery to getter {:?} msg {:?} failed because {:?} isn't here",
                                 getter,
                                 &send_payload_msg,
                                 cid
                             );
+                        }
+                    }
+                }
+            }
             // payload buffer is empty.
             // check if we have a solution yet
             log!(cu.logger(), "Check if we have any local decisions...");
             for solution in rctx.solution_storage.iter_new_local_make_old() {
                 log!(cu.logger(), "New local decision with solution {:?}...", &solution);
                 match comm.neighborhood.parent {
                     Some(parent) => {
                         // Always forward connector-local solutions to my parent
                         // AS they are moved from new->old in solution storage.
                         log!(cu.logger(), "Forwarding to my parent {:?}", parent);
                         let suggestion = Decision::Success(solution);
                         let msg = Msg::CommMsg(CommMsg {
                             round_index: comm.round_index,
                             contents: CommMsgContents::CommCtrl(CommCtrlMsg::Suggest {
                                 suggestion,
                             }),
                         });
                         comm.endpoint_manager.send_to_comms(parent, &msg)?;
+                    }
                     None => {
                         log!(cu.logger(), "No parent. Deciding on solution {:?}", &solution);
                         return Ok(Decision::Success(solution));
+                    }
+                }
+            }
             // stuck! make progress by receiving a msg
             // try recv ONE message arriving through an endpoint
             log!(cu.logger(), "No decision yet. Let's recv an endpoint msg...");
+            {
                 // This is the first call that may block the thread!
                 // Until a message arrives over the network, no new solutions are possible.
                 let (net_index, comm_ctrl_msg): (usize, CommCtrlMsg) =
                     match comm.endpoint_manager.try_recv_any_comms(cu, rctx, comm.round_index)? {
                         CommRecvOk::NewControlMsg { net_index, msg } => (net_index, msg),
                         CommRecvOk::NewPayloadMsgs => {
                             // 1+ speculative payloads have been buffered
                             // but no other control messages that require further handling
                             // restart the loop to process the messages before blocking
                             continue 'undecided;
+                        }
                         CommRecvOk::TimeoutWithoutNew => {
                             log!(cu.logger(), "Reached user-defined deadling without decision...");
                             if let Some(parent) = comm.neighborhood.parent {
                                 if already_requested_failure.replace_with_true() {
                                     Self::request_failure(cu, comm, parent)?
                                 } else {
                                     log!(cu.logger(), "Already requested failure");
+                                }
                             } else {
                                 log!(cu.logger(), "As the leader, deciding on timeout");
                                 return Ok(Decision::Failure);
+                            }
                             // disable future timeout events! our request for failure has been sent
                             // all we can do at this point is wait.
                             rctx.deadline = None;
                             continue 'undecided;
+                        }
                     };
                 // We received a control message that requires further action
                 log!(
                     cu.logger(),
                     "Received from endpoint {} ctrl msg {:?}",
                     net_index,
                     &comm_ctrl_msg
                 );
                 match comm_ctrl_msg {
                     CommCtrlMsg::Suggest { suggestion } => {
                         // We receive the solution of another connector (part of the decision process)
                         // (only accept this through a child endpoint)
                         if comm.neighborhood.children.contains(&net_index) {
                             match suggestion {
                                 Decision::Success(predicate) => {
                                     // child solution contributes to local solution
                                     log!(cu.logger(), "Child provided solution {:?}", &predicate);
                                     let subtree_id = SubtreeId::NetEndpoint { index: net_index };
                                     rctx.solution_storage.submit_and_digest_subtree_solution(
                                         cu, subtree_id, predicate,
                                     );
+                                }
                                 Decision::Failure => {
                                     // Someone timed out! propagate this to parent or decide
                                     match comm.neighborhood.parent {
                                         None => {
                                             log!(cu.logger(), "I decide on my child's failure");
                                             break 'undecided Ok(Decision::Failure);
+                                        }
                                         Some(parent) => {
                                             log!(cu.logger(), "Forwarding failure through my parent endpoint {:?}", parent);
                                             if already_requested_failure.replace_with_true() {
                                                 Self::request_failure(cu, comm, parent)?
                                             } else {
                                                 log!(cu.logger(), "Already requested failure");
+                                            }
+                                        }
+                                    }
+                                }
+                            }
                         } else {
                             // Unreachable if all connectors are playing by the rules.
                             // Silently ignored instead of causing panic to make the
                             // runtime more robust against network fuzz
                             log!(
                                 cu.logger(),
                                 "Discarding suggestion {:?} from non-child endpoint idx {:?}",
                                 &suggestion,
                                 net_index
                             );
+                        }
+                    }
                     CommCtrlMsg::Announce { decision } => {
                         // Apparently this round is over! A decision has been reached
                         if Some(net_index) == comm.neighborhood.parent {
                             // We accept the decision because it comes from our parent.
                             // end this loop, and and the synchronous round
                             return Ok(decision);
                         } else {
                             // Again, unreachable if all connectors are playing by the rules
                             log!(
                                 cu.logger(),
                                 "Discarding announcement {:?} from non-parent endpoint idx {:?}",
                                 &decision,
                                 net_index
                             );
+                        }
+                    }
+                }
+            }
             log!(cu.logger(), "Endpoint msg recv done");
+        }
+    }
     // Send a failure request to my parent in the consensus tree
     fn request_failure(
         cu: &mut impl CuUndecided,
         comm: &mut ConnectorCommunication,
         parent: usize,
     ) -> Result<(), UnrecoverableSyncError> {
         log!(cu.logger(), "Forwarding to my parent {:?}", parent);
         let suggestion = Decision::Failure;
         let msg = Msg::CommMsg(CommMsg {
             round_index: comm.round_index,
             contents: CommMsgContents::CommCtrl(CommCtrlMsg::Suggest { suggestion }),
         });
         comm.endpoint_manager.send_to_comms(parent, &msg)
+    }
+}
 impl NativeBranch {
     fn is_ended(&self) -> bool {
         self.to_get.is_empty()
+    }
+}
 impl BranchingNative {
     // Feed the given payload to the native component
     // May result in discovering new component solutions,
     // or fork speculative branches if the message's predicate
     // is MORE SPECIFIC than the branches of the native
     fn feed_msg(
         &mut self,
         cu: &mut impl CuUndecided,
         rctx: &mut RoundCtx,
         getter: PortId,
         send_payload_msg: &SendPayloadMsg,
         bn_temp: MapTempGuard<'_, Predicate, NativeBranch>,
     ) {
         log!(cu.logger(), "feeding native getter {:?} {:?}", getter, &send_payload_msg);
         assert_eq!(Getter, rctx.ips.port_info.map.get(&getter).unwrap().polarity);
         let mut draining = bn_temp;
         let finished = &mut self.branches;
         std::mem::swap(draining.0, finished);
         // Visit all native's branches, and feed those whose current predicates are
         // consistent with that of the received message.
         for (predicate, mut branch) in draining.drain() {
             log!(cu.logger(), "visiting native branch {:?} with {:?}", &branch, &predicate);
             let var = rctx.ips.port_info.spec_var_for(getter);
             if predicate.query(var) != Some(SpecVal::FIRING) {
                 // optimization. Don't bother trying this branch,
                 // because the resulting branch would have an inconsistent predicate.
                 // the existing branch asserts the getter port is SILENT
                 log!(
                     cu.logger(),
                     "skipping branch with {:?} that doesn't want the message (fastpath)",
                     &predicate
                 );
                 Self::insert_branch_merging(finished, predicate, branch);
                 continue;
+            }
             // Define a little helper closure over `rctx`
             // for feeding the given branch this new payload,
             // and submitting any resulting solutions
             let mut feed_branch = |branch: &mut NativeBranch, predicate: &Predicate| {
                 // This branch notes the getter port as "gotten"
                 branch.to_get.remove(&getter);
                 if let Some(was) = branch.gotten.insert(getter, send_payload_msg.payload.clone()) {
                     // Sanity check. Payload mapping (Predicate,Port) should be unique each round
                     assert_eq!(&was, &send_payload_msg.payload);
+                }
                 if branch.is_ended() {
                     // That was the last message the branch was awaiting!
                     // Submitting new component solution.
                     log!(
                         cu.logger(),
                         "new native solution with {:?} is_ended() with gotten {:?}",
                         &predicate,
                         &branch.gotten
                     );
                     let subtree_id = SubtreeId::LocalComponent(cu.native_component_id());
                     rctx.solution_storage.submit_and_digest_subtree_solution(
                         cu,
                         subtree_id,
                         predicate.clone(),
                     );
                 } else {
                     // This branch still has ports awaiting their messages
                     log!(
                         cu.logger(),
                         "Fed native {:?} still has to_get {:?}",
                         &predicate,
                         &branch.to_get
                     );
+                }
             };
             use AssignmentUnionResult as Aur;
             match predicate.assignment_union(&send_payload_msg.predicate) {
                 Aur::Nonexistant => {
                     // The predicates of this branch and the payload are incompatible
                     // retain this branch as-is
                     log!(
                         cu.logger(),
                         "skipping branch with {:?} that doesn't want the message (slowpath)",
                         &predicate
                     );
                     Self::insert_branch_merging(finished, predicate, branch);
+                }
                 Aur::Equivalent | Aur::FormerNotLatter => {
                     // The branch's existing predicate "covers" (is at least as specific)
                     // as that of the payload. Can feed this branch the message without altering
                     // the branch predicate.
                     feed_branch(&mut branch, &predicate);
                     log!(cu.logger(), "branch pred covers it! Accept the msg");
                     Self::insert_branch_merging(finished, predicate, branch);
+                }
                 Aur::LatterNotFormer => {
                     // The predicates of branch and payload are compatible,
                     // but that of the payload is strictly more specific than that of the latter.
                     // FORK the branch, feed the fork the message, and give it the payload's predicate.
                     let mut branch2 = branch.clone();
                     let predicate2 = send_payload_msg.predicate.clone();
                     feed_branch(&mut branch2, &predicate2);
                     log!(
                         cu.logger(),
                         "payload pred {:?} covers branch pred {:?}",
                         &predicate2,
                         &predicate
                     );
                     Self::insert_branch_merging(finished, predicate, branch);
                     Self::insert_branch_merging(finished, predicate2, branch2);
+                }
                 Aur::New(predicate2) => {
                     // The predicates of branch and payload are compatible,
                     // but their union is some new predicate (both preds assign something new).
                     // FORK the branch, feed the fork the message, and give it the new predicate.
                     let mut branch2 = branch.clone();
                     feed_branch(&mut branch2, &predicate2);
                     log!(
                         cu.logger(),
                         "new subsuming pred created {:?}. forking and feeding",
                         &predicate2
                     );
                     Self::insert_branch_merging(finished, predicate, branch);
                     Self::insert_branch_merging(finished, predicate2, branch2);
+                }
+            }
+        }
+    }
     // Insert a new speculate branch into the given storage,
     // MERGING it with an existing branch if their predicate keys clash.
     fn insert_branch_merging(
         branches: &mut HashMap<Predicate, NativeBranch>,
         predicate: Predicate,
         mut branch: NativeBranch,
     ) {
         let e = branches.entry(predicate);
         use std::collections::hash_map::Entry;
         match e {
             Entry::Vacant(ev) => {
                 // no existing branch present. We insert it no problem. (The most common case)
                 ev.insert(branch);
+            }
             Entry::Occupied(mut eo) => {
                 // Oh dear, there is already a branch with this predicate.
                 // Rather than choosing either branch, we MERGE them.
                 // This means taking the UNION of their .gotten and the INTERSECTION of their .to_get
                 let old = eo.get_mut();
                 for (k, v) in branch.gotten.drain() {
                     if old.gotten.insert(k, v).is_none() {
                         // added a gotten element in `branch` not already in `old`
                         old.to_get.remove(&k);
+                    }
+                }
+            }
+        }
+    }
     // Given the predicate for the round's solution, collapse this
     // branching native to an ended branch whose predicate is consistent with it.
     // return as `RoundEndedNative` the result of a native completing successful round
     fn collapse_with(
         self,
         logger: &mut dyn Logger,
         solution_predicate: &Predicate,
     ) -> RoundEndedNative {
         log!(
             logger,
             "Collapsing native with {} branch preds {:?}",
             self.branches.len(),
             self.branches.keys()
         );
         for (branch_predicate, branch) in self.branches {
             log!(
                 logger,
                 "Considering native branch {:?} with to_get {:?} gotten {:?}",
                 &branch_predicate,
                 &branch.to_get,
                 &branch.gotten
             );
             if branch.is_ended() && branch_predicate.assigns_subset(solution_predicate) {
                 let NativeBranch { index, gotten, .. } = branch;
                 log!(logger, "Collapsed native has gotten {:?}", &gotten);
                 return RoundEndedNative { batch_index: index, gotten };
+            }
+        }
         log!(logger, "Native had no branches matching pred {:?}", solution_predicate);
         panic!("Native had no branches matching pred {:?}", solution_predicate);
+    }
+}
 impl BranchingProtoComponent {
     // Create a singleton-branch branching protocol component as
     // speculation begins, with the given protocol state.
     fn initial(state: ComponentState) -> Self {
         let branch = ProtoComponentBranch { state, inner: Default::default(), ended: false };
         Self { branches: hashmap! { Predicate::default() => branch } }
+    }
     // run all the given branches (cd.input) to their SyncBlocker,
     // populating cd.output by cyclically draining "input" -> "cd."input" / cd.output.
     // (to prevent concurrent r/w of one structure, we realize "input" as cd.input for reading and cd.swap for writing)
     // This procedure might lose branches, and it might create new branches.
     fn drain_branches_to_blocked(
         cd: CyclicDrainer<Predicate, ProtoComponentBranch>,
         cu: &mut impl CuUndecided,
         rctx: &mut RoundCtx,
         proto_component_id: ComponentId,
     ) -> Result<(), UnrecoverableSyncError> {
         // let CyclicDrainer { input, swap, output } = cd;
         while !cd.input.is_empty() {
             'branch_iter: for (mut predicate, mut branch) in cd.input.drain() {
                 let mut ctx = SyncProtoContext {
                     rctx,
                     predicate: &predicate,
                     branch_inner: &mut branch.inner,
                 };
                 // Run this component's state to the next syncblocker for handling
                 let blocker = branch.state.sync_run(&mut ctx, cu.proto_description());
                 log!(
                     cu.logger(),
                     "Proto component with id {:?} branch with pred {:?} hit blocker {:?}",
                     proto_component_id,
                     &predicate,
                     &blocker,
                 );
                 use SyncBlocker as B;
                 match blocker {
                     B::Inconsistent => drop((predicate, branch)), // EXPLICIT inconsistency
                     B::CouldntReadMsg(port) => {
                         // sanity check: `CouldntReadMsg` returned IFF the message is unavailable
                         assert!(!branch.inner.inbox.contains_key(&port));
                         // This branch hit a proper blocker: progress awaits the receipt of some message. Exit the cycle.
                         Self::insert_branch_merging(cd.output, predicate, branch);
+                    }
                     B::CouldntCheckFiring(port) => {
                         // sanity check: `CouldntCheckFiring` returned IFF the variable is speculatively assigned
                         let var = rctx.ips.port_info.spec_var_for(port);
                         assert!(predicate.query(var).is_none());
                         // speculate on the two possible values of `var`. Schedule both branches to be rerun.
                         Self::insert_branch_merging(
                             cd.swap,
                             predicate.clone().inserted(var, SpecVal::SILENT),
                             branch.clone(),
                         );
                         Self::insert_branch_merging(
                             cd.swap,
                             predicate.inserted(var, SpecVal::FIRING),
                             branch,
                         );
+                    }
                     B::PutMsg(putter, payload) => {
                         // sanity check: The given port indeed has `Putter` polarity
                         assert_eq!(Putter, rctx.ips.port_info.map.get(&putter).unwrap().polarity);
                         // assign FIRING to this port's associated firing variable
                         let var = rctx.ips.port_info.spec_var_for(putter);
                         let was = predicate.assigned.insert(var, SpecVal::FIRING);
                         if was == Some(SpecVal::SILENT) {
                             // Discard the branch, as it clearly has contradictory requirements for this value.
                             log!(cu.logger(), "Proto component {:?} tried to PUT on port {:?} when pred said var {:?}==Some(false). inconsistent!",
                             proto_component_id, putter, var);
                             drop((predicate, branch));
                         } else {
                             // Note that this port has put this round,
                             // and assert that this isn't its 2nd time putting this round (otheriwse PDL programming error)
                             assert!(branch.inner.did_put_or_get.insert(putter));
                             log!(cu.logger(), "Proto component {:?} with pred {:?} putting payload {:?} on port {:?} (using var {:?})",
                             proto_component_id, &predicate, &payload, putter, var);
                             // Send the given payload (by buffering it).
                             let msg = SendPayloadMsg { predicate: predicate.clone(), payload };
                             rctx.putter_push(cu, putter, msg);
                             // Branch can still make progress. Schedule to be rerun
                             Self::insert_branch_merging(cd.swap, predicate, branch);
+                        }
+                    }
                     B::SyncBlockEnd => {
                         // This branch reached the end of it's synchronous block
                         // assign all variables of owned ports that DIDN'T fire to SILENT
                         for port in rctx.ips.port_info.ports_owned_by(proto_component_id) {
                             let var = rctx.ips.port_info.spec_var_for(*port);
                             let actually_exchanged = branch.inner.did_put_or_get.contains(port);
                             let val = *predicate.assigned.entry(var).or_insert(SpecVal::SILENT);
                             let speculated_to_fire = val == SpecVal::FIRING;
                             if actually_exchanged != speculated_to_fire {
                                 log!(cu.logger(), "Inconsistent wrt. port {:?} var {:?} val {:?} actually_exchanged={}, speculated_to_fire={}",
                                 port, var, val, actually_exchanged, speculated_to_fire);
                                 // IMPLICIT inconsistency
                                 drop((predicate, branch));
                                 continue 'branch_iter;
+                            }
+                        }
                         // submit solution for this component
                         let subtree_id = SubtreeId::LocalComponent(proto_component_id);
                         rctx.solution_storage.submit_and_digest_subtree_solution(
                             cu,
                             subtree_id,
                             predicate.clone(),
                         );
                         branch.ended = true;
                         // This branch exits the cyclic drain
                         Self::insert_branch_merging(cd.output, predicate, branch);
+                    }
+                }
+            }
             std::mem::swap(cd.input, cd.swap);
+        }
         Ok(())
+    }
     // Feed this branching protocol component the given message, and
     // then run all branches until they are once again blocked.
     fn feed_msg(
         &mut self,
         cu: &mut impl CuUndecided,
         rctx: &mut RoundCtx,
         proto_component_id: ComponentId,
         getter: PortId,
         send_payload_msg: &SendPayloadMsg,
         pcb_temps: MapTempsGuard<'_, Predicate, ProtoComponentBranch>,
     ) -> Result<(), UnrecoverableSyncError> {
         log!(
             cu.logger(),
             "feeding proto component {:?} getter {:?} {:?}",
             proto_component_id,
             getter,
             &send_payload_msg
         );
         let (mut unblocked, pcb_temps) = pcb_temps.split_first_mut();
         let (mut blocked, pcb_temps) = pcb_temps.split_first_mut();
         // partition drain from self.branches -> {unblocked, blocked} (not cyclic)
         log!(cu.logger(), "visiting {} blocked branches...", self.branches.len());
         for (predicate, mut branch) in self.branches.drain() {
             if branch.ended {
                 log!(cu.logger(), "Skipping ended branch with {:?}", &predicate);
                 Self::insert_branch_merging(&mut blocked, predicate, branch);
                 continue;
+            }
             use AssignmentUnionResult as Aur;
             log!(cu.logger(), "visiting branch with pred {:?}", &predicate);
             // We give each branch a chance to receive this message,
             // those that do are maybe UNBLOCKED, and all others remain BLOCKED.
             match predicate.assignment_union(&send_payload_msg.predicate) {
                 Aur::Nonexistant => {
                     // this branch does not receive the message. categorize into blocked.
                     log!(cu.logger(), "skipping branch");
                     Self::insert_branch_merging(&mut blocked, predicate, branch);
+                }
                 Aur::Equivalent | Aur::FormerNotLatter => {
                     // retain the existing predicate, but add this payload
                     log!(cu.logger(), "feeding this branch without altering its predicate");
                     branch.feed_msg(getter, send_payload_msg.payload.clone());
                     // this branch does receive the message. categorize into unblocked.
                     Self::insert_branch_merging(&mut unblocked, predicate, branch);
+                }
                 Aur::LatterNotFormer => {
                     // fork branch, give fork the message and payload predicate. original branch untouched
                     log!(cu.logger(), "Forking this branch, giving it the predicate of the msg");
                     let mut branch2 = branch.clone();
                     let predicate2 = send_payload_msg.predicate.clone();
                     branch2.feed_msg(getter, send_payload_msg.payload.clone());
                     // the branch that receives the message is unblocked, the original one is blocked
                     Self::insert_branch_merging(&mut blocked, predicate, branch);
                     Self::insert_branch_merging(&mut unblocked, predicate2, branch2);
+                }
                 Aur::New(predicate2) => {
                     // fork branch, give fork the message and the new predicate. original branch untouched
                     log!(cu.logger(), "Forking this branch with new predicate {:?}", &predicate2);
                     let mut branch2 = branch.clone();
                     branch2.feed_msg(getter, send_payload_msg.payload.clone());
                     // the branch that receives the message is unblocked, the original one is blocked
                     Self::insert_branch_merging(&mut blocked, predicate, branch);
                     Self::insert_branch_merging(&mut unblocked, predicate2, branch2);
+                }
+            }
+        }
         log!(cu.logger(), "blocked {:?} unblocked {:?}", blocked.len(), unblocked.len());
         // drain from unblocked --> blocked
         let (swap, _pcb_temps) = pcb_temps.split_first_mut(); // peel off ONE temp storage map
         let cd = CyclicDrainer { input: unblocked.0, swap: swap.0, output: blocked.0 };
         BranchingProtoComponent::drain_branches_to_blocked(cd, cu, rctx, proto_component_id)?;
         // swap the blocked branches back
         std::mem::swap(blocked.0, &mut self.branches);
         log!(cu.logger(), "component settles down with branches: {:?}", self.branches.keys());
         Ok(())
+    }
     // Insert a new speculate branch into the given storage,
     // MERGING it with an existing branch if their predicate keys clash.
     fn insert_branch_merging(
         branches: &mut HashMap<Predicate, ProtoComponentBranch>,
         predicate: Predicate,
         mut branch: ProtoComponentBranch,
     ) {
         let e = branches.entry(predicate);
         use std::collections::hash_map::Entry;
         match e {
             Entry::Vacant(ev) => {
                 // no existing branch present. We insert it no problem. (The most common case)
                 ev.insert(branch);
+            }
             Entry::Occupied(mut eo) => {
                 // Oh dear, there is already a branch with this predicate.
                 // Rather than choosing either branch, we MERGE them.
                 // This means keeping the existing one in-place, and giving it the UNION of the inboxes
                 let old = eo.get_mut();
                 for (k, v) in branch.inner.inbox.drain() {
                     old.inner.inbox.insert(k, v);
+                }
+            }
+        }
+    }
     // Given the predicate for the round's solution, collapse this
     // branching native to an ended branch whose predicate is consistent with it.
     fn collapse_with(
         self,
         logger: &mut dyn Logger,
         solution_predicate: &Predicate,
     ) -> ComponentState {
         let BranchingProtoComponent { branches } = self;
         for (branch_predicate, branch) in branches {
             if branch.ended && branch_predicate.assigns_subset(solution_predicate) {
                 let ProtoComponentBranch { state, .. } = branch;
                 return state;
+            }
+        }
         log!(logger, "ProtoComponent had no branches matching pred {:?}", solution_predicate);
         panic!("ProtoComponent had no branches matching pred {:?}", solution_predicate);
+    }
+}
 impl ProtoComponentBranch {
     // Feed this branch received message.
     // It's safe to receive the same message repeatedly,
     // but if we receive a message with different contents,
     // it's a sign something has gone wrong! keys of type (port, round, predicate)
     // should always map to at most one message value!
     fn feed_msg(&mut self, getter: PortId, payload: Payload) {
         let e = self.inner.inbox.entry(getter);
         use std::collections::hash_map::Entry;
         match e {
             Entry::Vacant(ev) => {
                 // new message
                 ev.insert(payload);
+            }
             Entry::Occupied(eo) => {
                 // redundant recv. can happen as a result of a
                 // component A having two branches X and Y related by
                 assert_eq!(eo.get(), &payload);
+            }
+        }
+    }
+}
 impl SolutionStorage {
     // Create a new solution storage, to manage the local solutions for
     // this connector and all of it's children (subtrees) in the solution tree.
     fn new(subtree_ids: impl Iterator<Item = SubtreeId>) -> Self {
         // For easy iteration, we store this SubtreeId => {Predicate}
         // structure instead as a pair of structures: a vector of predicate sets,
         // and a subtree_id-to-index lookup map
         let mut subtree_id_to_index: HashMap<SubtreeId, usize> = Default::default();
         let mut subtree_solutions = vec![];
         for id in subtree_ids {
             subtree_id_to_index.insert(id, subtree_solutions.len());
             subtree_solutions.push(Default::default())
+        }
         // new_local U old_local represents the solutions of this connector itself:
         // namely, those that can be created from the union of one element from each child's solution set.
         // The difference between new and old is that new stores those NOT YET sent over the network
         // to this connector's parent in the solution tree.
         // invariant: old_local and new_local have an empty intersection
         Self {
             subtree_solutions,
             subtree_id_to_index,
             old_local: Default::default(),
             new_local: Default::default(),
+        }
+    }
     // drain old_local to new_local, visiting all new additions to old_local
     pub(crate) fn iter_new_local_make_old(&mut self) -> impl Iterator<Item = Predicate> + '_ {
         let Self { old_local, new_local, .. } = self;
         new_local.drain().map(move |local| {
             // rely on invariant: empty intersection between old and new local sets
             assert!(old_local.insert(local.clone()));
             local
         })
+    }
     // insert a solution for the given subtree ID,
     // AND update new_local to include any solutions that become
     // possible as a result of this new addition
     pub(crate) fn submit_and_digest_subtree_solution(
         &mut self,
         cu: &mut impl CuUndecided,
         subtree_id: SubtreeId,
         predicate: Predicate,
     ) {
         log!(cu.logger(), "++ new component solution {:?} {:?}", subtree_id, &predicate);
         let Self { subtree_solutions, new_local, old_local, subtree_id_to_index } = self;
         let index = subtree_id_to_index[&subtree_id];
         let was_new = subtree_solutions[index].insert(predicate.clone());
         if was_new {
             // This is a newly-added solution! update new_local
             // consider ALL consistent combinations of one element from each solution set
             // to our right or left in the solution-set vector
             // but with THIS PARTICULAR predicate from our own index.
             let left = 0..index;
             let right = (index + 1)..subtree_solutions.len();
             // iterator over SETS of solutions, one for every component except `subtree_id` (me)
             let set_visitor = left.chain(right).map(|index| &subtree_solutions[index]);
             // Recursively enumerate all solutions matching the description above,
             Self::elaborate_into_new_local_rec(cu, predicate, set_visitor, old_local, new_local);
+        }
+    }
     // Recursively build local solutions for this connector,
     // see `submit_and_digest_subtree_solution`
     fn elaborate_into_new_local_rec<'a, 'b>(
         cu: &mut impl CuUndecided,
         partial: Predicate,
         mut set_visitor: impl Iterator<Item = &'b HashSet<Predicate>> + Clone,
         old_local: &'b HashSet<Predicate>,
         new_local: &'a mut HashSet<Predicate>,
     ) {
         if let Some(set) = set_visitor.next() {
             // incomplete solution. keep recursively creating combined solutions
             for pred in set.iter() {
                 if let Some(elaborated) = pred.union_with(&partial) {
                     Self::elaborate_into_new_local_rec(
                         cu,
                         elaborated,
                         set_visitor.clone(),
                         old_local,
                         new_local,
+                    )
+                }
+            }
         } else {
             // recursive stop condition. This is a solution for this connector...
             if !old_local.contains(&partial) {
                 // ... and it hasn't been found before
                 log!(cu.logger(), "storing NEW LOCAL SOLUTION {:?}", &partial);
                 new_local.insert(partial);
+            }
+        }
+    }
+}
 impl NonsyncProtoContext<'_> {
     // Facilitates callback from the component to the connector runtime,
     // creating a new component and changing the given port's ownership to that
     // of the new component.
     pub(crate) fn new_component(&mut self, moved_ports: HashSet<PortId>, state: ComponentState) {
         // Sanity check! The moved ports are owned by this component to begin with
         for port in moved_ports.iter() {
             assert_eq!(self.proto_component_id, self.ips.port_info.map.get(port).unwrap().owner);
+        }
         // Create the new component, and schedule it to be run
         let new_cid = self.ips.id_manager.new_component_id();
         log!(
             self.logger,
             "Component {:?} added new component {:?} with state {:?}, moving ports {:?}",
             self.proto_component_id,
             new_cid,
             &state,
             &moved_ports
         );
         self.unrun_components.push((new_cid, state));
         // Update the ownership of the moved ports
         for port in moved_ports.iter() {
             self.ips.port_info.map.get_mut(port).unwrap().owner = new_cid;
+        }
         if let Some(set) = self.ips.port_info.owned.get_mut(&self.proto_component_id) {
             set.retain(|x| !moved_ports.contains(x));
+        }
         self.ips.port_info.owned.insert(new_cid, moved_ports.clone());
+    }
     // Facilitates callback from the component to the connector runtime,
     // creating a new port-pair connected by an memory channel
     pub(crate) fn new_port_pair(&mut self) -> [PortId; 2] {
         // adds two new associated ports, related to each other, and exposed to the proto component
         let mut new_cid_fn = || self.ips.id_manager.new_port_id();
         let [o, i] = [new_cid_fn(), new_cid_fn()];
         self.ips.port_info.map.insert(
             o,
             PortInfo {
                 route: Route::LocalComponent,
                 peer: Some(i),
                 polarity: Putter,
                 owner: self.proto_component_id,
             },
         );
         self.ips.port_info.map.insert(
             i,
             PortInfo {
                 route: Route::LocalComponent,
                 peer: Some(o),
                 polarity: Getter,
                 owner: self.proto_component_id,
             },
         );
         self.ips
             .port_info
             .owned
             .entry(self.proto_component_id)
             .or_default()
             .extend([o, i].iter().copied());
         log!(
             self.logger,
             "Component {:?} port pair (out->in) {:?} -> {:?}",
             self.proto_component_id,
             o,
+            i
         );
         [o, i]
+    }
+}
 impl SyncProtoContext<'_> {
     // The component calls the runtime back, inspecting whether it's associated
     // preidcate has already determined a (speculative) value for the given port's firing variable.
     pub(crate) fn is_firing(&mut self, port: PortId) -> Option<bool> {
         let var = self.rctx.ips.port_info.spec_var_for(port);
         self.predicate.query(var).map(SpecVal::is_firing)
+    }
     pub(crate) fn did_put_or_get(&mut self, port: PortId) -> bool {
         self.branch_inner.did_put_or_get.contains(&port)
+    }
     // The component calls the runtime back, trying to inspect a port's message
     pub(crate) fn read_msg(&mut self, port: PortId) -> Option<&Payload> {
         let maybe_msg = self.branch_inner.inbox.get(&port);
         if maybe_msg.is_some() {
             // Make a note that this component has received
             // this port's message 1+ times this round
             self.branch_inner.did_put_or_get.insert(port);
+        }
         maybe_msg
+    }
+}

src/runtime/mod.rs

➞

Show inline comments

 /// cbindgen:ignore
 mod communication;
 /// cbindgen:ignore
 mod endpoints;
 pub mod error;
 /// cbindgen:ignore
 mod logging;
 /// cbindgen:ignore
 mod setup;
 #[cfg(test)]
 mod tests;
 use crate::common::*;
 use error::*;
 use mio::net::UdpSocket;
 /// The interface between the user's application and a communication session,
 /// in which the application plays the part of a (native) component. This structure provides the application
 /// with functionality available to all components: the ability to add new channels (port pairs), and to
 /// instantiate new components whose definitions are defined in the connector's configured protocol
 /// description. Native components have the additional ability to add `dangling' ports backed by local/remote
 /// IP addresses, to be coupled with a counterpart once the connector's setup is completed by `connect`.
 /// This allows sets of applications to cooperate in constructing shared sessions that span the network.
 #[derive(Debug)]
 pub struct Connector {
     unphased: ConnectorUnphased,
     phased: ConnectorPhased,
+}
 /// Characterizes a type which can write lines of logging text.
 /// The implementations provided in the `logging` module are likely to be sufficient,
 /// but for added flexibility, users are able to implement their own loggers for use
 /// by connectors.
 pub trait Logger: Debug + Send + Sync {
     fn line_writer(&mut self) -> Option<&mut dyn std::io::Write>;
+}
 /// A logger that appends the logged strings to a growing byte buffer
 #[derive(Debug)]
 pub struct VecLogger(ConnectorId, Vec<u8>);
 /// A trivial logger that always returns None, such that no logging information is ever written.
 #[derive(Debug)]
 pub struct DummyLogger;
 /// A logger that writes the logged lines to a given file.
 #[derive(Debug)]
 pub struct FileLogger(ConnectorId, std::fs::File);
 // Interface between protocol state and the connector runtime BEFORE all components
 // ave begun their branching speculation. See ComponentState::nonsync_run.
 pub(crate) struct NonsyncProtoContext<'a> {
     ips: &'a mut IdAndPortState,
     logger: &'a mut dyn Logger,
     unrun_components: &'a mut Vec<(ComponentId, ComponentState)>, // lives for Nonsync phase
     proto_component_id: ComponentId,                              // KEY in id->component map
+}
 // Interface between protocol state and the connector runtime AFTER all components
 // have begun their branching speculation. See ComponentState::sync_run.
 pub(crate) struct SyncProtoContext<'a> {
     rctx: &'a RoundCtx,
     branch_inner: &'a mut ProtoComponentBranchInner, // sub-structure of component branch
     predicate: &'a Predicate,                        // KEY in pred->branch map
+}
 // The data coupled with a particular protocol component branch, but crucially omitting
 // the `ComponentState` such that this may be passed by reference to the state with separate
 // access control.
 #[derive(Default, Debug, Clone)]
 struct ProtoComponentBranchInner {
     did_put_or_get: HashSet<PortId>,
     inbox: HashMap<PortId, Payload>,
+}
 // A speculative variable that lives for the duration of the synchronous round.
 // Each is assigned a value in domain `SpecVal`.
 #[derive(
     Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd, serde::Serialize, serde::Deserialize,
 )]
 struct SpecVar(PortId);
 // The codomain of SpecVal. Has two associated constants for values FIRING and SILENT,
 // but may also enumerate many more values to facilitate finer-grained nondeterministic branching.
 #[derive(
     Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd, serde::Serialize, serde::Deserialize,
 )]
 struct SpecVal(u16);
 // Data associated with a successful synchronous round, retained afterwards such that the
 // native component can freely reflect on how it went, reading the messages received at their
 // inputs, and reflecting on which of their connector's synchronous batches succeeded.
 #[derive(Debug)]
 struct RoundEndedNative {
     batch_index: usize,
     gotten: HashMap<PortId, Payload>,
+}
 // Implementation of a set in terms of a vector (optimized for reading, not writing)
 #[derive(Default)]
 struct VecSet<T: std::cmp::Ord> {
     // invariant: ordered, deduplicated
     vec: Vec<T>,
+}
 // Allows a connector to remember how to forward payloads towards the component that
 // owns their destination port. `LocalComponent` corresponds with messages for components
 // managed by the connector itself (hinting for it to look it up in a local structure),
 // whereas the other variants direct the connector to forward the messages over the network.
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)]
 enum Route {
     LocalComponent,
     NetEndpoint { index: usize },
     UdpEndpoint { index: usize },
+}
 // The outcome of a synchronous round, representing the distributed consensus.
 // In the success case, the attached predicate encodes a row in the session's trace table.
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 enum Decision {
     Failure, // some connector timed out!
     Success(Predicate),
+}
 // The type of control messages exchanged between connectors over the network
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 enum Msg {
     SetupMsg(SetupMsg),
     CommMsg(CommMsg),
+}
 // Control messages exchanged during the setup phase only
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 enum SetupMsg {
     MyPortInfo(MyPortInfo),
     LeaderWave { wave_leader: ConnectorId },
     LeaderAnnounce { tree_leader: ConnectorId },
     YouAreMyParent,
     SessionGather { unoptimized_map: HashMap<ConnectorId, SessionInfo> },
     SessionScatter { optimized_map: HashMap<ConnectorId, SessionInfo> },
+}
 // A data structure encoding the state of a connector, passed around
 // during the session optimization procedure.
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 struct SessionInfo {
     serde_proto_description: SerdeProtocolDescription,
     port_info: PortInfoMap,
     endpoint_incoming_to_getter: Vec<PortId>,
     proto_components: HashMap<ComponentId, ComponentState>,
+}
 // Newtype wrapper for an Arc<ProtocolDescription>,
 // such that it can be (de)serialized for transmission over the network.
 #[derive(Debug, Clone)]
 struct SerdeProtocolDescription(Arc<ProtocolDescription>);
 // Control message particular to the communication phase.
 // as such, it's annotated with a round_index
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 struct CommMsg {
     round_index: usize,
     contents: CommMsgContents,
+}
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 enum CommMsgContents {
     SendPayload(SendPayloadMsg),
     CommCtrl(CommCtrlMsg),
+}
 // Connector <-> connector control messages for use in the communication phase
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 enum CommCtrlMsg {
     Suggest { suggestion: Decision }, // child->parent
     Announce { decision: Decision },  // parent->child
+}
 // Speculative payload message, communicating the value for the given
 // port's message predecated on the given speculative variable assignments.
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 struct SendPayloadMsg {
     predicate: Predicate,
     payload: Payload,
+}
 // Return result of `Predicate::assignment_union`, communicating the contents
 // of the predicate which represents the (consistent) union of their mappings,
 // if it exists (no variable mapped distinctly by the input predicates)
 #[derive(Debug, PartialEq)]
 enum AssignmentUnionResult {
     FormerNotLatter,
     LatterNotFormer,
     Equivalent,
     New(Predicate),
     Nonexistant,
+}
 // One of two endpoints for a control channel with a connector on either end.
 // The underlying transport is TCP, so we use an inbox buffer to allow
 // discrete payload receipt.
 struct NetEndpoint {
     inbox: Vec<u8>,
     stream: TcpStream,
+}
 // Datastructure used during the setup phase representing a NetEndpoint TO BE SETUP
 #[derive(Debug, Clone)]
 struct NetEndpointSetup {
     getter_for_incoming: PortId,
     sock_addr: SocketAddr,
     endpoint_polarity: EndpointPolarity,
+}
 // Datastructure used during the setup phase representing a UdpEndpoint TO BE SETUP
 #[derive(Debug, Clone)]
 struct UdpEndpointSetup {
     getter_for_incoming: PortId,
     local_addr: SocketAddr,
     peer_addr: SocketAddr,
+}
 // NetEndpoint annotated with the ID of the port that receives payload
 // messages received through the endpoint. This approach assumes that NetEndpoints
 // DO NOT multiplex port->port channels, and so a mapping such as this is possible.
 // As a result, the messages themselves don't need to carry the PortID with them.
 #[derive(Debug)]
 struct NetEndpointExt {
     net_endpoint: NetEndpoint,
     getter_for_incoming: PortId,
+}
 // Endpoint for a "raw" UDP endpoint. Corresponds to the "Udp Mediator Component"
 // described in the literature.
 // It acts as an endpoint by receiving messages via the poller etc. (managed by EndpointManager),
 // It acts as a native component by managing a (speculative) set of payload messages (an outbox,
 //  protecting the peer on the other side of the network).
 #[derive(Debug)]
 struct UdpEndpointExt {
     sock: UdpSocket, // already bound and connected
     received_this_round: bool,
     outgoing_payloads: HashMap<Predicate, Payload>,
     getter_for_incoming: PortId,
+}
 // Meta-data for the connector: its role in the consensus tree.
 #[derive(Debug)]
 struct Neighborhood {
     parent: Option<usize>,
     children: VecSet<usize>,
+}
 // Manages the connector's ID, and manages allocations for connector/port IDs.
 #[derive(Debug, Clone)]
 struct IdManager {
     connector_id: ConnectorId,
     port_suffix_stream: U32Stream,
     component_suffix_stream: U32Stream,
+}
 // Newtype wrapper around a byte buffer, used for UDP mediators to receive incoming datagrams.
 struct IoByteBuffer {
     byte_vec: Vec<u8>,
+}
 // A generator of speculative variables. Created on-demand during the synchronous round
 // by the IdManager.
 #[derive(Debug)]
 struct SpecVarStream {
     connector_id: ConnectorId,
     port_suffix_stream: U32Stream,
+}
 // Manages the messy state of the various endpoints, pollers, buffers, etc.
 #[derive(Debug)]
 struct EndpointManager {
     // invariants:
     // 1. net and udp endpoints are registered with poll with tokens computed with TargetToken::into
     // 2. Events is empty
     poll: Poll,
     events: Events,
     delayed_messages: Vec<(usize, Msg)>,
     undelayed_messages: Vec<(usize, Msg)>, // ready to yield
     net_endpoint_store: EndpointStore<NetEndpointExt>,
     udp_endpoint_store: EndpointStore<UdpEndpointExt>,
     io_byte_buffer: IoByteBuffer,
+}
 // A storage of endpoints, which keeps track of which components have raised
 // an event during poll(), signifying that they need to be checked for new incoming data
 #[derive(Debug)]
 struct EndpointStore<T> {
     endpoint_exts: Vec<T>,
     polled_undrained: VecSet<usize>,
+}
 // The information associated with a port identifier, designed for local storage.
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 struct PortInfo {
     owner: ComponentId,
     peer: Option<PortId>,
     polarity: Polarity,
     route: Route,
+}
 // Similar to `PortInfo`, but designed for communication during the setup procedure.
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 struct MyPortInfo {
     polarity: Polarity,
     port: PortId,
     owner: ComponentId,
+}
 // Newtype around port info map, allowing the implementation of some
 // useful methods
 #[derive(Default, Debug, Clone, serde::Serialize, serde::Deserialize)]
 struct PortInfoMap {
     // invariant: self.invariant_preserved()
     // `owned` is redundant information, allowing for fast lookup
     // of a component's owned ports (which occurs during the sync round a lot)
     map: HashMap<PortId, PortInfo>,
     owned: HashMap<ComponentId, HashSet<PortId>>,
+}
 // A convenient substructure for containing port info and the ID manager.
 // Houses the bulk of the connector's persistent state between rounds.
 // It turns out several situations require access to both things.
 #[derive(Debug, Clone)]
 struct IdAndPortState {
     port_info: PortInfoMap,
     id_manager: IdManager,
+}
 // A component's setup-phase-specific data
 #[derive(Debug)]
 struct ConnectorCommunication {
     round_index: usize,
     endpoint_manager: EndpointManager,
     neighborhood: Neighborhood,
     native_batches: Vec<NativeBatch>,
     round_result: Result<Option<RoundEndedNative>, SyncError>,
+}
 // A component's data common to both setup and communication phases
 #[derive(Debug)]
 struct ConnectorUnphased {
     proto_description: Arc<ProtocolDescription>,
     proto_components: HashMap<ComponentId, ComponentState>,
     logger: Box<dyn Logger>,
     ips: IdAndPortState,
     native_component_id: ComponentId,
+}
 // A connector's phase-specific data
 #[derive(Debug)]
 enum ConnectorPhased {
     Setup(Box<ConnectorSetup>),
     Communication(Box<ConnectorCommunication>),
+}
 // A connector's setup-phase-specific data
 #[derive(Debug)]
 struct ConnectorSetup {
     net_endpoint_setups: Vec<NetEndpointSetup>,
     udp_endpoint_setups: Vec<UdpEndpointSetup>,
+}
 // A newtype wrapper for a map from speculative variable to speculative value
 // A missing mapping corresponds with "unspecified".
 #[derive(Default, Clone, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)]
 struct Predicate {
     assigned: BTreeMap<SpecVar, SpecVal>,
+}
 // Identifies a child of this connector in the _solution tree_.
 // Each connector creates its own local solutions for the consensus procedure during `sync`,
 // from the solutions of its children. Those children are either locally-managed components,
 // (which are leaves in the solution tree), or other connectors reachable through the given
 // network endpoint (which are internal nodes in the solution tree).
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)]
 enum SubtreeId {
     LocalComponent(ComponentId),
     NetEndpoint { index: usize },
+}
 // An accumulation of the connector's knowledge of all (a) the local solutions its children
 // in the solution tree have found, and (b) its own solutions derivable from those of its children.
 // This structure starts off each round with an empty set, and accumulates solutions as they are found
 // by local components, or received over the network in control messages.
 // IMPORTANT: solutions, once found, don't go away until the end of the round. That is to
 // say that these sets GROW until the round is over, and all solutions are reset.
 #[derive(Debug)]
 struct SolutionStorage {
     // invariant: old_local U new_local solutions are those that can be created from
     // the UNION of one element from each set in `subtree_solution`.
     // invariant is maintained by potentially populating new_local whenever subtree_solutions is populated.
     old_local: HashSet<Predicate>, // already sent to this connector's parent OR decided
     new_local: HashSet<Predicate>, // not yet sent to this connector's parent OR decided
     // this pair acts as SubtreeId -> HashSet<Predicate> which is friendlier to iteration
     subtree_solutions: Vec<HashSet<Predicate>>,
     subtree_id_to_index: HashMap<SubtreeId, usize>,
+}
 // Stores the transient data of a synchronous round.
 // Some of it is for bookkeeping, and the rest is a temporary mirror of fields of
 // `ConnectorUnphased`, such that any changes are safely contained within RoundCtx,
 // and can be undone if the round fails.
 struct RoundCtx {
     solution_storage: SolutionStorage,
     spec_var_stream: SpecVarStream,
     payload_inbox: Vec<(PortId, SendPayloadMsg)>,
     deadline: Option<Instant>,
     ips: IdAndPortState,
+}
 // A trait intended to limit the access of the ConnectorUnphased structure
 // such that we don't accidentally modify any important component/port data
 // while the results of the round are undecided. Why? Any actions during Connector::sync
 // are _speculative_ until the round is decided, and we need a safe way of rolling
 // back any changes.
 trait CuUndecided {
     fn logger(&mut self) -> &mut dyn Logger;
     fn proto_description(&self) -> &ProtocolDescription;
     fn native_component_id(&self) -> ComponentId;
     fn logger_and_protocol_description(&mut self) -> (&mut dyn Logger, &ProtocolDescription);
     fn logger_and_protocol_components(
         &mut self,
     ) -> (&mut dyn Logger, &mut HashMap<ComponentId, ComponentState>);
+}
 // Represents a set of synchronous port operations that the native component
 // has described as an "option" for completing during the synchronous rounds.
 // Operations contained here succeed together or not at all.
 // A native with N=2+ batches are expressing an N-way nondeterministic choice
 #[derive(Debug, Default)]
 struct NativeBatch {
     // invariant: putters' and getters' polarities respected
     to_put: HashMap<PortId, Payload>,
     to_get: HashSet<PortId>,
+}
 // Parallels a mio::Token type, but more clearly communicates
 // the way it identifies the evented structre it corresponds to.
 // See runtime/setup for methods converting between TokenTarget and mio::Token
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 enum TokenTarget {
     NetEndpoint { index: usize },
     UdpEndpoint { index: usize },
+}
 // Returned by the endpoint manager as a result of comm_recv, telling the connector what happened,
 // such that it can know when to continue polling, and when to block.
 enum CommRecvOk {
     TimeoutWithoutNew,
     NewPayloadMsgs,
     NewControlMsg { net_index: usize, msg: CommCtrlMsg },
+}
 ////////////////
 fn err_would_block(err: &std::io::Error) -> bool {
     err.kind() == std::io::ErrorKind::WouldBlock
+}
 impl<T: std::cmp::Ord> VecSet<T> {
     fn new(mut vec: Vec<T>) -> Self {
         // establish the invariant
         vec.sort();
         vec.dedup();
         Self { vec }
+    }
     fn contains(&self, element: &T) -> bool {
         self.vec.binary_search(element).is_ok()
+    }
     // Insert the given element. Returns whether it was already present.
     fn insert(&mut self, element: T) -> bool {
         match self.vec.binary_search(&element) {
             Ok(_) => false,
             Err(index) => {
                 self.vec.insert(index, element);
                 true
+            }
+        }
+    }
     fn iter(&self) -> std::slice::Iter<T> {
         self.vec.iter()
+    }
     fn pop(&mut self) -> Option<T> {
         self.vec.pop()
+    }
+}
 impl PortInfoMap {
     fn ports_owned_by(&self, owner: ComponentId) -> impl Iterator<Item = &PortId> {
         self.owned.get(&owner).into_iter().flat_map(HashSet::iter)
+    }
     fn spec_var_for(&self, port: PortId) -> SpecVar {
         // Every port maps to a speculative variable
         // Two distinct ports map to the same variable
         // IFF they are two ends of the same logical channel.
         let info = self.map.get(&port).unwrap();
         SpecVar(match info.polarity {
             Getter => port,
             Putter => info.peer.unwrap(),
         })
+    }
     fn invariant_preserved(&self) -> bool {
         // for every port P with some owner O,
         // P is in O's owned set
         for (port, info) in self.map.iter() {
             match self.owned.get(&info.owner) {
                 Some(set) if set.contains(port) => {}
                 _ => {
                     println!("{:#?}\n WITH port {:?}", self, port);
                     return false;
+                }
+            }
+        }
         // for every port P owned by every owner O,
         // P's owner is O
         for (&owner, set) in self.owned.iter() {
             for port in set {
                 match self.map.get(port) {
                     Some(info) if info.owner == owner => {}
                     _ => {
                         println!("{:#?}\n WITH owner {:?} port {:?}", self, owner, port);
                         return false;
+                    }
+                }
+            }
+        }
         true
+    }
+}
 impl SpecVarStream {
     fn next(&mut self) -> SpecVar {
         let phantom_port: PortId =
             Id { connector_id: self.connector_id, u32_suffix: self.port_suffix_stream.next() }
                 .into();
         SpecVar(phantom_port)
+    }
+}
 impl IdManager {
     fn new(connector_id: ConnectorId) -> Self {
         Self {
             connector_id,
             port_suffix_stream: Default::default(),
             component_suffix_stream: Default::default(),
+        }
+    }
     fn new_spec_var_stream(&self) -> SpecVarStream {
         // Spec var stream starts where the current port_id stream ends, with gap of SKIP_N.
         // This gap is entirely unnecessary (i.e. 0 is fine)
         // It's purpose is only to make SpecVars easier to spot in logs.
         // E.g. spot the spec var: { v0_0, v1_2, v1_103 }
         const SKIP_N: u32 = 100;
         let port_suffix_stream = self.port_suffix_stream.clone().n_skipped(SKIP_N);
         SpecVarStream { connector_id: self.connector_id, port_suffix_stream }
+    }
     fn new_port_id(&mut self) -> PortId {
         Id { connector_id: self.connector_id, u32_suffix: self.port_suffix_stream.next() }.into()
+    }
     fn new_component_id(&mut self) -> ComponentId {
         Id { connector_id: self.connector_id, u32_suffix: self.component_suffix_stream.next() }
             .into()
+    }
+}
 impl Drop for Connector {
     fn drop(&mut self) {
         log!(self.unphased.logger(), "Connector dropping. Goodbye!");
+    }
+}
 // Given a slice of ports, return the first, if any, port is present repeatedly
 fn duplicate_port(slice: &[PortId]) -> Option<PortId> {
     let mut vec = Vec::with_capacity(slice.len());
     for port in slice.iter() {
         match vec.binary_search(port) {
             Err(index) => vec.insert(index, *port),
             Ok(_) => return Some(*port),
+        }
+    }
     None
+}
 impl Connector {
     /// Generate a random connector identifier from the system's source of randomness.
     pub fn random_id() -> ConnectorId {
         type Bytes8 = [u8; std::mem::size_of::<ConnectorId>()];
         unsafe {
             let mut bytes = std::mem::MaybeUninit::<Bytes8>::uninit();
             // getrandom is the canonical crate for a small, secure rng
             getrandom::getrandom(&mut *bytes.as_mut_ptr()).unwrap();
             // safe! representations of all valid Byte8 values are valid ConnectorId values
             std::mem::transmute::<_, _>(bytes.assume_init())
+        }
+    }
     /// Returns true iff the connector is in connected state, i.e., it's setup phase is complete,
     /// and it is ready to participate in synchronous rounds of communication.
     pub fn is_connected(&self) -> bool {
         // If designed for Rust usage, connectors would be exposed as an enum type from the start.
         // consequently, this "phased" business would also include connector variants and this would
         // get a lot closer to the connector impl. itself.
         // Instead, the C-oriented implementation doesn't distinguish connector states as types,
         // and distinguish them as enum variants instead
         match self.phased {
             ConnectorPhased::Setup(..) => false,
             ConnectorPhased::Communication(..) => true,
+        }
+    }
     /// Enables the connector's current logger to be swapped out for another
     pub fn swap_logger(&mut self, mut new_logger: Box<dyn Logger>) -> Box<dyn Logger> {
         std::mem::swap(&mut self.unphased.logger, &mut new_logger);
         new_logger
+    }
     /// Access the connector's current logger
     pub fn get_logger(&mut self) -> &mut dyn Logger {
         &mut *self.unphased.logger
+    }
     /// Create a new synchronous channel, returning its ends as a pair of ports,
     /// with polarity output, input respectively. Available during either setup/communication phase.
     /// # Panics
     /// This function panics if the connector's (large) port id space is exhausted.
     pub fn new_port_pair(&mut self) -> [PortId; 2] {
         let cu = &mut self.unphased;
         // adds two new associated ports, related to each other, and exposed to the native
         let mut new_cid = || cu.ips.id_manager.new_port_id();
         // allocate two fresh port identifiers
         let [o, i] = [new_cid(), new_cid()];
         // store info for each:
         // - they are each others' peers
         // - they are owned by a local component with id `cid`
         // - polarity putter, getter respectively
         cu.ips.port_info.map.insert(
             o,
             PortInfo {
                 route: Route::LocalComponent,
                 peer: Some(i),
                 owner: cu.native_component_id,
                 polarity: Putter,
             },
         );
         cu.ips.port_info.map.insert(
             i,
             PortInfo {
                 route: Route::LocalComponent,
                 peer: Some(o),
                 owner: cu.native_component_id,
                 polarity: Getter,
             },
         );
         cu.ips
             .port_info
             .owned
             .entry(cu.native_component_id)
             .or_default()
             .extend([o, i].iter().copied());
         log!(cu.logger, "Added port pair (out->in) {:?} -> {:?}", o, i);
         [o, i]
+    }
     /// Instantiates a new component for the connector runtime to manage, and passing
     /// the given set of ports from the interface of the native component, to that of the
     /// newly created component (passing their ownership).
     /// # Errors
     /// Error is returned if the moved ports are not owned by the native component,
     /// if the given component name is not defined in the connector's protocol,
     /// the given sequence of ports contains a duplicate port,
     /// or if the component is unfit for instantiation with the given port sequence.
     /// # Panics
     /// This function panics if the connector's (large) component id space is exhausted.
     pub fn add_component(
         &mut self,
         identifier: &[u8],
         ports: &[PortId],
     ) -> Result<(), AddComponentError> {
         // Check for error cases first before modifying `cu`
         use AddComponentError as Ace;
         let cu = &self.unphased;
         if let Some(port) = duplicate_port(ports) {
             return Err(Ace::DuplicatePort(port));
+        }
         let expected_polarities = cu.proto_description.component_polarities(identifier)?;
         if expected_polarities.len() != ports.len() {
             return Err(Ace::WrongNumberOfParamaters { expected: expected_polarities.len() });
+        }
         for (&expected_polarity, &port) in expected_polarities.iter().zip(ports.iter()) {
             let info = cu.ips.port_info.map.get(&port).ok_or(Ace::UnknownPort(port))?;
             if info.owner != cu.native_component_id {
                 return Err(Ace::UnknownPort(port));
+            }
             if info.polarity != expected_polarity {
                 return Err(Ace::WrongPortPolarity { port, expected_polarity });
+            }
+        }
         // No errors! Time to modify `cu`
         // create a new component and identifier
         let Connector { phased, unphased: cu } = self;
         let new_cid = cu.ips.id_manager.new_component_id();
         cu.proto_components.insert(new_cid, cu.proto_description.new_component(identifier, ports));
         // update the ownership of moved ports
         for port in ports.iter() {
             match cu.ips.port_info.map.get_mut(port) {
                 Some(port_info) => port_info.owner = new_cid,
                 None => unreachable!(),
+            }
+        }
         if let Some(set) = cu.ips.port_info.owned.get_mut(&cu.native_component_id) {
             set.retain(|x| !ports.contains(x));
+        }
         let moved_port_set: HashSet<PortId> = ports.iter().copied().collect();
         if let ConnectorPhased::Communication(comm) = phased {
             // Preserve invariant: batches only reason about native's ports.
             // Remove batch puts/gets for moved ports.
             for batch in comm.native_batches.iter_mut() {
                 batch.to_put.retain(|port, _| !moved_port_set.contains(port));
                 batch.to_get.retain(|port| !moved_port_set.contains(port));
+            }
+        }
         cu.ips.port_info.owned.insert(new_cid, moved_port_set);
         Ok(())
+    }
+}
 impl Predicate {
     #[inline]
     pub fn singleton(k: SpecVar, v: SpecVal) -> Self {
         Self::default().inserted(k, v)
+    }
     #[inline]
     pub fn inserted(mut self, k: SpecVar, v: SpecVal) -> Self {
         self.assigned.insert(k, v);
         self
+    }
     // Return true whether `self` is a subset of `maybe_superset`
     pub fn assigns_subset(&self, maybe_superset: &Self) -> bool {
         for (var, val) in self.assigned.iter() {
             match maybe_superset.assigned.get(var) {
                 Some(val2) if val2 == val => {}
                 _ => return false, // var unmapped, or mapped differently
+            }
+        }
         // `maybe_superset` mirrored all my assignments!
         true
+    }
     /// Given the two predicates {self, other}, return that whose
     /// assignments are the union of those of both.
     fn assignment_union(&self, other: &Self) -> AssignmentUnionResult {
         use AssignmentUnionResult as Aur;
         // iterators over assignments of both predicates. Rely on SORTED ordering of BTreeMap's keys.
         let [mut s_it, mut o_it] = [self.assigned.iter(), other.assigned.iter()];
         let [mut s, mut o] = [s_it.next(), o_it.next()];
         // populate lists of assignments in self but not other and vice versa.
         // do this by incrementally unfolding the iterators, keeping an eye
         // on the ordering between the head elements [s, o].
         // whenever s<o, other is certainly missing element 's', etc.
         let [mut s_not_o, mut o_not_s] = [vec![], vec![]];
         loop {
             match [s, o] {
                 [None, None] => break, // both iterators are empty
                 [None, Some(x)] => {
                     // self's iterator is empty.
                     // all remaning elements are in other but not self
                     o_not_s.push(x);
                     o_not_s.extend(o_it);
                     break;
+                }
                 [Some(x), None] => {
                     // other's iterator is empty.
                     // all remaning elements are in self but not other
                     s_not_o.push(x);
                     s_not_o.extend(s_it);
                     break;
+                }
                 [Some((sid, sb)), Some((oid, ob))] => {
                     if sid < oid {
                         // o is missing this element
                         s_not_o.push((sid, sb));
                         s = s_it.next();
                     } else if sid > oid {
                         // s is missing this element
                         o_not_s.push((oid, ob));
                         o = o_it.next();
                     } else if sb != ob {
                         assert_eq!(sid, oid);
                         // both predicates assign the variable but differ on the value
                         // No predicate exists which satisfies both!
                         return Aur::Nonexistant;
                     } else {
                         // both predicates assign the variable to the same value
                         s = s_it.next();
                         o = o_it.next();
+                    }
+                }
+            }
+        }
         // Observed zero inconsistencies. A unified predicate exists...
         match [s_not_o.is_empty(), o_not_s.is_empty()] {
             [true, true] => Aur::Equivalent,       // ... equivalent to both.
             [false, true] => Aur::FormerNotLatter, // ... equivalent to self.
             [true, false] => Aur::LatterNotFormer, // ... equivalent to other.
             [false, false] => {
                 // ... which is the union of the predicates' assignments but
                 //     is equivalent to neither self nor other.
                 let mut new = self.clone();
                 for (&id, &b) in o_not_s {
                     new.assigned.insert(id, b);
+                }
                 Aur::New(new)
+            }
+        }
+    }
     // Compute the union of the assignments of the two given predicates, if it exists.
     // It doesn't exist if there is some value which the predicates assign to different values.
     pub(crate) fn union_with(&self, other: &Self) -> Option<Self> {
         let mut res = self.clone();
         for (&channel_id, &assignment_1) in other.assigned.iter() {
             match res.assigned.insert(channel_id, assignment_1) {
                 Some(assignment_2) if assignment_1 != assignment_2 => return None,
                 _ => {}
+            }
+        }
         Some(res)
+    }
     pub(crate) fn query(&self, var: SpecVar) -> Option<SpecVal> {
         self.assigned.get(&var).copied()
+    }
+}
 impl RoundCtx {
     // remove an arbitrary buffered message, along with the ID of the getter who receives it
     fn getter_pop(&mut self) -> Option<(PortId, SendPayloadMsg)> {
         self.payload_inbox.pop()
+    }
     // buffer a message along with the ID of the getter who receives it
     fn getter_push(&mut self, getter: PortId, msg: SendPayloadMsg) {
         self.payload_inbox.push((getter, msg));
+    }
     // buffer a message along with the ID of the putter who sent it
     fn putter_push(&mut self, cu: &mut impl CuUndecided, putter: PortId, msg: SendPayloadMsg) {
         if let Some(getter) = self.ips.port_info.map.get(&putter).unwrap().peer {
             log!(cu.logger(), "Putter add (putter:{:?} => getter:{:?})", putter, getter);
             self.getter_push(getter, msg);
         } else {
             log!(cu.logger(), "Putter {:?} has no known peer!", putter);
             panic!("Putter {:?} has no known peer!");
+            panic!("Putter {:?} has no known peer!", putter);
+        }
+    }
+}
 impl<T: Debug + std::cmp::Ord> Debug for VecSet<T> {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         f.debug_set().entries(self.vec.iter()).finish()
+    }
+}
 impl Debug for Predicate {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         struct Assignment<'a>((&'a SpecVar, &'a SpecVal));
         impl Debug for Assignment<'_> {
             fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
                 write!(f, "{:?}={:?}", (self.0).0, (self.0).1)
+            }
+        }
         f.debug_set().entries(self.assigned.iter().map(Assignment)).finish()
+    }
+}
 impl serde::Serialize for SerdeProtocolDescription {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
+    {
         let inner: &ProtocolDescription = &self.0;
         inner.serialize(serializer)
+    }
+}
 impl<'de> serde::Deserialize<'de> for SerdeProtocolDescription {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
+    {
         let inner: ProtocolDescription = ProtocolDescription::deserialize(deserializer)?;
         Ok(Self(Arc::new(inner)))
+    }
+}
 impl IdParts for SpecVar {
     fn id_parts(self) -> (ConnectorId, U32Suffix) {
         self.0.id_parts()
+    }
+}
 impl Debug for SpecVar {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         let (a, b) = self.id_parts();
         write!(f, "v{}_{}", a, b)
+    }
+}
 impl SpecVal {
     const FIRING: Self = SpecVal(1);
     const SILENT: Self = SpecVal(0);
     fn is_firing(self) -> bool {
         self == Self::FIRING
         // all else treated as SILENT
+    }
     fn iter_domain() -> impl Iterator<Item = Self> {
         (0..).map(SpecVal)
+    }
+}
 impl Debug for SpecVal {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         self.0.fmt(f)
+    }
+}
 impl Default for IoByteBuffer {
     fn default() -> Self {
         let mut byte_vec = Vec::with_capacity(Self::CAPACITY);
         unsafe {
             // safe! this vector is guaranteed to have sufficient capacity
             byte_vec.set_len(Self::CAPACITY);
+        }
         Self { byte_vec }
+    }
+}
 impl IoByteBuffer {
     const CAPACITY: usize = u16::MAX as usize + 1000;
     fn as_mut_slice(&mut self) -> &mut [u8] {
         self.byte_vec.as_mut_slice()
+    }
+}
 impl Debug for IoByteBuffer {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         write!(f, "IoByteBuffer")
+    }
+}

src/runtime/tests.rs

➞

Show inline comments

 use crate as reowolf;
 use crossbeam_utils::thread::scope;
 use reowolf::{
     error::*,
     EndpointPolarity::{Active, Passive},
     Polarity::{Getter, Putter},
     *,
 };
 use std::{fs::File, net::SocketAddr, path::Path, sync::Arc, time::Duration};
 //////////////////////////////////////////
 const MS100: Option<Duration> = Some(Duration::from_millis(100));
 const MS300: Option<Duration> = Some(Duration::from_millis(300));
 const SEC1: Option<Duration> = Some(Duration::from_secs(1));
 const SEC5: Option<Duration> = Some(Duration::from_secs(5));
 const SEC15: Option<Duration> = Some(Duration::from_secs(15));
 fn next_test_addr() -> SocketAddr {
     use std::{
         net::{Ipv4Addr, SocketAddrV4},
         sync::atomic::{AtomicU16, Ordering::SeqCst},
     };
     static TEST_PORT: AtomicU16 = AtomicU16::new(5_000);
     let port = TEST_PORT.fetch_add(1, SeqCst);
     SocketAddrV4::new(Ipv4Addr::LOCALHOST, port).into()
+}
 fn file_logged_connector(connector_id: ConnectorId, dir_path: &Path) -> Connector {
     file_logged_configured_connector(connector_id, dir_path, MINIMAL_PROTO.clone())
+}
 fn file_logged_configured_connector(
     connector_id: ConnectorId,
     dir_path: &Path,
     pd: Arc<ProtocolDescription>,
 ) -> Connector {
     let _ = std::fs::create_dir_all(dir_path).expect("Failed to create log output dir");
     let path = dir_path.join(format!("cid_{:?}.txt", connector_id));
     let file = File::create(path).expect("Failed to create log output file!");
     let file_logger = Box::new(FileLogger::new(connector_id, file));
     Connector::new(file_logger, pd, connector_id)
+}
 static MINIMAL_PDL: &'static [u8] = b"
 primitive together(in ia, in ib, out oa, out ob){
   while(true) synchronous {
     if(fires(ia)) {
       put(oa, get(ia));
       put(ob, get(ib));
+    }
+  }
+}
 ";
 lazy_static::lazy_static! {
     static ref MINIMAL_PROTO: Arc<ProtocolDescription> = {
         Arc::new(reowolf::ProtocolDescription::parse(MINIMAL_PDL).unwrap())
     };
+}
 static TEST_MSG_BYTES: &'static [u8] = b"hello";
 lazy_static::lazy_static! {
     static ref TEST_MSG: Payload = {
         Payload::from(TEST_MSG_BYTES)
     };
+}
 fn new_u8_buffer(cap: usize) -> Vec<u8> {
     let mut v = Vec::with_capacity(cap);
     // Safe! len will cover owned bytes in valid state
     unsafe { v.set_len(cap) }
+    v
+}
 //////////////////////////////////////////
 #[test]
 fn basic_connector() {
     Connector::new(Box::new(DummyLogger), MINIMAL_PROTO.clone(), 0);
+}
 #[test]
 fn basic_logged_connector() {
     let test_log_path = Path::new("./logs/basic_logged_connector");
     file_logged_connector(0, test_log_path);
+}
 #[test]
 fn new_port_pair() {
     let test_log_path = Path::new("./logs/new_port_pair");
     let mut c = file_logged_connector(0, test_log_path);
     let [_, _] = c.new_port_pair();
     let [_, _] = c.new_port_pair();
+}
 #[test]
 fn new_sync() {
     let test_log_path = Path::new("./logs/new_sync");
     let mut c = file_logged_connector(0, test_log_path);
     let [o, i] = c.new_port_pair();
     c.add_component(b"sync", &[i, o]).unwrap();
+}
 #[test]
 fn new_net_port() {
     let test_log_path = Path::new("./logs/new_net_port");
     let mut c = file_logged_connector(0, test_log_path);
     let sock_addrs = [next_test_addr()];
     let _ = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();
     let _ = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();
+}
 #[test]
 fn trivial_connect() {
     let test_log_path = Path::new("./logs/trivial_connect");
     let mut c = file_logged_connector(0, test_log_path);
     c.connect(SEC1).unwrap();
+}
 #[test]
 fn single_node_connect() {
     let test_log_path = Path::new("./logs/single_node_connect");
     let sock_addrs = [next_test_addr()];
     let mut c = file_logged_connector(0, test_log_path);
     let _ = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();
     let _ = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();
     c.connect(SEC1).unwrap();
+}
 #[test]
 fn minimal_net_connect() {
     let test_log_path = Path::new("./logs/minimal_net_connect");
     let sock_addrs = [next_test_addr()];
     scope(|s| {
         s.spawn(|_| {
             let mut c = file_logged_connector(0, test_log_path);
             let _ = c.new_net_port(Getter, sock_addrs[0], Active).unwrap();
             c.connect(SEC1).unwrap();
         });
         s.spawn(|_| {
             let mut c = file_logged_connector(1, test_log_path);
             let _ = c.new_net_port(Putter, sock_addrs[0], Passive).unwrap();
             c.connect(SEC1).unwrap();
         });
     })
     .unwrap();
+}
 #[test]
 fn put_no_sync() {
     let test_log_path = Path::new("./logs/put_no_sync");
     let mut c = file_logged_connector(0, test_log_path);
     let [o, _] = c.new_port_pair();
     c.connect(SEC1).unwrap();
     c.put(o, TEST_MSG.clone()).unwrap();
+}
 #[test]
 fn wrong_polarity_bad() {
     let test_log_path = Path::new("./logs/wrong_polarity_bad");
     let mut c = file_logged_connector(0, test_log_path);
     let [_, i] = c.new_port_pair();
     c.connect(SEC1).unwrap();
     c.put(i, TEST_MSG.clone()).unwrap_err();
+}
 #[test]
 fn dup_put_bad() {
     let test_log_path = Path::new("./logs/dup_put_bad");
     let mut c = file_logged_connector(0, test_log_path);
     let [o, _] = c.new_port_pair();
     c.connect(SEC1).unwrap();
     c.put(o, TEST_MSG.clone()).unwrap();
     c.put(o, TEST_MSG.clone()).unwrap_err();
+}
 #[test]
 fn trivial_sync() {
     let test_log_path = Path::new("./logs/trivial_sync");
     let mut c = file_logged_connector(0, test_log_path);
     c.connect(SEC1).unwrap();
     c.sync(SEC1).unwrap();
+}
 #[test]
 fn unconnected_gotten_err() {
     let test_log_path = Path::new("./logs/unconnected_gotten_err");
     let mut c = file_logged_connector(0, test_log_path);
     let [_, i] = c.new_port_pair();
     assert_eq!(reowolf::error::GottenError::NoPreviousRound, c.gotten(i).unwrap_err());
+}
 #[test]
 fn connected_gotten_err_no_round() {
     let test_log_path = Path::new("./logs/connected_gotten_err_no_round");
     let mut c = file_logged_connector(0, test_log_path);
     let [_, i] = c.new_port_pair();
     c.connect(SEC1).unwrap();
     assert_eq!(reowolf::error::GottenError::NoPreviousRound, c.gotten(i).unwrap_err());
+}
 #[test]
 fn connected_gotten_err_ungotten() {
     let test_log_path = Path::new("./logs/connected_gotten_err_ungotten");
     let mut c = file_logged_connector(0, test_log_path);
     let [_, i] = c.new_port_pair();
     c.connect(SEC1).unwrap();
     c.sync(SEC1).unwrap();
     assert_eq!(reowolf::error::GottenError::PortDidntGet, c.gotten(i).unwrap_err());
+}
 #[test]
 fn native_polarity_checks() {
     let test_log_path = Path::new("./logs/native_polarity_checks");
     let mut c = file_logged_connector(0, test_log_path);
     let [o, i] = c.new_port_pair();
     c.connect(SEC1).unwrap();
     // fail...
     c.get(o).unwrap_err();
     c.put(i, TEST_MSG.clone()).unwrap_err();
     // succeed..
     c.get(i).unwrap();
     c.put(o, TEST_MSG.clone()).unwrap();
+}
 #[test]
 fn native_multiple_gets() {
     let test_log_path = Path::new("./logs/native_multiple_gets");
     let mut c = file_logged_connector(0, test_log_path);
     let [_, i] = c.new_port_pair();
     c.connect(SEC1).unwrap();
     c.get(i).unwrap();
     c.get(i).unwrap_err();
+}
 #[test]
 fn next_batch() {
     let test_log_path = Path::new("./logs/next_batch");
     let mut c = file_logged_connector(0, test_log_path);
     c.next_batch().unwrap_err();
     c.connect(SEC1).unwrap();
     c.next_batch().unwrap();
     c.next_batch().unwrap();
     c.next_batch().unwrap();
+}
 #[test]
 fn native_self_msg() {
     let test_log_path = Path::new("./logs/native_self_msg");
     let mut c = file_logged_connector(0, test_log_path);
     let [o, i] = c.new_port_pair();
     c.connect(SEC1).unwrap();
     c.get(i).unwrap();
     c.put(o, TEST_MSG.clone()).unwrap();
     c.sync(SEC1).unwrap();
+}
 #[test]
 fn two_natives_msg() {
     let test_log_path = Path::new("./logs/two_natives_msg");
     let sock_addrs = [next_test_addr()];
     scope(|s| {
         s.spawn(|_| {
             let mut c = file_logged_connector(0, test_log_path);
             let g = c.new_net_port(Getter, sock_addrs[0], Active).unwrap();
             c.connect(SEC1).unwrap();
             c.get(g).unwrap();
             c.sync(SEC1).unwrap();
             c.gotten(g).unwrap();
         });
         s.spawn(|_| {
             let mut c = file_logged_connector(1, test_log_path);
             let p = c.new_net_port(Putter, sock_addrs[0], Passive).unwrap();
             c.connect(SEC1).unwrap();
             c.put(p, TEST_MSG.clone()).unwrap();
             c.sync(SEC1).unwrap();
         });
     })
     .unwrap();
+}
 #[test]
 fn trivial_nondet() {
     let test_log_path = Path::new("./logs/trivial_nondet");
     let mut c = file_logged_connector(0, test_log_path);
     let [_, i] = c.new_port_pair();
     c.connect(SEC1).unwrap();
     c.get(i).unwrap();
     // getting 0 batch
     c.next_batch().unwrap();
     // silent 1 batch
     assert_eq!(1, c.sync(SEC1).unwrap());
     c.gotten(i).unwrap_err();
+}
 #[test]
 fn connector_pair_nondet() {
     let test_log_path = Path::new("./logs/connector_pair_nondet");
     let sock_addrs = [next_test_addr()];
     scope(|s| {
         s.spawn(|_| {
             let mut c = file_logged_connector(0, test_log_path);
             let g = c.new_net_port(Getter, sock_addrs[0], Active).unwrap();
             c.connect(SEC1).unwrap();
             c.next_batch().unwrap();
             c.get(g).unwrap();
             assert_eq!(1, c.sync(SEC1).unwrap());
             c.gotten(g).unwrap();
         });
         s.spawn(|_| {
             let mut c = file_logged_connector(1, test_log_path);
             let p = c.new_net_port(Putter, sock_addrs[0], Passive).unwrap();
             c.connect(SEC1).unwrap();
             c.put(p, TEST_MSG.clone()).unwrap();
             c.sync(SEC1).unwrap();
         });
     })
     .unwrap();
+}
 #[test]
 fn native_immediately_inconsistent() {
     let test_log_path = Path::new("./logs/native_immediately_inconsistent");
     let mut c = file_logged_connector(0, test_log_path);
     let [_, g] = c.new_port_pair();
     c.connect(SEC1).unwrap();
     c.get(g).unwrap();
     c.sync(SEC15).unwrap_err();
+}
 #[test]
 fn native_recovers() {
     let test_log_path = Path::new("./logs/native_recovers");
     let mut c = file_logged_connector(0, test_log_path);
     let [p, g] = c.new_port_pair();
     c.connect(SEC1).unwrap();
     c.get(g).unwrap();
     c.sync(SEC15).unwrap_err();
     c.put(p, TEST_MSG.clone()).unwrap();
     c.get(g).unwrap();
     c.sync(SEC15).unwrap();
+}
 #[test]
 fn cannot_use_moved_ports() {
     /*
     native p|-->|g sync
     */
     let test_log_path = Path::new("./logs/cannot_use_moved_ports");
     let mut c = file_logged_connector(0, test_log_path);
     let [p, g] = c.new_port_pair();
     c.add_component(b"sync", &[g, p]).unwrap();
     c.connect(SEC1).unwrap();
     c.put(p, TEST_MSG.clone()).unwrap_err();
     c.get(g).unwrap_err();
+}
 #[test]
 fn sync_sync() {
     /*
     native p0|-->|g0 sync
            g1|<--|p1
     */
     let test_log_path = Path::new("./logs/sync_sync");
     let mut c = file_logged_connector(0, test_log_path);
     let [p0, g0] = c.new_port_pair();
     let [p1, g1] = c.new_port_pair();
     c.add_component(b"sync", &[g0, p1]).unwrap();
     c.connect(SEC1).unwrap();
     c.put(p0, TEST_MSG.clone()).unwrap();
     c.get(g1).unwrap();
     c.sync(SEC1).unwrap();
     c.gotten(g1).unwrap();
+}
 #[test]
 fn double_net_connect() {
     let test_log_path = Path::new("./logs/double_net_connect");
     let sock_addrs = [next_test_addr(), next_test_addr()];
     scope(|s| {
         s.spawn(|_| {
             let mut c = file_logged_connector(0, test_log_path);
             let [_p, _g] = [
                 c.new_net_port(Putter, sock_addrs[0], Active).unwrap(),
                 c.new_net_port(Getter, sock_addrs[1], Active).unwrap(),
             ];
             c.connect(SEC1).unwrap();
         });
         s.spawn(|_| {
             let mut c = file_logged_connector(1, test_log_path);
             let [_g, _p] = [
                 c.new_net_port(Getter, sock_addrs[0], Passive).unwrap(),
                 c.new_net_port(Putter, sock_addrs[1], Passive).unwrap(),
             ];
             c.connect(SEC1).unwrap();
         });
     })
     .unwrap();
+}
 #[test]
 fn distributed_msg_bounce() {
     /*
     native[0] | sync 0.p|-->|1.p native[1]
 .g|<--|1.g
     */
     let test_log_path = Path::new("./logs/distributed_msg_bounce");
     let sock_addrs = [next_test_addr(), next_test_addr()];
     scope(|s| {
         s.spawn(|_| {
             /*
             native | sync p|-->
                    |      g|<--
             */
             let mut c = file_logged_connector(0, test_log_path);
             let [p, g] = [
                 c.new_net_port(Putter, sock_addrs[0], Active).unwrap(),
                 c.new_net_port(Getter, sock_addrs[1], Active).unwrap(),
             ];
             c.add_component(b"sync", &[g, p]).unwrap();
             c.connect(SEC1).unwrap();
             c.sync(SEC1).unwrap();
         });
         s.spawn(|_| {
             /*
             native p|-->
                    g|<--
             */
             let mut c = file_logged_connector(1, test_log_path);
             let [g, p] = [
                 c.new_net_port(Getter, sock_addrs[0], Passive).unwrap(),
                 c.new_net_port(Putter, sock_addrs[1], Passive).unwrap(),
             ];
             c.connect(SEC1).unwrap();
             c.put(p, TEST_MSG.clone()).unwrap();
             c.get(g).unwrap();
             c.sync(SEC1).unwrap();
             c.gotten(g).unwrap();
         });
     })
     .unwrap();
+}
 #[test]
 fn local_timeout() {
     let test_log_path = Path::new("./logs/local_timeout");
     let mut c = file_logged_connector(0, test_log_path);
     let [_, g] = c.new_port_pair();
     c.connect(SEC1).unwrap();
     c.get(g).unwrap();
     match c.sync(MS300) {
         Err(SyncError::RoundFailure) => {}
         res => panic!("expeted timeout. but got {:?}", res),
+    }
+}
 #[test]
 fn parent_timeout() {
     let test_log_path = Path::new("./logs/parent_timeout");
     let sock_addrs = [next_test_addr()];
     scope(|s| {
         s.spawn(|_| {
             // parent; times out
             let mut c = file_logged_connector(999, test_log_path);
             let _ = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();
             c.connect(SEC1).unwrap();
             c.sync(MS300).unwrap_err(); // timeout
         });
         s.spawn(|_| {
             // child
             let mut c = file_logged_connector(000, test_log_path);
             let g = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();
             c.connect(SEC1).unwrap();
             c.get(g).unwrap(); // not matched by put
             c.sync(None).unwrap_err(); // no timeout
         });
     })
     .unwrap();
+}
 #[test]
 fn child_timeout() {
     let test_log_path = Path::new("./logs/child_timeout");
     let sock_addrs = [next_test_addr()];
     scope(|s| {
         s.spawn(|_| {
             // child; times out
             let mut c = file_logged_connector(000, test_log_path);
             let _ = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();
             c.connect(SEC1).unwrap();
             c.sync(MS300).unwrap_err(); // timeout
         });
         s.spawn(|_| {
             // parent
             let mut c = file_logged_connector(999, test_log_path);
             let g = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();
             c.connect(SEC1).unwrap();
             c.get(g).unwrap(); // not matched by put
             c.sync(None).unwrap_err(); // no timeout
         });
     })
     .unwrap();
+}
 #[test]
 fn chain_connect() {
     let test_log_path = Path::new("./logs/chain_connect");
     let sock_addrs = [next_test_addr(), next_test_addr(), next_test_addr(), next_test_addr()];
     scope(|s| {
         s.spawn(|_| {
             let mut c = file_logged_connector(0, test_log_path);
             c.new_net_port(Putter, sock_addrs[0], Passive).unwrap();
             c.connect(SEC5).unwrap();
         });
         s.spawn(|_| {
             let mut c = file_logged_connector(10, test_log_path);
             c.new_net_port(Getter, sock_addrs[0], Active).unwrap();
             c.new_net_port(Putter, sock_addrs[1], Passive).unwrap();
             c.connect(SEC5).unwrap();
         });
         s.spawn(|_| {
             // LEADER
             let mut c = file_logged_connector(7, test_log_path);
             c.new_net_port(Getter, sock_addrs[1], Active).unwrap();
             c.new_net_port(Putter, sock_addrs[2], Passive).unwrap();
             c.connect(SEC5).unwrap();
         });
         s.spawn(|_| {
             let mut c = file_logged_connector(4, test_log_path);
             c.new_net_port(Getter, sock_addrs[2], Active).unwrap();
             c.new_net_port(Putter, sock_addrs[3], Passive).unwrap();
             c.connect(SEC5).unwrap();
         });
         s.spawn(|_| {
             let mut c = file_logged_connector(1, test_log_path);
             c.new_net_port(Getter, sock_addrs[3], Active).unwrap();
             c.connect(SEC5).unwrap();
         });
     })
     .unwrap();
+}
 #[test]
 fn net_self_loop() {
     let test_log_path = Path::new("./logs/net_self_loop");
     let sock_addrs = [next_test_addr()];
     let mut c = file_logged_connector(0, test_log_path);
     let p = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();
     let g = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();
     c.connect(SEC1).unwrap();
     c.put(p, TEST_MSG.clone()).unwrap();
     c.get(g).unwrap();
     c.sync(MS300).unwrap();
+}
 #[test]
 fn nobody_connects_active() {
     let test_log_path = Path::new("./logs/nobody_connects_active");
     let sock_addrs = [next_test_addr()];
     let mut c = file_logged_connector(0, test_log_path);
     let _g = c.new_net_port(Getter, sock_addrs[0], Active).unwrap();
     c.connect(Some(Duration::from_secs(5))).unwrap_err();
+}
 #[test]
 fn nobody_connects_passive() {
     let test_log_path = Path::new("./logs/nobody_connects_passive");
     let sock_addrs = [next_test_addr()];
     let mut c = file_logged_connector(0, test_log_path);
     let _g = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();
     c.connect(Some(Duration::from_secs(5))).unwrap_err();
+}
 #[test]
 fn together() {
     let test_log_path = Path::new("./logs/together");
     let sock_addrs = [next_test_addr(), next_test_addr()];
     scope(|s| {
         s.spawn(|_| {
             let mut c = file_logged_connector(0, test_log_path);
             let [p0, p1] = c.new_port_pair();
             let p2 = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();
             let p3 = c.new_net_port(Putter, sock_addrs[1], Active).unwrap();
             let [p4, p5] = c.new_port_pair();
             c.add_component(b"together", &[p1, p2, p3, p4]).unwrap();
             c.connect(SEC1).unwrap();
             c.put(p0, TEST_MSG.clone()).unwrap();
             c.get(p5).unwrap();
             c.sync(MS300).unwrap();
             c.gotten(p5).unwrap();
         });
         s.spawn(|_| {
             let mut c = file_logged_connector(1, test_log_path);
             let [p0, p1] = c.new_port_pair();
             let p2 = c.new_net_port(Getter, sock_addrs[1], Passive).unwrap();
             let p3 = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();
             let [p4, p5] = c.new_port_pair();
             c.add_component(b"together", &[p1, p2, p3, p4]).unwrap();
             c.connect(SEC1).unwrap();
             c.put(p0, TEST_MSG.clone()).unwrap();
             c.get(p5).unwrap();
             c.sync(MS300).unwrap();
             c.gotten(p5).unwrap();
         });
     })
     .unwrap();
+}
 #[test]
 fn native_batch_distinguish() {
     let test_log_path = Path::new("./logs/native_batch_distinguish");
     let mut c = file_logged_connector(0, test_log_path);
     c.connect(SEC1).unwrap();
     c.next_batch().unwrap();
     c.sync(SEC1).unwrap();
+}
 #[test]
 fn multirounds() {
     let test_log_path = Path::new("./logs/multirounds");
     let sock_addrs = [next_test_addr(), next_test_addr()];
     scope(|s| {
         s.spawn(|_| {
             let mut c = file_logged_connector(0, test_log_path);
             let p0 = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();
             let p1 = c.new_net_port(Getter, sock_addrs[1], Passive).unwrap();
             c.connect(SEC1).unwrap();
             for _ in 0..10 {
                 c.put(p0, TEST_MSG.clone()).unwrap();
                 c.get(p1).unwrap();
                 c.sync(SEC1).unwrap();
+            }
         });
         s.spawn(|_| {
             let mut c = file_logged_connector(1, test_log_path);
             let p0 = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();
             let p1 = c.new_net_port(Putter, sock_addrs[1], Active).unwrap();
             c.connect(SEC1).unwrap();
             for _ in 0..10 {
                 c.get(p0).unwrap();
                 c.put(p1, TEST_MSG.clone()).unwrap();
                 c.sync(SEC1).unwrap();
+            }
         });
     })
     .unwrap();
+}
 #[test]
 fn multi_recover() {
     let test_log_path = Path::new("./logs/multi_recover");
     let sock_addrs = [next_test_addr(), next_test_addr()];
     let success_iter = [true, false].iter().copied().cycle().take(10);
     scope(|s| {
         s.spawn(|_| {
             let mut c = file_logged_connector(0, test_log_path);
             let p0 = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();
             let p1 = c.new_net_port(Getter, sock_addrs[1], Passive).unwrap();
             c.connect(SEC1).unwrap();
             for succeeds in success_iter.clone() {
                 c.put(p0, TEST_MSG.clone()).unwrap();
                 if succeeds {
                     c.get(p1).unwrap();
+                }
                 let res = c.sync(MS300);
                 assert_eq!(res.is_ok(), succeeds);
+            }
         });
         s.spawn(|_| {
             let mut c = file_logged_connector(1, test_log_path);
             let p0 = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();
             let p1 = c.new_net_port(Putter, sock_addrs[1], Active).unwrap();
             c.connect(SEC1).unwrap();
             for succeeds in success_iter.clone() {
                 c.get(p0).unwrap();
                 c.put(p1, TEST_MSG.clone()).unwrap();
                 let res = c.sync(MS300);
                 assert_eq!(res.is_ok(), succeeds);
+            }
         });
     })
     .unwrap();
+}
 #[test]
 fn udp_self_connect() {
     let test_log_path = Path::new("./logs/udp_self_connect");
     let sock_addrs = [next_test_addr(), next_test_addr()];
     let mut c = file_logged_connector(0, test_log_path);
     c.new_udp_mediator_component(sock_addrs[0], sock_addrs[1]).unwrap();
     c.new_udp_mediator_component(sock_addrs[1], sock_addrs[0]).unwrap();
     c.connect(SEC1).unwrap();
+}
 #[test]
 fn solo_udp_put_success() {
     let test_log_path = Path::new("./logs/solo_udp_put_success");
     let sock_addrs = [next_test_addr(), next_test_addr()];
     let mut c = file_logged_connector(0, test_log_path);
     let [p0, _] = c.new_udp_mediator_component(sock_addrs[0], sock_addrs[1]).unwrap();
     c.connect(SEC1).unwrap();
     c.put(p0, TEST_MSG.clone()).unwrap();
     c.sync(MS300).unwrap();
+}
 #[test]
 fn solo_udp_get_fail() {
     let test_log_path = Path::new("./logs/solo_udp_get_fail");
     let sock_addrs = [next_test_addr(), next_test_addr()];
     let mut c = file_logged_connector(0, test_log_path);
     let [_, p0] = c.new_udp_mediator_component(sock_addrs[0], sock_addrs[1]).unwrap();
     c.connect(SEC1).unwrap();
     c.get(p0).unwrap();
     c.sync(MS300).unwrap_err();
+}
 #[ignore]
 #[test]
 fn reowolf_to_udp() {
     let test_log_path = Path::new("./logs/reowolf_to_udp");
     let sock_addrs = [next_test_addr(), next_test_addr()];
     let barrier = std::sync::Barrier::new(2);
     scope(|s| {
         s.spawn(|_| {
             barrier.wait();
             // reowolf thread
             let mut c = file_logged_connector(0, test_log_path);
             let [p0, _] = c.new_udp_mediator_component(sock_addrs[0], sock_addrs[1]).unwrap();
             c.connect(SEC1).unwrap();
             c.put(p0, TEST_MSG.clone()).unwrap();
             c.sync(MS300).unwrap();
             barrier.wait();
         });
         s.spawn(|_| {
             barrier.wait();
             // udp thread
             let udp = std::net::UdpSocket::bind(sock_addrs[1]).unwrap();
             udp.connect(sock_addrs[0]).unwrap();
             let mut buf = new_u8_buffer(256);
             let len = udp.recv(&mut buf).unwrap();
             assert_eq!(TEST_MSG_BYTES, &buf[0..len]);
             barrier.wait();
         });
     })
     .unwrap();
+}
 #[ignore]
 #[test]
 fn udp_to_reowolf() {
     let test_log_path = Path::new("./logs/udp_to_reowolf");
     let sock_addrs = [next_test_addr(), next_test_addr()];
     let barrier = std::sync::Barrier::new(2);
     scope(|s| {
         s.spawn(|_| {
             barrier.wait();
             // reowolf thread
             let mut c = file_logged_connector(0, test_log_path);
             let [_, p0] = c.new_udp_mediator_component(sock_addrs[0], sock_addrs[1]).unwrap();
             c.connect(SEC1).unwrap();
             c.get(p0).unwrap();
             c.sync(SEC5).unwrap();
             assert_eq!(c.gotten(p0).unwrap().as_slice(), TEST_MSG_BYTES);
             barrier.wait();
         });
         s.spawn(|_| {
             barrier.wait();
             // udp thread
             let udp = std::net::UdpSocket::bind(sock_addrs[1]).unwrap();
             udp.connect(sock_addrs[0]).unwrap();
             for _ in 0..15 {
                 udp.send(TEST_MSG_BYTES).unwrap();
                 std::thread::sleep(MS100.unwrap());
+            }
             barrier.wait();
         });
     })
     .unwrap();
+}
 #[test]
 fn udp_reowolf_swap() {
     let test_log_path = Path::new("./logs/udp_reowolf_swap");
     let sock_addrs = [next_test_addr(), next_test_addr()];
     let barrier = std::sync::Barrier::new(2);
     scope(|s| {
         s.spawn(|_| {
             barrier.wait();
             // reowolf thread
             let mut c = file_logged_connector(0, test_log_path);
             let [p0, p1] = c.new_udp_mediator_component(sock_addrs[0], sock_addrs[1]).unwrap();
             c.connect(SEC1).unwrap();
             c.put(p0, TEST_MSG.clone()).unwrap();
             c.get(p1).unwrap();
             c.sync(SEC5).unwrap();
             assert_eq!(c.gotten(p1).unwrap().as_slice(), TEST_MSG_BYTES);
             barrier.wait();
         });
         s.spawn(|_| {
             barrier.wait();
             // udp thread
             let udp = std::net::UdpSocket::bind(sock_addrs[1]).unwrap();
             udp.connect(sock_addrs[0]).unwrap();
             let mut buf = new_u8_buffer(256);
             for _ in 0..5 {
                 std::thread::sleep(Duration::from_millis(60));
                 udp.send(TEST_MSG_BYTES).unwrap();
+            }
             let len = udp.recv(&mut buf).unwrap();
             assert_eq!(TEST_MSG_BYTES, &buf[0..len]);
             barrier.wait();
         });
     })
     .unwrap();
+}
 #[test]
 fn example_pres_3() {
     let test_log_path = Path::new("./logs/example_pres_3");
     let sock_addrs = [next_test_addr(), next_test_addr()];
     scope(|s| {
         s.spawn(|_| {
             // "amy"
             let mut c = file_logged_connector(0, test_log_path);
             let p0 = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();
             let p1 = c.new_net_port(Putter, sock_addrs[1], Active).unwrap();
             c.connect(SEC1).unwrap();
             // put {A} and FAIL
             c.put(p0, TEST_MSG.clone()).unwrap();
             c.sync(SEC1).unwrap_err();
             // put {B} and FAIL
             c.put(p1, TEST_MSG.clone()).unwrap();
             c.sync(SEC1).unwrap_err();
             // put {A, B} and SUCCEED
             c.put(p0, TEST_MSG.clone()).unwrap();
             c.put(p1, TEST_MSG.clone()).unwrap();
             c.sync(SEC1).unwrap();
         });
         s.spawn(|_| {
             // "bob"
             let mut c = file_logged_connector(1, test_log_path);
             let p0 = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();
             let p1 = c.new_net_port(Getter, sock_addrs[1], Passive).unwrap();
             c.connect(SEC1).unwrap();
             for _ in 0..2 {
                 // get {A, B} and FAIL
                 c.get(p0).unwrap();
                 c.get(p1).unwrap();
                 c.sync(SEC1).unwrap_err();
+            }
             // get {A, B} and SUCCEED
             c.get(p0).unwrap();
             c.get(p1).unwrap();
             c.sync(SEC1).unwrap();
         });
     })
     .unwrap();
+}
 #[test]
 fn ac_not_b() {
     let test_log_path = Path::new("./logs/ac_not_b");
     let sock_addrs = [next_test_addr(), next_test_addr()];
     scope(|s| {
         s.spawn(|_| {
             // "amy"
             let mut c = file_logged_connector(0, test_log_path);
             let p0 = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();
             let p1 = c.new_net_port(Putter, sock_addrs[1], Active).unwrap();
             c.connect(SEC1).unwrap();
             // put both A and B
             c.put(p0, TEST_MSG.clone()).unwrap();
             c.put(p1, TEST_MSG.clone()).unwrap();
             c.sync(SEC1).unwrap_err();
         });
         s.spawn(|_| {
             // "bob"
             let pdl = b"
             primitive ac_not_b(in a, in b, out c){
                 // forward A to C but keep B silent
                 synchronous{ put(c, get(a)); }
             }";
             let pd = Arc::new(reowolf::ProtocolDescription::parse(pdl).unwrap());
             let mut c = file_logged_configured_connector(1, test_log_path, pd);
             let p0 = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();
             let p1 = c.new_net_port(Getter, sock_addrs[1], Passive).unwrap();
             let [a, b] = c.new_port_pair();
             c.add_component(b"ac_not_b", &[p0, p1, a]).unwrap();
             c.connect(SEC1).unwrap();
             c.get(b).unwrap();
             c.sync(SEC1).unwrap_err();
         });
     })
     .unwrap();
+}
 #[test]
 fn many_rounds_net() {
     let test_log_path = Path::new("./logs/many_rounds_net");
     let sock_addrs = [next_test_addr()];
     const NUM_ROUNDS: usize = 1_000;
     scope(|s| {
         s.spawn(|_| {
             let mut c = file_logged_connector(0, test_log_path);
             let p0 = c.new_net_port(Putter, sock_addrs[0], Active).unwrap();
             c.connect(SEC1).unwrap();
             for _ in 0..NUM_ROUNDS {
                 c.put(p0, TEST_MSG.clone()).unwrap();
                 c.sync(SEC1).unwrap();
+            }
         });
         s.spawn(|_| {
             let mut c = file_logged_connector(1, test_log_path);
             let p0 = c.new_net_port(Getter, sock_addrs[0], Passive).unwrap();
             c.connect(SEC1).unwrap();
             for _ in 0..NUM_ROUNDS {
                 c.get(p0).unwrap();
                 c.sync(SEC1).unwrap();
+            }
         });
     })
     .unwrap();
+}
 #[test]
 fn many_rounds_mem() {
     let test_log_path = Path::new("./logs/many_rounds_mem");
     const NUM_ROUNDS: usize = 1_000;
     let mut c = file_logged_connector(0, test_log_path);
     let [p0, p1] = c.new_port_pair();
     c.connect(SEC1).unwrap();
     for _ in 0..NUM_ROUNDS {
         c.put(p0, TEST_MSG.clone()).unwrap();
         c.get(p1).unwrap();
         c.sync(SEC1).unwrap();
+    }
+}
 #[test]
 fn pdl_reo_lossy() {
     let pdl = b"
     primitive lossy(in a, out b) {
         while(true) synchronous {
             msg m = null;
             if(fires(a)) {
                 m = get(a);
                 if(fires(b)) {
                     put(b, m);
+                }
+            }
+        }
+    }
     ";
     reowolf::ProtocolDescription::parse(pdl).unwrap();
+}
 #[test]
 fn pdl_reo_fifo1() {
     let pdl = b"
     primitive fifo1(in a, out b) {
         msg m = null;
         while(true) synchronous {
             if(m == null) {
                 if(fires(a)) m=get(a);
             } else {
                 if(fires(b)) put(b, m);
                 m = null;
+            }
+        }
+    }
     ";
     reowolf::ProtocolDescription::parse(pdl).unwrap();
+}
 #[test]
 fn pdl_reo_fifo1full() {
     let test_log_path = Path::new("./logs/pdl_reo_fifo1full");
     let pdl = b"
     primitive fifo1full(in a, out b) {
         msg m = create(0);
         while(true) synchronous {
             if(m == null) {
                 if(fires(a)) m=get(a);
             } else {
                 if(fires(b)) put(b, m);
                 m = null;
+            }
+        }
+    }
     ";
     let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();
     let mut c = file_logged_configured_connector(0, test_log_path, Arc::new(pd));
     let [_p0, g0] = c.new_port_pair();
     let [p1, g1] = c.new_port_pair();
     c.add_component(b"fifo1full", &[g0, p1]).unwrap();
     c.connect(None).unwrap();
     c.get(g1).unwrap();
     c.sync(None).unwrap();
     assert_eq!(0, c.gotten(g1).unwrap().len());
+}
 #[test]
 fn pdl_msg_consensus() {
     let test_log_path = Path::new("./logs/pdl_msg_consensus");
     let pdl = b"
     primitive msgconsensus(in a, in b) {
         while(true) synchronous {
             msg x = get(a);
             msg y = get(b);
             assert(x == y);
+        }
+    }
     ";
     let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();
     let mut c = file_logged_configured_connector(0, test_log_path, Arc::new(pd));
     let [p0, g0] = c.new_port_pair();
     let [p1, g1] = c.new_port_pair();
     c.add_component(b"msgconsensus", &[g0, g1]).unwrap();
     c.connect(None).unwrap();
     c.put(p0, Payload::from(b"HELLO" as &[_])).unwrap();
     c.put(p1, Payload::from(b"HELLO" as &[_])).unwrap();
     c.sync(SEC1).unwrap();
     c.put(p0, Payload::from(b"HEY" as &[_])).unwrap();
     c.put(p1, Payload::from(b"HELLO" as &[_])).unwrap();
     c.sync(SEC1).unwrap_err();
+}
 #[test]
 fn sequencer3_prim() {
     let test_log_path = Path::new("./logs/sequencer3_prim");
     let pdl = b"
     primitive sequencer3(out a, out b, out c) {
         int i = 0;
         while(true) synchronous {
             out to = a;
             if     (i==1) to = b;
             else if(i==2) to = c;
             if(fires(to)) {
                 put(to, create(0));
                 i = (i + 1)%3;
+            }
+        }
+    }
     ";
     let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();
     let mut c = file_logged_configured_connector(0, test_log_path, Arc::new(pd));
     // setup a session between (a) native, and (b) sequencer3, connected by 3 ports.
     let [p0, g0] = c.new_port_pair();
     let [p1, g1] = c.new_port_pair();
     let [p2, g2] = c.new_port_pair();
     c.add_component(b"sequencer3", &[p0, p1, p2]).unwrap();
     c.connect(None).unwrap();
     let which_of_three = move |c: &mut Connector| {
         // setup three sync batches. sync. return which succeeded
         c.get(g0).unwrap();
         c.next_batch().unwrap();
         c.get(g1).unwrap();
         c.next_batch().unwrap();
         c.get(g2).unwrap();
         c.sync(None).unwrap()
     };
     const TEST_ROUNDS: usize = 50;
     // check that the batch index for rounds 0..TEST_ROUNDS are [0, 1, 2, 0, 1, 2, ...]
     for expected_batch_idx in (0..=2).cycle().take(TEST_ROUNDS) {
         // silent round
         assert_eq!(0, c.sync(None).unwrap());
         // non silent round
         assert_eq!(expected_batch_idx, which_of_three(&mut c));
+    }
+}
 #[test]
 fn sequencer3_comp() {
     let test_log_path = Path::new("./logs/sequencer3_comp");
     let pdl = b"
     primitive fifo1_init(msg m, in a, out b) {
         while(true) synchronous {
             if(m != null && fires(b)) {
                 put(b, m);
                 m = null;
             } else if (m == null && fires(a)) {
                 m = get(a);
+            }
+        }
+    }
     composite fifo1_full(in a, out b) {
         new fifo1_init(create(0), a, b);
+    }
     composite fifo1(in a, out b) {
         new fifo1_init(null, a, b);
+    }
     composite sequencer3(out a, out b, out c) {
         channel d -> e;
         channel f -> g;
         channel h -> i;
         channel j -> k;
         channel l -> m;
         channel n -> o;
         new fifo1_full(o, d);
         new replicator(e, f, a);
         new fifo1(g, h);
         new replicator(i, j, b);
         new fifo1(k, l);
         new replicator(m, n, c);
+    }
     ";
     let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();
     let mut c = file_logged_configured_connector(0, test_log_path, Arc::new(pd));
     // setup a session between (a) native, and (b) sequencer3, connected by 3 ports.
     let [p0, g0] = c.new_port_pair();
     let [p1, g1] = c.new_port_pair();
     let [p2, g2] = c.new_port_pair();
     c.add_component(b"sequencer3", &[p0, p1, p2]).unwrap();
     c.connect(None).unwrap();
     let which_of_three = move |c: &mut Connector| {
         // setup three sync batches. sync. return which succeeded
         c.get(g0).unwrap();
         c.next_batch().unwrap();
         c.get(g1).unwrap();
         c.next_batch().unwrap();
         c.get(g2).unwrap();
         c.sync(SEC1).unwrap()
     };
     const TEST_ROUNDS: usize = 50;
     // check that the batch index for rounds 0..TEST_ROUNDS are [0, 1, 2, 0, 1, 2, ...]
     for expected_batch_idx in (0..=2).cycle().take(TEST_ROUNDS) {
         // silent round
         assert_eq!(0, c.sync(SEC1).unwrap());
         // non silent round
         assert_eq!(expected_batch_idx, which_of_three(&mut c));
+    }
+}
 enum XRouterItem {
     Silent,
     GetA,
     GetB,
+}
 // Hardcoded pseudo-random sequence of round behaviors for the native component
 const XROUTER_ITEMS: &[XRouterItem] = {
     use XRouterItem::{GetA as A, GetB as B, Silent as S};
     &[
         B, A, S, B, A, A, B, S, B, S, A, A, S, B, B, S, B, S, B, B, S, B, B, A, B, B, A, B, A, B,
         S, B, S, B, S, A, S, B, A, S, B, A, B, S, B, S, B, S, S, B, B, A, A, A, S, S, S, B, A, A,
         A, S, S, B, B, B, A, B, S, S, A, A, B, A, B, B, A, A, A, B, A, B, S, A, B, S, A, A, B, S,
+    ]
 };
 #[test]
 fn xrouter_prim() {
     let test_log_path = Path::new("./logs/xrouter_prim");
     let pdl = b"
     primitive xrouter(in a, out b, out c) {
         while(true) synchronous {
             if(fires(a)) {
                 if(fires(b)) put(b, get(a));
                 else         put(c, get(a));
+            }
+        }
+    }
     ";
     let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();
     let mut c = file_logged_configured_connector(0, test_log_path, Arc::new(pd));
     // setup a session between (a) native, and (b) xrouter2, connected by 3 ports.
     let [p0, g0] = c.new_port_pair();
     let [p1, g1] = c.new_port_pair();
     let [p2, g2] = c.new_port_pair();
     c.add_component(b"xrouter", &[g0, p1, p2]).unwrap();
     c.connect(None).unwrap();
     let now = std::time::Instant::now();
     for item in XROUTER_ITEMS.iter() {
         match item {
             XRouterItem::Silent => {}
             XRouterItem::GetA => {
                 c.put(p0, TEST_MSG.clone()).unwrap();
                 c.get(g1).unwrap();
+            }
             XRouterItem::GetB => {
                 c.put(p0, TEST_MSG.clone()).unwrap();
                 c.get(g2).unwrap();
+            }
+        }
         assert_eq!(0, c.sync(SEC1).unwrap());
+    }
     println!("PRIM {:?}", now.elapsed());
+}
 #[test]
 fn xrouter_comp() {
     let test_log_path = Path::new("./logs/xrouter_comp");
     let pdl = b"
     primitive lossy(in a, out b) {
         while(true) synchronous {
             if(fires(a)) {
                 msg m = get(a);
                 if(fires(b)) put(b, m);
+            }
+        }
+    }
     primitive sync_drain(in a, in b) {
         while(true) synchronous {
             if(fires(a)) {
                 get(a);
                 get(b);
+            }
+        }
+    }
     composite xrouter(in a, out b, out c) {
         channel d -> e;
         channel f -> g;
         channel h -> i;
         channel j -> k;
         channel l -> m;
         channel n -> o;
         channel p -> q;
         channel r -> s;
         channel t -> u;
         new replicator(a, d, f);
         new replicator(g, t, h);
         new lossy(e, l);
         new lossy(i, j);
         new replicator(m, b, p);
         new replicator(k, n, c);
         new merger(q, o, r);
         new sync_drain(u, s);
+    }
     ";
     let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();
     let mut c = file_logged_configured_connector(0, test_log_path, Arc::new(pd));
     // setup a session between (a) native, and (b) xrouter2, connected by 3 ports.
     let [p0, g0] = c.new_port_pair();
     let [p1, g1] = c.new_port_pair();
     let [p2, g2] = c.new_port_pair();
     c.add_component(b"xrouter", &[g0, p1, p2]).unwrap();
     c.connect(None).unwrap();
     let now = std::time::Instant::now();
     for item in XROUTER_ITEMS.iter() {
         match item {
             XRouterItem::Silent => {}
             XRouterItem::GetA => {
                 c.put(p0, TEST_MSG.clone()).unwrap();
                 c.get(g1).unwrap();
+            }
             XRouterItem::GetB => {
                 c.put(p0, TEST_MSG.clone()).unwrap();
                 c.get(g2).unwrap();
+            }
+        }
         assert_eq!(0, c.sync(SEC1).unwrap());
+    }
     println!("COMP {:?}", now.elapsed());
+}
 #[test]
 fn count_stream() {
     let test_log_path = Path::new("./logs/count_stream");
     let pdl = b"
     primitive count_stream(out o) {
         msg m = create(1);
         m[0] = 0;
         while(true) synchronous {
             put(o, m);
             m[0] += 1;
+        }
+    }
     ";
     let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();
     let mut c = file_logged_configured_connector(0, test_log_path, Arc::new(pd));
     // setup a session between (a) native, and (b) sequencer3, connected by 3 ports.
     let [p0, g0] = c.new_port_pair();
     c.add_component(b"count_stream", &[p0]).unwrap();
     c.connect(None).unwrap();
     for expecting in 0u8..16 {
         c.get(g0).unwrap();
         c.sync(None).unwrap();
         assert_eq!(&[expecting], c.gotten(g0).unwrap().as_slice());
+    }
+}
 #[test]
 fn for_msg_byte() {
     let test_log_path = Path::new("./logs/for_msg_byte");
     let pdl = b"
     primitive for_msg_byte(out o) {
         byte i = 0;
         while(i<8) {
             msg m = create(1);
             m[0] = i;
             synchronous put(o, m);
             i++;
+        }
+    }
     ";
     let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();
     let mut c = file_logged_configured_connector(0, test_log_path, Arc::new(pd));
     // setup a session between (a) native, and (b) sequencer3, connected by 3 ports.
     let [p0, g0] = c.new_port_pair();
     c.add_component(b"for_msg_byte", &[p0]).unwrap();
     c.connect(None).unwrap();
     for expecting in 0u8..8 {
         c.get(g0).unwrap();
         c.sync(None).unwrap();
         assert_eq!(&[expecting], c.gotten(g0).unwrap().as_slice());
+    }
     c.sync(None).unwrap();
+}
 #[test]
 fn eq_causality() {
     let test_log_path = Path::new("./logs/eq_causality");
     let pdl = b"
     primitive eq(in a, in b, out c) {
         msg ma = null;
         msg mb = null;
         while(true) synchronous {
             if(fires(a)) {
                 // b and c also fire!
                 // left first!
                 ma = get(a);
                 put(c, ma);
                 mb = get(b);
                 assert(ma == mb);
+            }
+        }
+    }
     ";
     let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();
     let mut c = file_logged_configured_connector(0, test_log_path, Arc::new(pd));
     /*
     [native]p0-->g0[eq]p1--.
                  g1        |
                  ^---------`
     */
     let [p0, g0] = c.new_port_pair();
     let [p1, g1] = c.new_port_pair();
     c.add_component(b"eq", &[g0, g1, p1]).unwrap();
     /*
                   V--------.
                  g2        |
     [native]p2-->g3[eq]p3--`
     */
     let [p2, g2] = c.new_port_pair();
     let [p3, g3] = c.new_port_pair();
     c.add_component(b"eq", &[g3, g2, p3]).unwrap();
     c.connect(None).unwrap();
     for _ in 0..4 {
         // everything is fine with LEFT FIRST
         c.put(p0, TEST_MSG.clone()).unwrap();
         c.sync(MS100).unwrap();
         // no solution when left is NOT FIRST
         c.put(p2, TEST_MSG.clone()).unwrap();
         c.sync(MS100).unwrap_err();
+    }
+}
 #[test]
 fn eq_no_causality() {
     let test_log_path = Path::new("./logs/eq_no_causality");
     let pdl = b"
     composite eq(in<msg> a, in<msg> b, out<msg> c) {
         channel leftfirsto -> leftfirsti;
         new eqinner(a, b, c, leftfirsto, leftfirsti);
+    }
     primitive eqinner(in<msg> a, in<msg> b, out<msg> c, out<msg> leftfirsto, in<msg> leftfirsti) {
         msg ma = null;
         msg mb = null;
         while(true) synchronous {
             if(fires(a)) {
                 // b and c also fire!
                 if(fires(leftfirsti)) {
                     // left first! DO USE DUMMY
                     ma = get(a);
                     put(c, ma);
                     mb = get(b);
                     // using dummy!
                     put(leftfirsto, ma);
                     get(leftfirsti);
                 } else {
                     // right first! DON'T USE DUMMY
                     mb = get(b);
                     put(c, mb);
                     ma = get(a);
+                }
                 assert(ma == mb);
+            }
+        }
+    }
     T some_function<T>(msg a, msg b) {
         T something = a;
         return something;
+    }
-    primitive quick_test(in<msg> a, in<msg> b) {
+    primitive quick_test(in<int> a, in<int> b) {
         // msg ma = null;
         msg test1 = null;
         msg test2 = null;
         msg ma = some_function(test1, test2);
         auto test1 = 0;
         auto test2 = 0;
         auto ma = some_function(test1, test2);
         while(true) synchronous {
             if (fires(a)) {
                 ma = get(a);
+            }
             if (fires(b)) {
                 ma = get(b);
+            }
             if (fires(a) && fires(b)) {
                 ma = get(a) + get(b);
+            }
+        }
+    }
     ";
     let pd = reowolf::ProtocolDescription::parse(pdl).unwrap();
     let mut c = file_logged_configured_connector(0, test_log_path, Arc::new(pd));
     /*
     [native]p0-->g0[eq]p1--.
                  g1        |
                  ^---------`
     */
     let [p0, g0] = c.new_port_pair();
     let [p1, g1] = c.new_port_pair();
     c.add_component(b"eq", &[g0, g1, p1]).unwrap();
     /*
                   V--------.
                  g2        |
     [native]p2-->g3[eq]p3--`
     */
     let [p2, g2] = c.new_port_pair();
     let [p3, g3] = c.new_port_pair();
     c.add_component(b"eq", &[g3, g2, p3]).unwrap();
     c.connect(None).unwrap();
     for _ in 0..32 {
         // ok when they send
         c.put(p0, TEST_MSG.clone()).unwrap();
         c.put(p2, TEST_MSG.clone()).unwrap();
         c.sync(SEC1).unwrap();
         // ok when they don't
         c.sync(SEC1).unwrap();
+    }
+}

0 comments (0 inline, 0 general)