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

Changeset - 6929a6091ed6

Parent rev.

Child rev.

[Not reviewed]

0 7 0

MH - 4 years ago 2021-04-08 10:05:57
henger@cwi.nl

start on binding expressions

6 files changed:

src/protocol/ast.rs

src/protocol/ast_printer.rs

src/protocol/eval.rs

src/protocol/lexer.rs

src/protocol/tests/parser_monomorphs.rs

src/protocol/tests/parser_validation.rs

Changeset was too big and was cut off... Show full diff anyway

0 comments (0 inline, 0 general)

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 crate::protocol::inputsource::*;
 /// Global limits to the AST, should be checked by lexer and parser. Some are
 /// arbitrary
 const MAX_LEVEL: usize = 128;
 const MAX_NAMESPACES: usize = 64;
 /// 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,
         index($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]
+            }
+        }
     };
     // Variant where we define type, Index(Mut) traits and an allocation function
+    (
         $name:ident, $parent:ty,
         index($indexed_type:ty, $indexed_arena:ident),
         alloc($fn_name:ident)
     ) => {
         define_aliased_ast_id!($name, $parent, index($indexed_type, $indexed_arena));
         impl Heap {
             pub fn $fn_name(&mut self, f: impl FnOnce($name) -> $indexed_type) -> $name {
                 self.$indexed_arena.alloc_with_id(|id| f(id))
+            }
+        }
     };
+}
 /// 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,
         index($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!()
+                }
+            }
+        }
     };
     // Variant where we define the type, the Index and IndexMut traits, and an allocation function
+    (
         $name:ident, $parent:ty,
         index($indexed_type:ty, $wrapper_type:path, $indexed_arena:ident),
         alloc($fn_name:ident)
     ) => {
         define_new_ast_id!($name, $parent, index($indexed_type, $wrapper_type, $indexed_arena));
         impl Heap {
             pub fn $fn_name(&mut self, f: impl FnOnce($name) -> $indexed_type) -> $name {
                 $name(
                     self.$indexed_arena.alloc_with_id(|id| {
                         $wrapper_type(f($name(id)))
                     })
+                )
+            }
+        }
+    }
+}
 define_aliased_ast_id!(RootId, Id<Root>, index(Root, protocol_descriptions), alloc(alloc_protocol_description));
 define_aliased_ast_id!(PragmaId, Id<Pragma>, index(Pragma, pragmas), alloc(alloc_pragma));
 define_aliased_ast_id!(ImportId, Id<Import>, index(Import, imports), alloc(alloc_import));
 define_aliased_ast_id!(ParserTypeId, Id<ParserType>, index(ParserType, parser_types), alloc(alloc_parser_type));
 define_aliased_ast_id!(VariableId, Id<Variable>, index(Variable, variables));
 define_new_ast_id!(ParameterId, VariableId, index(Parameter, Variable::Parameter, variables), alloc(alloc_parameter));
 define_new_ast_id!(LocalId, VariableId, index(Local, Variable::Local, variables), alloc(alloc_local));
 define_aliased_ast_id!(DefinitionId, Id<Definition>, index(Definition, definitions));
 define_new_ast_id!(StructId, DefinitionId, index(StructDefinition, Definition::Struct, definitions), alloc(alloc_struct_definition));
 define_new_ast_id!(EnumId, DefinitionId, index(EnumDefinition, Definition::Enum, definitions), alloc(alloc_enum_definition));
 define_new_ast_id!(UnionId, DefinitionId, index(UnionDefinition, Definition::Union, definitions), alloc(alloc_union_definition));
 define_new_ast_id!(ComponentId, DefinitionId, index(Component, Definition::Component, definitions), alloc(alloc_component));
 define_new_ast_id!(FunctionId, DefinitionId, index(Function, Definition::Function, definitions), alloc(alloc_function));
 define_aliased_ast_id!(StatementId, Id<Statement>, index(Statement, statements));
 define_new_ast_id!(BlockStatementId, StatementId, index(BlockStatement, Statement::Block, statements), alloc(alloc_block_statement));
 define_new_ast_id!(LocalStatementId, StatementId, index(LocalStatement, Statement::Local, statements), alloc(alloc_local_statement));
 define_new_ast_id!(MemoryStatementId, LocalStatementId);
 define_new_ast_id!(ChannelStatementId, LocalStatementId);
 define_new_ast_id!(SkipStatementId, StatementId, index(SkipStatement, Statement::Skip, statements), alloc(alloc_skip_statement));
 define_new_ast_id!(LabeledStatementId, StatementId, index(LabeledStatement, Statement::Labeled, statements), alloc(alloc_labeled_statement));
 define_new_ast_id!(IfStatementId, StatementId, index(IfStatement, Statement::If, statements), alloc(alloc_if_statement));
 define_new_ast_id!(EndIfStatementId, StatementId, index(EndIfStatement, Statement::EndIf, statements), alloc(alloc_end_if_statement));
 define_new_ast_id!(WhileStatementId, StatementId, index(WhileStatement, Statement::While, statements), alloc(alloc_while_statement));
 define_new_ast_id!(EndWhileStatementId, StatementId, index(EndWhileStatement, Statement::EndWhile, statements), alloc(alloc_end_while_statement));
 define_new_ast_id!(BreakStatementId, StatementId, index(BreakStatement, Statement::Break, statements), alloc(alloc_break_statement));
 define_new_ast_id!(ContinueStatementId, StatementId, index(ContinueStatement, Statement::Continue, statements), alloc(alloc_continue_statement));
 define_new_ast_id!(SynchronousStatementId, StatementId, index(SynchronousStatement, Statement::Synchronous, statements), alloc(alloc_synchronous_statement));
 define_new_ast_id!(EndSynchronousStatementId, StatementId, index(EndSynchronousStatement, Statement::EndSynchronous, statements), alloc(alloc_end_synchronous_statement));
 define_new_ast_id!(ReturnStatementId, StatementId, index(ReturnStatement, Statement::Return, statements), alloc(alloc_return_statement));
 define_new_ast_id!(AssertStatementId, StatementId, index(AssertStatement, Statement::Assert, statements), alloc(alloc_assert_statement));
 define_new_ast_id!(GotoStatementId, StatementId, index(GotoStatement, Statement::Goto, statements), alloc(alloc_goto_statement));
 define_new_ast_id!(NewStatementId, StatementId, index(NewStatement, Statement::New, statements), alloc(alloc_new_statement));
 define_new_ast_id!(ExpressionStatementId, StatementId, index(ExpressionStatement, Statement::Expression, statements), alloc(alloc_expression_statement));
 define_aliased_ast_id!(ExpressionId, Id<Expression>, index(Expression, expressions));
 define_new_ast_id!(AssignmentExpressionId, ExpressionId, index(AssignmentExpression, Expression::Assignment, expressions), alloc(alloc_assignment_expression));
 define_new_ast_id!(BindingExpressionId, ExpressionId, index(BindingExpression, Expression::Binding, expressions), alloc(alloc_binding_expression));
 define_new_ast_id!(ConditionalExpressionId, ExpressionId, index(ConditionalExpression, Expression::Conditional, expressions), alloc(alloc_conditional_expression));
 define_new_ast_id!(BinaryExpressionId, ExpressionId, index(BinaryExpression, Expression::Binary, expressions), alloc(alloc_binary_expression));
 define_new_ast_id!(UnaryExpressionId, ExpressionId, index(UnaryExpression, Expression::Unary, expressions), alloc(alloc_unary_expression));
 define_new_ast_id!(IndexingExpressionId, ExpressionId, index(IndexingExpression, Expression::Indexing, expressions), alloc(alloc_indexing_expression));
 define_new_ast_id!(SlicingExpressionId, ExpressionId, index(SlicingExpression, Expression::Slicing, expressions), alloc(alloc_slicing_expression));
 define_new_ast_id!(SelectExpressionId, ExpressionId, index(SelectExpression, Expression::Select, expressions), alloc(alloc_select_expression));
 define_new_ast_id!(ArrayExpressionId, ExpressionId, index(ArrayExpression, Expression::Array, expressions), alloc(alloc_array_expression));
 define_new_ast_id!(LiteralExpressionId, ExpressionId, index(LiteralExpression, Expression::Literal, expressions), alloc(alloc_literal_expression));
 define_new_ast_id!(CallExpressionId, ExpressionId, index(CallExpression, Expression::Call, expressions), alloc(alloc_call_expression));
 define_new_ast_id!(VariableExpressionId, ExpressionId, index(VariableExpression, Expression::Variable, expressions), alloc(alloc_variable_expression));
 // 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_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)))
             ))
         })))
+    }
+}
 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: Identifier,
     // 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: Identifier,
     pub alias: Identifier,
     // 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>
+}
 impl PartialEq for Identifier {
     fn eq(&self, other: &Self) -> bool {
         return self.value == other.value
+    }
+}
 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))
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum NamespacedIdentifierPart {
     // Regular identifier
     Identifier{start: u16, end: u16},
     // Polyargs associated with a preceding identifier
     PolyArgs{start: u16, end: u16},
+}
 impl NamespacedIdentifierPart {
     pub(crate) fn is_identifier(&self) -> bool {
         match self {
             NamespacedIdentifierPart::Identifier{..} => true,
             NamespacedIdentifierPart::PolyArgs{..} => false,
+        }
+    }
     pub(crate) fn as_identifier(&self) -> (u16, u16) {
         match self {
             NamespacedIdentifierPart::Identifier{start, end} => (*start, *end),
             NamespacedIdentifierPart::PolyArgs{..} => {
                 unreachable!("Tried to obtain {:?} as Identifier", self);
+            }
+        }
+    }
     pub(crate) fn as_poly_args(&self) -> (u16, u16) {
         match self {
             NamespacedIdentifierPart::PolyArgs{start, end} => (*start, *end),
             NamespacedIdentifierPart::Identifier{..} => {
                 unreachable!("Tried to obtain {:?} as PolyArgs", self)
+            }
+        }
+    }
+}
 /// An identifier with optional namespaces and polymorphic variables. Note that
 /// we allow each identifier to be followed by polymorphic arguments during the
 /// parsing phase (e.g. Foo<A,B>::Bar<C,D>::Qux). But in our current language
 /// implementation we can only have valid namespaced identifier that contain one
 /// set of polymorphic arguments at the appropriate position.
 /// TODO: @tokens Reimplement/rename once we have a tokenizer
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct NamespacedIdentifier {
     pub position: InputPosition,
     pub value: Vec<u8>, // Full name as it resides in the input source
     pub poly_args: Vec<ParserTypeId>, // All poly args littered throughout the namespaced identifier
     pub parts: Vec<NamespacedIdentifierPart>, // Indices into value/poly_args
+}
 impl NamespacedIdentifier {
     /// Returns the identifier value without any of the specific polymorphic
     /// arguments.
     pub fn strip_poly_args(&self) -> Vec<u8> {
         debug_assert!(!self.parts.is_empty() && self.parts[0].is_identifier());
         let mut result = Vec::with_capacity(self.value.len());
         let mut iter = self.iter();
         let (first_ident, _) = iter.next().unwrap();
         result.extend(first_ident);
         for (ident, _) in iter.next() {
             result.push(b':');
             result.push(b':');
             result.extend(ident);
+        }
         result
+    }
     /// Returns an iterator of the elements in the namespaced identifier
     pub fn iter(&self) -> NamespacedIdentifierIter {
         return NamespacedIdentifierIter{
             identifier: self,
             element_idx: 0
+        }
+    }
     pub fn get_poly_args(&self) -> Option<&[ParserTypeId]> {
         let has_poly_args = self.parts.iter().any(|v| !v.is_identifier());
         if has_poly_args {
             Some(&self.poly_args)
         } else {
             None
+        }
+    }
     // Check if two namespaced identifiers match eachother when not considering
     // the polymorphic arguments
     pub fn matches_namespaced_identifier(&self, other: &Self) -> bool {
         let mut iter_self = self.iter();
         let mut iter_other = other.iter();
         loop {
             let val_self = iter_self.next();
             let val_other = iter_other.next();
             if val_self.is_some() != val_other.is_some() {
                 // One is longer than the other
                 return false;
+            }
             if val_self.is_none() {
                 // Both are none
                 return true;
+            }
             // Both are something
             let (val_self, _) = val_self.unwrap();
             let (val_other, _) = val_other.unwrap();
             if val_self != val_other { return false; }
+        }
+    }
     // Check if the namespaced identifier matches an identifier when not
     // considering the polymorphic arguments
     pub fn matches_identifier(&self, other: &Identifier) -> bool {
         let mut iter = self.iter();
         let (first_ident, _) = iter.next().unwrap();
         if first_ident != other.value {
             return false;
+        }
         if iter.next().is_some() {
             return false;
+        }
         return true;
+    }
+}
 /// Iterator over elements of the namespaced identifier. The element index will
 /// only ever be at the start of an identifier element.
 #[derive(Debug)]
 pub struct NamespacedIdentifierIter<'a> {
     identifier: &'a NamespacedIdentifier,
     element_idx: usize,
+}
 impl<'a> Iterator for NamespacedIdentifierIter<'a> {
     type Item = (&'a [u8], Option<&'a [ParserTypeId]>);
     fn next(&mut self) -> Option<Self::Item> {
         match self.get(self.element_idx) {
             Some((ident, poly)) => {
                 self.element_idx += 1;
                 if poly.is_some() {
                     self.element_idx += 1;
+                }
                 Some((ident, poly))
             },
             None => None
+        }
+    }
+}
 impl<'a> NamespacedIdentifierIter<'a> {
     /// Returns number of parts iterated over, may not correspond to number of
     /// times one called `next()` because returning an identifier with
     /// polymorphic arguments increments the internal counter by 2.
     pub fn num_returned(&self) -> usize {
         return self.element_idx;
+    }
     pub fn num_remaining(&self) -> usize {
         return self.identifier.parts.len() - self.element_idx;
+    }
     pub fn returned_section(&self) -> &[u8] {
         if self.element_idx == 0 { return &self.identifier.value[0..0]; }
         let last_idx = match &self.identifier.parts[self.element_idx - 1] {
             NamespacedIdentifierPart::Identifier{end, ..} => *end,
             NamespacedIdentifierPart::PolyArgs{end, ..} => *end,
         };
         return &self.identifier.value[..last_idx as usize];
+    }
     /// Returns a specific element from the namespaced identifier
     pub fn get(&self, idx: usize) -> Option<<Self as Iterator>::Item> {
         if idx >= self.identifier.parts.len() {
             return None
+        }
         let cur_part = &self.identifier.parts[idx];
         let next_part = self.identifier.parts.get(idx + 1);
         let (ident_start, ident_end) = cur_part.as_identifier();
         let poly_slice = match next_part {
             Some(part) => match part {
                 NamespacedIdentifierPart::Identifier{..} => None,
                 NamespacedIdentifierPart::PolyArgs{start, end} => Some(
                     &self.identifier.poly_args[*start as usize..*end as usize]
                 ),
             },
             None => None
         };
         Some((
             &self.identifier.value[ident_start as usize..ident_end as usize],
             poly_slice
         ))
+    }
     /// Returns the previously returend index into the parts array of the
     /// identifier.
     pub fn prev_idx(&self) -> Option<usize> {
         if self.element_idx == 0 {
             return None;
         };
         if self.identifier.parts[self.element_idx - 1].is_identifier() {
             return Some(self.element_idx - 1);
+        }
         // Previous part had polymorphic arguments, so the one before that must
         // be an identifier (if well formed)
         debug_assert!(self.element_idx >= 2 && self.identifier.parts[self.element_idx - 2].is_identifier());
         return Some(self.element_idx - 2)
+    }
     /// Returns the previously returned result from `next()`
     pub fn prev(&self) -> Option<<Self as Iterator>::Item> {
         match self.prev_idx() {
             None => None,
             Some(idx) => self.get(idx)
+        }
+    }
+}
 /// TODO: @types Remove the Message -> Byte hack at some point...
 #[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,
     // Phase 2: validation/linking (for types in function/component bodies) and
     //  type table construction (for embedded types of structs/unions)
     pub poly_args2: Vec<ParserTypeId>, // taken from identifier or inferred
     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, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
 pub enum ConcreteTypePart {
     // Markers for the use of polymorphic types within a procedure's body that
     // refer to polymorphic variables on the procedure's definition. Different
     // from markers in the `InferenceType`, these will not contain nested types.
     Marker(usize),
     // 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, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ConcreteType {
     pub(crate) parts: Vec<ConcreteTypePart>
+}
 impl Default for ConcreteType {
     fn default() -> Self {
         Self{ parts: Vec::new() }
+    }
+}
 impl ConcreteType {
     pub(crate) fn has_marker(&self) -> bool {
         self.parts
             .iter()
             .any(|p| {
                 if let ConcreteTypePart::Marker(_) = p { true } else { false }
             })
+    }
+}
 // TODO: Remove at some point
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum PrimitiveType {
     Unassigned,
     Input,
     Output,
     Message,
     Boolean,
     Byte,
     Short,
     Int,
     Long,
+}
 #[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 UNASSIGNED: Type = Type { primitive: PrimitiveType::Unassigned, array: false };
     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::Unassigned => {
                 write!(f, "unassigned")?;
+            }
             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")?;
+            }
+        }
         if self.array {
             write!(f, "[]")
         } else {
             Ok(())
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Field {
     Length,
     Symbolic(FieldSymbolic),
+}
 impl Field {
     pub fn is_length(&self) -> bool {
         match self {
             Field::Length => true,
             _ => false,
+        }
+    }
     pub fn as_symbolic(&self) -> &FieldSymbolic {
         match self {
             Field::Symbolic(v) => v,
             _ => unreachable!("attempted to get Field::Symbolic from {:?}", self)
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct FieldSymbolic {
     // Phase 1: Parser
     pub(crate) identifier: Identifier,
     // Phase 3: Typing
     pub(crate) definition: Option<DefinitionId>,
     pub(crate) field_idx: usize,
+}
 #[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 {
@@ @@ -1078,1324 +1079,1343 @@ impl VariableScope for Definition { @@
+    }
     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 == *id {
                 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)]
 pub enum EnumVariantValue {
     None,
     Integer(i64),
+}
 #[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, serde::Serialize, serde::Deserialize)]
 pub enum UnionVariantValue {
     None,
     Embedded(Vec<ParserTypeId>),
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct UnionVariantDefinition {
     pub position: InputPosition,
     pub identifier: Identifier,
     pub value: UnionVariantValue,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct UnionDefinition {
     pub this: UnionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     pub variants: Vec<UnionVariantDefinition>,
+}
 #[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 == *id {
                 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,
     // 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
     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),
     Binding(BindingExpression),
     Conditional(ConditionalExpression),
     Binary(BinaryExpression),
     Unary(UnaryExpression),
     Indexing(IndexingExpression),
     Slicing(SlicingExpression),
     Select(SelectExpression),
     Array(ArrayExpression),
     Literal(LiteralExpression),
     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) -> &LiteralExpression {
         match self {
             Expression::Literal(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::Binding(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::Literal(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::Binding(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::Literal(expr) => expr.parent = parent,
             Expression::Call(expr) => expr.parent = parent,
             Expression::Variable(expr) => expr.parent = parent,
+        }
+    }
     pub fn get_type(&self) -> &ConcreteType {
         match self {
             Expression::Assignment(expr) => &expr.concrete_type,
             Expression::Binding(expr) => &expr.concrete_type,
             Expression::Conditional(expr) => &expr.concrete_type,
             Expression::Binary(expr) => &expr.concrete_type,
             Expression::Unary(expr) => &expr.concrete_type,
             Expression::Indexing(expr) => &expr.concrete_type,
             Expression::Slicing(expr) => &expr.concrete_type,
             Expression::Select(expr) => &expr.concrete_type,
             Expression::Array(expr) => &expr.concrete_type,
             Expression::Literal(expr) => &expr.concrete_type,
             Expression::Call(expr) => &expr.concrete_type,
             Expression::Variable(expr) => &expr.concrete_type,
+        }
+    }
     // TODO: @cleanup
     pub fn get_type_mut(&mut self) -> &mut ConcreteType {
         match self {
             Expression::Assignment(expr) => &mut expr.concrete_type,
             Expression::Binding(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::Literal(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::Binding(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::Literal(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 BindingExpression {
     pub this: BindingExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub left: ExpressionId,
     pub right: ExpressionId,
     // Phase 2: linker
     pub parent: ExpressionParent,
     // Phase 3: type checking
     pub concrete_type: ConcreteType,
+}
 #[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
+    }
+}
 // TODO: @tokenizer Symbolic function calls are ambiguous with union literals
 //  that accept embedded values (although the polymorphic arguments are placed
 //  differently). To prevent double work we parse as CallExpression, and during
 //  validation we may transform the expression into a union literal.
 #[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>, // if symbolic will be determined during validation phase
     // 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 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 struct LiteralExpression {
     pub this: LiteralExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub value: Literal,
     // Phase 2: linker
     pub parent: ExpressionParent,
     // Phase 3: type checking
     pub concrete_type: ConcreteType,
+}
 impl SyntaxElement for LiteralExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 type LiteralCharacter = Vec<u8>;
 type LiteralInteger = i64; // TODO: @int_literal
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Literal {
     Null, // message
     True,
     False,
     Character(LiteralCharacter),
     Integer(LiteralInteger),
     Struct(LiteralStruct),
     Enum(LiteralEnum),
     Union(LiteralUnion),
+}
 impl Literal {
     pub(crate) fn as_struct(&self) -> &LiteralStruct {
         if let Literal::Struct(literal) = self{
             literal
         } else {
             unreachable!("Attempted to obtain {:?} as Literal::Struct", self)
+        }
+    }
     pub(crate) fn as_struct_mut(&mut self) -> &mut LiteralStruct {
         if let Literal::Struct(literal) = self{
             literal
         } else {
             unreachable!("Attempted to obtain {:?} as Literal::Struct", self)
+        }
+    }
     pub(crate) fn as_enum(&self) -> &LiteralEnum {
         if let Literal::Enum(literal) = self {
             literal
         } else {
             unreachable!("Attempted to obtain {:?} as Literal::Enum", self)
+        }
+    }
     pub(crate) fn as_union(&self) -> &LiteralUnion {
         if let Literal::Union(literal) = self {
             literal
         } else {
             unreachable!("Attempted to obtain {:?} as Literal::Union", self)
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct LiteralStructField {
     // Phase 1: parser
     pub(crate) identifier: Identifier,
     pub(crate) value: ExpressionId,
     // Phase 2: linker
     pub(crate) field_idx: usize, // in struct definition
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct LiteralStruct {
     // Phase 1: parser
     pub(crate) identifier: NamespacedIdentifier,
     pub(crate) fields: Vec<LiteralStructField>,
     // Phase 2: linker
     pub(crate) poly_args2: Vec<ParserTypeId>, // taken from identifier once linked to a definition
     pub(crate) definition: Option<DefinitionId>
+}
 // TODO: @tokenizer Enum literals are ambiguous with union literals that do not
 //  accept embedded values. To prevent double work for now we parse as a
 //  LiteralEnum, and during validation we may transform the expression into a
 //  union literal.
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct LiteralEnum {
     // Phase 1: parser
     pub(crate) identifier: NamespacedIdentifier,
     // Phase 2: linker
     pub(crate) poly_args2: Vec<ParserTypeId>, // taken from identifier once linked to a definition
     pub(crate) definition: Option<DefinitionId>,
     pub(crate) variant_idx: usize, // as present in the type table
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct LiteralUnion {
     // Phase 1: parser
     pub(crate) identifier: NamespacedIdentifier,
     pub(crate) values: Vec<ExpressionId>,
     // Phase 2: linker
     pub(crate) poly_args2: Vec<ParserTypeId>, // taken from identifier once linked to a definition
     pub(crate) definition: Option<DefinitionId>,
     pub(crate) variant_idx: usize, // as present in type table
+}
 #[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_UNION_ID: &'static str = "DefU";
 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_BINDING_EXPR_ID: &'static str = "EBnd";
 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>(self, key: &D) -> Self {
         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>(self, val: &D) -> Self {
         self.temp_val.push_str(&format!("{}", val));
         self
+    }
     fn with_debug_val<D: Debug>(self, val: &D) -> Self {
         self.temp_val.push_str(&format!("{:?}", val));
         self
+    }
     fn with_ascii_val(self, val: &[u8]) -> Self {
         self.temp_val.push_str(&*String::from_utf8_lossy(val));
         self
+    }
     fn with_opt_disp_val<D: Display>(self, val: Option<&D>) -> Self {
         match val {
             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.push_str("Some(");
                 self.temp_val.push_str(&*String::from_utf8_lossy(v));
                 self.temp_val.push(')');
             },
             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 {
             self.buffer.push_str(&format!("{}[{:04}]", prefix, id));
         } else {
             self.buffer.push_str("           ");
+        }
         for _ in 0..self.indent * INDENT {
             self.buffer.push(' ');
+        }
         // Leading dash
         self.buffer.push_str("- ");
         // Key and value
         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 {
     cur_definition: Option<DefinitionId>,
     buffer: String,
     temp1: String,
     temp2: String,
+}
 impl ASTWriter {
     pub(crate) fn new() -> Self {
         Self{
             cur_definition: None,
             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.value);
                 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.value);
                     self.kv(indent4).with_s_key("Alias").with_ascii_val(&symbol.alias.value);
                     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) {
         self.cur_definition = Some(def_id);
         let indent2 = indent + 1;
         let indent3 = indent2 + 1;
         let indent4 = indent3 + 1;
         match &heap[def_id] {
             Definition::Struct(def) => {
                 self.kv(indent).with_id(PREFIX_STRUCT_ID, def.this.0.index)
                     .with_s_key("DefinitionStruct");
                 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").with_ascii_val(&poly_var_id.value);
+                }
                 self.kv(indent2).with_s_key("Fields");
                 for field in &def.fields {
                     self.kv(indent3).with_s_key("Field");
                     self.kv(indent4).with_s_key("Name")
                         .with_ascii_val(&field.field.value);
                     self.kv(indent4).with_s_key("Type")
                         .with_custom_val(|s| write_parser_type(s, heap, &heap[field.parser_type]));
+                }
             },
             Definition::Enum(def) => {
                 self.kv(indent).with_id(PREFIX_ENUM_ID, def.this.0.index)
                     .with_s_key("DefinitionEnum");
                 self.kv(indent2).with_s_key("Name").with_ascii_val(&def.identifier.value);
                 for poly_var_id in &def.poly_vars {
                     self.kv(indent3).with_s_key("PolyVar").with_ascii_val(&poly_var_id.value);
+                }
                 self.kv(indent2).with_s_key("Variants");
                 for variant in &def.variants {
                     self.kv(indent3).with_s_key("Variant");
                     self.kv(indent4).with_s_key("Name")
                         .with_ascii_val(&variant.identifier.value);
                     let variant_value = self.kv(indent4).with_s_key("Value");
                     match &variant.value {
                         EnumVariantValue::None => variant_value.with_s_val("None"),
                         EnumVariantValue::Integer(value) => variant_value.with_disp_val(value),
                     };
+                }
             },
             Definition::Union(def) => {
                 self.kv(indent).with_id(PREFIX_UNION_ID, def.this.0.index)
                     .with_s_key("DefinitionUnion");
                 self.kv(indent2).with_s_key("Name").with_ascii_val(&def.identifier.value);
                 for poly_var_id in &def.poly_vars {
                     self.kv(indent3).with_s_key("PolyVar").with_ascii_val(&poly_var_id.value);
+                }
                 self.kv(indent2).with_s_key("Variants");
                 for variant in &def.variants {
                     self.kv(indent3).with_s_key("Variant");
                     self.kv(indent4).with_s_key("Name")
                         .with_ascii_val(&variant.identifier.value);
                     match &variant.value {
                         UnionVariantValue::None => {
                             self.kv(indent4).with_s_key("Value").with_s_val("None");
+                        }
                         UnionVariantValue::Embedded(embedded) => {
                             self.kv(indent4).with_s_key("Values");
                             for embedded in embedded {
                                 self.kv(indent4+1).with_s_key("Value")
                                     .with_custom_val(|v| write_parser_type(v, heap, &heap[*embedded]));
+                            }
+                        }
+                    }
+                }
+            }
             Definition::Function(def) => {
                 self.kv(indent).with_id(PREFIX_FUNCTION_ID, def.this.0.index)
                     .with_s_key("DefinitionFunction");
                 self.kv(indent2).with_s_key("Name").with_ascii_val(&def.identifier.value);
                 for poly_var_id in &def.poly_vars {
                     self.kv(indent3).with_s_key("PolyVar").with_ascii_val(&poly_var_id.value);
+                }
                 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").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("ParserType").with_custom_val(|w| write_parser_type(w, heap, &heap[param.parser_type]));
+    }
     fn write_poly_args(&mut self, heap: &Heap, poly_args: &[ParserTypeId], indent: usize) {
         if poly_args.is_empty() {
             return
+        }
         let indent2 = indent + 1;
         self.kv(indent).with_s_key("PolymorphicArguments");
         for poly_arg in poly_args {
             self.kv(indent2).with_s_key("Argument")
                 .with_custom_val(|v| write_parser_type(v, heap, &heap[*poly_arg]));
+        }
+    }
     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("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;
         let def_id = self.cur_definition.unwrap();
         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, def_id, &expr.concrete_type));
             },
             Expression::Binding(expr) => {
                 self.kv(indent).with_id(PREFIX_BINARY_EXPR_ID, expr.this.0.index)
                     .with_s_key("BindingExpr");
                 self.kv(indent2).with_s_key("LeftExpression");
                 self.write_expr(heap, expr.left, indent3);
                 self.kv(indent2).with_s_key("RightExpression");
                 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, def_id, &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, def_id, &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, def_id, &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, def_id, &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, def_id, &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, def_id, &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.identifier.value);
                         self.kv(indent3).with_s_key("Definition").with_opt_disp_val(field.definition.as_ref().map(|v| &v.index));
                         self.kv(indent3).with_s_key("Index").with_disp_val(&field.field_idx);
+                    }
+                }
                 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, def_id, &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, def_id, &expr.concrete_type));
             },
             Expression::Literal(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 {
                     Literal::Null => { val.with_s_val("null"); },
                     Literal::True => { val.with_s_val("true"); },
                     Literal::False => { val.with_s_val("false"); },
                     Literal::Character(data) => { val.with_ascii_val(data); },
                     Literal::Integer(data) => { val.with_disp_val(data); },
                     Literal::Struct(data) => {
                         val.with_s_val("Struct");
                         let indent4 = indent3 + 1;
                         self.write_poly_args(heap, &data.poly_args2, indent3);
                         self.kv(indent3).with_s_key("Definition").with_custom_val(|s| {
                             write_option(s, data.definition.as_ref().map(|v| &v.index));
                         });
                         for field in &data.fields {
                             self.kv(indent3).with_s_key("Field");
                             self.kv(indent4).with_s_key("Name").with_ascii_val(&field.identifier.value);
                             self.kv(indent4).with_s_key("Index").with_disp_val(&field.field_idx);
                             self.kv(indent4).with_s_key("ParserType");
                             self.write_expr(heap, field.value, indent4 + 1);
+                        }
                     },
                     Literal::Enum(data) => {
                         val.with_s_val("Enum");
                         self.write_poly_args(heap, &data.poly_args2, indent3);
                         self.kv(indent3).with_s_key("Definition").with_custom_val(|s| {
                             write_option(s, data.definition.as_ref().map(|v| &v.index))
                         });
                         self.kv(indent3).with_s_key("VariantIdx").with_disp_val(&data.variant_idx);
                     },
                     Literal::Union(data) => {
                         val.with_s_val("Union");
                         let indent4 = indent3 + 1;
                         self.write_poly_args(heap, &data.poly_args2, indent3);
                         self.kv(indent3).with_s_key("Definition").with_custom_val(|s| {
                             write_option(s, data.definition.as_ref().map(|v| &v.index));
                         });
                         self.kv(indent3).with_s_key("VariantIdx").with_disp_val(&data.variant_idx);
                         for value in &data.values {
                             self.kv(indent3).with_s_key("Value");
                             self.write_expr(heap, *value, indent4);
+                        }
+                    }
+                }
                 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, def_id, &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));
+                    }
+                }
                 self.write_poly_args(heap, &expr.poly_args, indent2);
                 // 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, def_id, &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, def_id, &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("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) => target.push_str(&format!("Some({})", v)),
         None => target.push_str("None")
     };
+}
 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.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.push_str(&String::from_utf8_lossy(&symbolic.identifier.value));
             match symbolic.variant {
                 Some(SymbolicParserTypeVariant::PolyArg(def_id, idx)) => {
                     target.push_str(&format!("{{def: {}, idx: {}}}", def_id.index, idx));
                 },
                 Some(SymbolicParserTypeVariant::Definition(def_id)) => {
                     target.push_str(&format!("{{def: {}}}", def_id.index));
                 },
                 None => {
                     target.push_str("{None}");
+                }
+            }
             embedded.extend(&symbolic.poly_args2);
+        }
     };
     if !embedded.is_empty() {
         target.push_str("<");
         for (idx, embedded_id) in embedded.into_iter().enumerate() {
             if idx != 0 { target.push_str(", "); }
             write_parser_type(target, heap, &heap[embedded_id]);
+        }
         target.push_str(">");
+    }
+}
 fn write_concrete_type(target: &mut String, heap: &Heap, def_id: DefinitionId, t: &ConcreteType) {
     use ConcreteTypePart as CTP;
     fn write_concrete_part(target: &mut String, heap: &Heap, def_id: DefinitionId, t: &ConcreteType, mut idx: usize) -> usize {
         if idx >= t.parts.len() {
             return idx;
+        }
         match &t.parts[idx] {
             CTP::Marker(marker) => {
                 // Marker points to polymorphic variable index
                 let definition = &heap[def_id];
                 let poly_var_ident = match definition {
                     Definition::Struct(_) | Definition::Enum(_) | Definition::Union(_) => unreachable!(),
                     Definition::Function(definition) => &definition.poly_vars[*marker].value,
                     Definition::Component(definition) => &definition.poly_vars[*marker].value,
                 };
                 target.push_str(&String::from_utf8_lossy(&poly_var_ident));
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
             },
             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, def_id, t, idx + 1);
                 target.push_str("[]");
             },
             CTP::Slice => {
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
                 target.push_str("[..]");
+            }
             CTP::Input => {
                 target.push_str("in<");
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
                 target.push('>');
             },
             CTP::Output => {
                 target.push_str("out<");
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
                 target.push('>')
             },
             CTP::Instance(definition_id, num_embedded) => {
                 let identifier = heap[*definition_id].identifier();
                 target.push_str(&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, def_id, t, idx + 1);
+                }
                 target.push('>');
+            }
+        }
         idx + 1
+    }
     write_concrete_part(target, heap, def_id, t, 0);
+}
 fn write_expression_parent(target: &mut String, parent: &ExpressionParent) {
     use ExpressionParent as EP;
     *target = match parent {
         EP::None => String::from("None"),
         EP::If(id) => format!("IfStmt({})", id.0.index),
         EP::While(id) => format!("WhileStmt({})", id.0.index),
         EP::Return(id) => format!("ReturnStmt({})", id.0.index),
         EP::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

@@ @@ -681,1119 +681,1122 @@ impl Value { @@
+            }
             (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::Unassigned => Type::UNASSIGNED,
             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::Unassigned => true,
             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::Unassigned => disp = &Type::UNASSIGNED,
             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 {
         use ParserTypeVariant::*;
         match &t.variant {
             Input(_) | Inferred | Symbolic(_) => true,
             _ => 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 {
         use ParserTypeVariant::*;
         match &t.variant {
             Output(_) | Inferred | Symbolic(_) => true,
             _ => 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 {
         use ParserTypeVariant::*;
         match &t.variant {
             Message | Inferred | Symbolic(_) => true,
             _ => 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 {
             Symbolic(_) | Inferred | 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 {
             Symbolic(_) | Inferred | 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 {
             Symbolic(_) | Inferred | 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 {
             Symbolic(_) | Inferred | 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 {
         use ParserTypeVariant::*;
         match &t.variant {
             Long | Inferred | Symbolic(_) => true,
             _ => 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::Binding(expr) => {
                 unimplemented!("eval binding expression");
+            }
             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::Literal(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])?;
                     if ctx.did_put(port_value.clone()) {
                         // Return bogus, replacing this at some point anyway
                         Ok(Value::Message(MessageValue(None)))
                     } else {
                         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) => {
                         // Update store
                         self.store.initialize(h, stmt.variable.upcast(), Value::Unassigned);
+                    }
                     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/lexer.rs

➞

Show inline comments

@@ @@ -496,1536 +496,1549 @@ impl Lexer<'_> { @@
             parts: Vec::new(),
         };
         // Keep consume parts separted by "::". We don't consume the trailing
         // whitespace, hence we keep a backup position at the end of the last
         // valid part of the namespaced identifier (i.e. the last ident, or the
         // last encountered polymorphic arguments).
         let mut backup_pos = self.source.pos();
         consume_part(self, h, &mut ident, &mut backup_pos)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"::") {
             self.consume_string(b"::")?;
             self.consume_whitespace(false)?;
             consume_part(self, h, &mut ident, &mut backup_pos)?;
             self.consume_whitespace(false)?;
+        }
         self.source.seek(backup_pos);
         Ok(ident)
+    }
     // Consumes a spilled namespaced identifier and returns the number of
     // namespaces that we encountered.
     fn consume_namespaced_identifier_spilled(&mut self) -> Result<usize, ParseError> {
         if self.has_reserved() {
             return Err(self.error_at_pos("Encountered reserved keyword"));
+        }
         debug_log!("consume_nsident2_spilled: {}", debug_line!(self.source));
         fn consume_part_spilled(l: &mut Lexer, backup_pos: &mut InputPosition) -> Result<(), ParseError> {
             l.consume_ident()?;
             *backup_pos = l.source.pos();
             l.consume_whitespace(false)?;
             match l.maybe_consume_poly_args_spilled_without_pos_recovery() {
                 Ok(true) => { *backup_pos = l.source.pos(); },
                 Ok(false) => {},
                 Err(_) => { return Err(l.error_at_pos("Failed to parse poly args (spilled)")) },
+            }
             Ok(())
+        }
         let mut backup_pos = self.source.pos();
         let mut num_namespaces = 1;
         consume_part_spilled(self, &mut backup_pos)?;
         self.consume_whitespace(false)?;
         while self.has_string(b"::") {
             self.consume_string(b"::")?;
             self.consume_whitespace(false)?;
             consume_part_spilled(self, &mut backup_pos)?;
             self.consume_whitespace(false)?;
             num_namespaces += 1;
+        }
         self.source.seek(backup_pos);
         Ok(num_namespaces)
+    }
     // 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_type(&mut self, h: &mut Heap, allow_inference: bool) -> Result<ParserTypeId, ParseError> {
         // 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
         debug_log!("consume_type: {}", debug_line!(self.source));
         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(ParseError::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
             self.consume_keyword(b"in")?;
             let poly_args = self.consume_polymorphic_args(h, allow_inference)?.unwrap_or_default();
             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"
                     };
                     ParseError::new_error(&self.source, pos, msg)
                 })?;
             ParserTypeVariant::Input(poly_arg)
         } else if self.has_keyword(b"out") {
             self.consume_keyword(b"out")?;
             let poly_args = self.consume_polymorphic_args(h, allow_inference)?.unwrap_or_default();
             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"
                     };
                     ParseError::new_error(&self.source, pos, msg)
                 })?;
             ParserTypeVariant::Output(poly_arg)
         } else {
             // Must be a symbolic type
             let identifier = self.consume_namespaced_identifier(h)?;
             ParserTypeVariant::Symbolic(SymbolicParserType{identifier, variant: None, poly_args2: Vec::new()})
         };
         // 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(ParseError::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(ParseError::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
         debug_log!("maybe_consume_type_spilled_...: {}", debug_line!(self.source));
         if self.has_type_keyword() {
             self.consume_any_chars();
         } else {
             let ident = self.consume_namespaced_identifier_spilled();
             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; }
         // 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
         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. Returns a boolean indicating if
     /// the poly_args list was present.
     fn maybe_consume_poly_args_spilled_without_pos_recovery(&mut self) -> Result<bool, ()> {
         debug_log!("maybe_consume_poly_args_spilled_...: {}", debug_line!(self.source));
         self.consume_comma_separated_spilled_without_pos_recovery(
             b'<', b'>', |lexer| {
                 lexer.maybe_consume_type_spilled_without_pos_recovery()
             })
+    }
     /// Consumes polymorphic arguments and its delimiters if specified. If
     /// polyargs are present then 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<Option<Vec<ParserTypeId>>, ParseError> {
         self.consume_comma_separated(
             h, b'<', b'>', "Expected the end of the polymorphic argument list",
             |lexer, heap| lexer.consume_type(heap, allow_inference)
+        )
+    }
     /// 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, h: &mut Heap) -> Result<Vec<Identifier>, ParseError> {
         let backup_pos = self.source.pos();
         match self.consume_comma_separated(
             h, b'<', b'>', "Expected the end of the polymorphic variable list",
             |lexer, _heap| lexer.consume_identifier()
         )? {
             Some(poly_vars) => Ok(poly_vars),
             None => {
                 self.source.seek(backup_pos);
                 Ok(vec!())
+            }
+        }
+    }
     // Parameters
     fn consume_parameter(&mut self, h: &mut Heap) -> Result<ParameterId, ParseError> {
         let parser_type = self.consume_type(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) -> Result<Vec<ParameterId>, ParseError> {
         match self.consume_comma_separated(
             h, b'(', b')', "Expected the end of the parameter list",
             |lexer, heap| lexer.consume_parameter(heap)
         )? {
             Some(params) => Ok(params),
             None => {
                 Err(ParseError::new_error(
                     &self.source, self.source.pos(),
                     "Expected a parameter list"
                 ))
+            }
+        }
+    }
     // ====================
     // Expressions
     // ====================
     fn consume_paren_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError> {
         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, ParseError> {
         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, ParseError> {
         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, ParseError> {
         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, ParseError> {
         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, ParseError> {
         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, ParseError> {
         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, ParseError> {
         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, ParseError> {
         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, ParseError> {
         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, ParseError> {
         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, ParseError> {
         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, ParseError> {
         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, ParseError> {
         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, ParseError> {
         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, ParseError> {
         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_binding_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError> {
         if self.has_string("let") {
             let position = self.source.pos();
             self.consume_whitespace(true)?;
             let left_expr = self.consume_expression(h)?;
             self.consume_whitespace(false)?;
             self.consume_string(b"=")?;
             self.consume_whitespace(false)?;
             let right_expr = self.consume_expression(h)?;
         } else {
             self.consume_prefix_expression(h)
+        }
+    }
     fn consume_prefix_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError> {
         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, ParseError> {
         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 {
                     let identifier = self.consume_identifier()?;
                     field = Field::Symbolic(FieldSymbolic{
                         identifier,
                         definition: None,
                         field_idx: 0,
                     });
+                }
                 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, ParseError> {
         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_builtin_literal() {
             return Ok(self.consume_builtin_literal_expression(h)?.upcast());
+        }
         if self.has_struct_literal() {
             return Ok(self.consume_struct_literal_expression(h)?.upcast());
+        }
         if self.has_call_expression() {
             return Ok(self.consume_call_expression(h)?.upcast());
+        }
         if self.has_enum_literal() {
             return Ok(self.consume_enum_literal(h)?.upcast());
+        }
         Ok(self.consume_variable_expression(h)?.upcast())
+    }
     fn consume_array_expression(&mut self, h: &mut Heap) -> Result<ArrayExpressionId, ParseError> {
         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_builtin_literal(&self) -> bool {
         is_constant(self.source.next())
             || self.has_keyword(b"null")
             || self.has_keyword(b"true")
             || self.has_keyword(b"false")
+    }
     fn consume_builtin_literal_expression(
         &mut self,
         h: &mut Heap,
     ) -> Result<LiteralExpressionId, ParseError> {
         let position = self.source.pos();
         let value;
         if self.has_keyword(b"null") {
             self.consume_keyword(b"null")?;
             value = Literal::Null;
         } else if self.has_keyword(b"true") {
             self.consume_keyword(b"true")?;
             value = Literal::True;
         } else if self.has_keyword(b"false") {
             self.consume_keyword(b"false")?;
             value = Literal::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 = Literal::Character(data);
         } else {
             if !self.has_integer() {
                 return Err(self.error_at_pos("Expected integer constant"));
+            }
             value = Literal::Integer(self.consume_integer()?);
+        }
         Ok(h.alloc_literal_expression(|this| LiteralExpression {
             this,
             position,
             value,
             parent: ExpressionParent::None,
             concrete_type: ConcreteType::default(),
         }))
+    }
     fn has_enum_literal(&mut self) -> bool {
         // An enum literal is always:
         //      maybe_a_namespace::EnumName<maybe_one_of_these>::Variant
         // So may for now be distinguished from other literals/variables by
         // first checking for struct literals and call expressions, then for
         // enum literals, finally for variable expressions. It is different
         // from a variable expression in that it _always_ contains multiple
         // elements to the enum.
         let backup_pos = self.source.pos();
         let result = match self.consume_namespaced_identifier_spilled() {
             Ok(num_namespaces) => num_namespaces > 1,
             Err(_) => false,
         };
         self.source.seek(backup_pos);
         result
+    }
     fn consume_enum_literal(&mut self, h: &mut Heap) -> Result<LiteralExpressionId, ParseError> {
         let identifier = self.consume_namespaced_identifier(h)?;
         Ok(h.alloc_literal_expression(|this| LiteralExpression{
             this,
             position: identifier.position,
             value: Literal::Enum(LiteralEnum{
                 identifier,
                 poly_args2: Vec::new(),
                 definition: None,
                 variant_idx: 0,
             }),
             parent: ExpressionParent::None,
             concrete_type: ConcreteType::default(),
         }))
+    }
     fn has_struct_literal(&mut self) -> bool {
         // A struct literal is written as:
         //      namespace::StructName<maybe_one_of_these, auto>{ field: expr }
         // We will parse up until the opening brace to see if we're dealing with
         // a struct literal.
         let backup_pos = self.source.pos();
         let result = self.consume_namespaced_identifier_spilled().is_ok() &&
             self.consume_whitespace(false).is_ok() &&
             self.source.next() == Some(b'{');
         self.source.seek(backup_pos);
         return result;
+    }
     fn consume_struct_literal_expression(&mut self, h: &mut Heap) -> Result<LiteralExpressionId, ParseError> {
         // Consume identifier and polymorphic arguments
         debug_log!("consume_struct_literal_expression: {}", debug_line!(self.source));
         let position = self.source.pos();
         let identifier = self.consume_namespaced_identifier(h)?;
         self.consume_whitespace(false)?;
         // Consume fields
         let fields = match self.consume_comma_separated(
             h, b'{', b'}', "Expected the end of the list of struct fields",
             |lexer, heap| {
                 let identifier = lexer.consume_identifier()?;
                 lexer.consume_whitespace(false)?;
                 lexer.consume_string(b":")?;
                 lexer.consume_whitespace(false)?;
                 let value = lexer.consume_expression(heap)?;
                 Ok(LiteralStructField{ identifier, value, field_idx: 0 })
+            }
         )? {
             Some(fields) => fields,
             None => return Err(ParseError::new_error(
                 self.source, self.source.pos(),
                 "A struct literal must be followed by its field values"
             ))
         };
         Ok(h.alloc_literal_expression(|this| LiteralExpression{
             this,
             position,
             value: Literal::Struct(LiteralStruct{
                 identifier,
                 fields,
                 poly_args2: Vec::new(),
                 definition: None,
             }),
             parent: ExpressionParent::None,
             concrete_type: Default::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.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, ParseError> {
         let position = self.source.pos();
         // Consume method identifier
         // TODO: @token Replace this conditional polymorphic arg parsing once we have a tokenizer.
         debug_log!("consume_call_expression: {}", debug_line!(self.source));
         let method;
         let mut consume_poly_args_explicitly = true;
         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(h)?;
             method = Method::Symbolic(MethodSymbolic{
                 identifier,
                 definition: None
             });
             consume_poly_args_explicitly = false;
         };
         // Consume polymorphic arguments
         let poly_args = if consume_poly_args_explicitly {
             self.consume_whitespace(false)?;
             self.consume_polymorphic_args(h, true)?.unwrap_or_default()
         } else {
             Vec::new()
         };
         // 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, ParseError> {
         let position = self.source.pos();
         debug_log!("consume_variable_expression: {}", debug_line!(self.source));
         // TODO: @token Reimplement when tokenizer is implemented, prevent ambiguities
         let identifier = identifier_as_namespaced(self.consume_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, ParseError> {
         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, ParseError> {
         // 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, ParseError> {
         let position = self.source.pos();
         let mut statements = Vec::new();
         self.consume_string(b"{")?;
         self.consume_whitespace(false)?;
         while self.has_local_statement() {
             let (local_id, stmt_id) = self.consume_local_statement(h)?;
             statements.push(local_id.upcast());
             if let Some(stmt_id) = stmt_id {
                 statements.push(stmt_id.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, Option<ExpressionStatementId>), ParseError> {
         if self.has_keyword(b"channel") {
             let local_id = self.consume_channel_statement(h)?.upcast();
             Ok((local_id, None))
         } else {
             let (memory_id, stmt_id) = self.consume_memory_statement(h)?;
             Ok((memory_id.upcast(), Some(stmt_id)))
+        }
+    }
     fn consume_channel_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<ChannelStatementId, ParseError> {
         // Consume channel statement and polymorphic argument if specified.
         // Needs a tiny bit of special parsing to ensure the right amount of
         // whitespace is present.
         let position = self.source.pos();
         self.consume_keyword(b"channel")?;
         let expect_whitespace = self.source.next() != Some(b'<');
         self.consume_whitespace(expect_whitespace)?;
         let poly_args = self.consume_polymorphic_args(h, true)?.unwrap_or_default();
         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(ParseError::new_error(
                 &self.source, self.source.pos(),
                 "port construction using 'channel' accepts up to 1 polymorphic argument"
             ))
         };
         self.consume_whitespace(false)?;
         // 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
         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, ExpressionStatementId), ParseError> {
         let position = self.source.pos();
         let parser_type = self.consume_type(h, true)?;
         self.consume_whitespace(true)?;
         let identifier = self.consume_identifier()?;
         self.consume_whitespace(false)?;
         let assignment_position = self.source.pos();
         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: identifier.clone(),
             relative_pos_in_block: 0
         });
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         // Transform into the variable declaration, followed by an assignment
         let memory_stmt_id = h.alloc_memory_statement(|this| MemoryStatement {
             this,
             position,
             variable,
             next: None,
         });
         let variable_expr_id = h.alloc_variable_expression(|this| VariableExpression{
             this,
             position: identifier.position.clone(),
             identifier: identifier_as_namespaced(identifier),
             declaration: None,
             parent: ExpressionParent::None,
             concrete_type: Default::default()
         });
         let assignment_expr_id = h.alloc_assignment_expression(|this| AssignmentExpression{
             this,
             position: assignment_position,
             left: variable_expr_id.upcast(),
             operation: AssignmentOperator::Set,
             right: initial,
             parent: ExpressionParent::None,
             concrete_type: Default::default()
         });
         let assignment_stmt_id = h.alloc_expression_statement(|this| ExpressionStatement{
             this,
             position,
             expression: assignment_expr_id.upcast(),
             next: None
         });
         Ok((memory_stmt_id, assignment_stmt_id))
+    }
     fn consume_labeled_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<LabeledStatementId, ParseError> {
         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, ParseError> {
         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, ParseError> {
         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, ParseError> {
         let position = self.source.pos();
         self.consume_keyword(b"while")?;

src/protocol/tests/parser_monomorphs.rs

➞

Show inline comments

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

src/protocol/tests/parser_validation.rs

➞

Show inline comments

 /// parser_validation.rs
 ///
 /// Simple tests for the validation phase
 /// TODO: If semicolon behind struct definition: should be fine...
 use super::*;
 #[test]
 fn test_correct_struct_instance() {
     Tester::new_single_source_expect_ok(
         "single field",
+        "
         struct Foo { int a }
         Foo bar(int arg) { return Foo{ a: arg }; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple fields",
+        "
         struct Foo { int a, int b }
         Foo bar(int arg) { return Foo{ a: arg, b: arg }; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "single field, explicit polymorph",
+        "
         struct Foo<T>{ T field }
         Foo<int> bar(int arg) { return Foo<int>{ field: arg }; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "single field, implicit polymorph",
+        "
         struct Foo<T>{ T field }
         int bar(int arg) {
             auto thingo = Foo{ field: arg };
             return arg;
+        }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple fields, same explicit polymorph",
+        "
         struct Pair<T1, T2>{ T1 first, T2 second }
         int bar(int arg) {
             auto qux = Pair<int, int>{ first: arg, second: arg };
             return arg;
+        }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple fields, same implicit polymorph",
+        "
         struct Pair<T1, T2>{ T1 first, T2 second }
         int bar(int arg) {
             auto wup = Pair{ first: arg, second: arg };
             return arg;
+        }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple fields, different explicit polymorph",
+        "
         struct Pair<T1, T2>{ T1 first, T2 second }
         int bar(int arg1, byte arg2) {
             auto shoo = Pair<int, byte>{ first: arg1, second: arg2 };
             return arg1;
+        }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple fields, different implicit polymorph",
+        "
         struct Pair<T1, T2>{ T1 first, T2 second }
         int bar(int arg1, byte arg2) {
             auto shrubbery = Pair{ first: arg1, second: arg2 };
             return arg1;
+        }
+        "
     );
+}
 #[test]
 fn test_incorrect_struct_instance() {
     Tester::new_single_source_expect_err(
         "reused field in definition",
         "struct Foo{ int a, byte a }"
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "a }")
         .assert_msg_has(0, "defined more than once")
         .assert_occurs_at(1, "a, ")
         .assert_msg_has(1, "other struct field");
     });
     Tester::new_single_source_expect_err(
         "reused field in instance",
+        "
         struct Foo{ int a, int b }
         int bar() {
             auto foo = Foo{ a: 5, a: 3 };
             return 0;
+        }
+        "
     ).error(|e| { e
         .assert_occurs_at(0, "a: 3")
         .assert_msg_has(0, "field is specified more than once");
     });
     Tester::new_single_source_expect_err(
         "missing field",
+        "
         struct Foo { int a, int b }
         int bar() {
             auto foo = Foo{ a: 2 };
             return 0;
+        }
+        "
     ).error(|e| { e
         .assert_occurs_at(0, "Foo{")
         .assert_msg_has(0, "'b' is missing");
     });
     Tester::new_single_source_expect_err(
         "missing fields",
+        "
         struct Foo { int a, int b, int c }
         int bar() {
             auto foo = Foo{ a: 2 };
             return 0;
+        }
+        "
     ).error(|e| { e
         .assert_occurs_at(0, "Foo{")
         .assert_msg_has(0, "[b, c] are missing");
     });
+}
 #[test]
 fn test_correct_enum_instance() {
     Tester::new_single_source_expect_ok(
         "single variant",
+        "
         enum Foo { A }
         Foo bar() { return Foo::A; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple variants",
+        "
         enum Foo { A=15, B = 0xF }
         Foo bar() { auto a = Foo::A; return Foo::B; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "explicit single polymorph",
+        "
         enum Foo<T>{ A }
         Foo<int> bar() { return Foo::A; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "explicit multi-polymorph",
+        "
         enum Foo<A, B>{ A, B }
         Foo<byte, int> bar() { return Foo::B; }
+        "
     );
+}
 #[test]
 fn test_incorrect_enum_instance() {
     Tester::new_single_source_expect_err(
         "variant name reuse",
+        "
         enum Foo { A, A }
         Foo bar() { return Foo::A; }
+        "
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "A }")
         .assert_msg_has(0, "defined more than once")
         .assert_occurs_at(1, "A, ")
         .assert_msg_has(1, "other enum variant is defined here");
     });
     Tester::new_single_source_expect_err(
         "undefined variant",
+        "
         enum Foo { A }
         Foo bar() { return Foo::B; }
+        "
     ).error(|e| { e
         .assert_num(1)
         .assert_msg_has(0, "variant 'B' does not exist on the enum 'Foo'");
     });
+}
 #[test]
 fn test_correct_union_instance() {
     Tester::new_single_source_expect_ok(
         "single tag",
+        "
         union Foo { A }
         Foo bar() { return Foo::A; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple tags",
+        "
         union Foo { A, B }
         Foo bar() { return Foo::B; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "single embedded",
+        "
         union Foo { A(int) }
         Foo bar() { return Foo::A(5); }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple embedded",
+        "
         union Foo { A(int), B(byte) }
         Foo bar() { return Foo::B(2); }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple values in embedded",
+        "
         union Foo { A(int, byte) }
         Foo bar() { return Foo::A(0, 2); }
+        "
     );
     Tester::new_single_source_expect_ok(
         "mixed tag/embedded",
+        "
         union OptionInt { None, Some(int) }
         OptionInt bar() { return OptionInt::Some(3); }
+        "
     );
     Tester::new_single_source_expect_ok(
         "single polymorphic var",
+        "
         union Option<T> { None, Some(T) }
         Option<int> bar() { return Option::Some(3); }"
     );
     Tester::new_single_source_expect_ok(
         "multiple polymorphic vars",
+        "
         union Result<T, E> { Ok(T), Err(E), }
         Result<int, byte> bar() { return Result::Ok(3); }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple polymorphic in one variant",
+        "
         union MaybePair<T1, T2>{ None, Some(T1, T2) }
         MaybePair<byte, int> bar() { return MaybePair::Some(1, 2); }
+        "
     );
+}
 #[test]
 fn test_incorrect_union_instance() {
     Tester::new_single_source_expect_err(
         "tag-variant name reuse",
+        "
         union Foo{ A, A }
+        "
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "A }")
         .assert_msg_has(0, "union variant is defined more than once")
         .assert_occurs_at(1, "A, ")
         .assert_msg_has(1, "other union variant");
     });
     Tester::new_single_source_expect_err(
         "embedded-variant name reuse",
+        "
         union Foo{ A(int), A(byte) }
+        "
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "A(byte)")
         .assert_msg_has(0, "union variant is defined more than once")
         .assert_occurs_at(1, "A(int)")
         .assert_msg_has(1, "other union variant");
     });
     Tester::new_single_source_expect_err(
         "undefined variant",
+        "
         union Silly{ Thing(byte) }
         Silly bar() { return Silly::Undefined(5); }
+        "
     ).error(|e| { e
         .assert_msg_has(0, "variant 'Undefined' does not exist on the union 'Silly'");
     });
     Tester::new_single_source_expect_err(
         "using tag instead of embedded",
+        "
         union Foo{ A(int) }
         Foo bar() { return Foo::A; }
+        "
     ).error(|e| { e
         .assert_msg_has(0, "variant 'A' of union 'Foo' expects 1 embedded values, but 0 were");
     });
     Tester::new_single_source_expect_err(
         "using embedded instead of tag",
+        "
         union Foo{ A }
         Foo bar() { return Foo::A(3); }
+        "
     ).error(|e| { e
         .assert_msg_has(0, "The variant 'A' of union 'Foo' expects 0");
     });
     Tester::new_single_source_expect_err(
         "wrong embedded value",
+        "
         union Foo{ A(int) }
         Foo bar() { return Foo::A(false); }
+        "
     ).error(|e| { e
         .assert_occurs_at(0, "Foo::A")
         .assert_msg_has(0, "Failed to fully resolve")
         .assert_occurs_at(1, "false")
         .assert_msg_has(1, "has been resolved to 'int'")
         .assert_msg_has(1, "has been resolved to 'bool'");
     });
+}
@@ \ No newline at end of file @@

Changeset was too big and was cut off... Show full diff anyway

0 comments (0 inline, 0 general)