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

Changeset - d36ad4f5458b

Parent rev.

Child rev.

[Not reviewed]

0 7 1

mh - 4 years ago 2021-05-12 10:15:31
contact@maxhenger.nl

WIP on fixing evaluator bugs

8 files changed with 449 insertions and 92 deletions:

src/protocol/eval/executor.rs

src/protocol/eval/mod.rs

src/protocol/eval/store.rs

src/protocol/eval/value.rs

104

src/protocol/tests/eval_calls.rs

src/protocol/tests/eval_operators.rs

167

src/protocol/tests/mod.rs

src/protocol/tests/utils.rs

0 comments (0 inline, 0 general)

src/protocol/eval/executor.rs

➞

Show inline comments

 use std::collections::VecDeque;
 use super::value::*;
 use super::store::*;
 use crate::protocol::*;
 use crate::protocol::ast::*;
 macro_rules! debug_enabled { () => { true }; }
 macro_rules! debug_log {
     ($format:literal) => {
         enabled_debug_print!(true, "exec", $format);
     };
     ($format:literal, $($args:expr),*) => {
         enabled_debug_print!(true, "exec", $format, $($args),*);
     };
+}
 #[derive(Debug, Clone)]
 pub(crate) enum ExprInstruction {
     EvalExpr(ExpressionId),
     PushValToFront,
+}
 #[derive(Debug, Clone)]
 pub(crate) struct Frame {
     definition: DefinitionId,
     position: StatementId,
     expr_stack: VecDeque<ExprInstruction>, // hack for expression evaluation, evaluated by popping from back
     expr_values: VecDeque<Value>, // hack for expression results, evaluated by popping from front/back
+}
 impl Frame {
     /// Creates a new execution frame. Does not modify the stack in any way.
     pub fn new(heap: &Heap, definition_id: DefinitionId) -> Self {
         let definition = &heap[definition_id];
         let first_statement = match definition {
             Definition::Component(definition) => definition.body,
             Definition::Function(definition) => definition.body,
             _ => unreachable!("initializing frame with {:?} instead of a function/component", definition),
         };
         Frame{
             definition: definition_id,
             position: first_statement.upcast(),
             expr_stack: VecDeque::with_capacity(128),
             expr_values: VecDeque::with_capacity(128),
+        }
+    }
     /// Prepares a single expression for execution. This involves walking the
     /// expression tree and putting them in the `expr_stack` such that
     /// continuously popping from its back will evaluate the expression. The
     /// results of each expression will be stored by pushing onto `expr_values`.
     pub fn prepare_single_expression(&mut self, heap: &Heap, expr_id: ExpressionId) {
         debug_assert!(self.expr_stack.is_empty());
         self.expr_values.clear(); // May not be empty if last expression result(s) were discarded
         self.serialize_expression(heap, expr_id);
+    }
     /// Prepares multiple expressions for execution (i.e. evaluating all
     /// function arguments or all elements of an array/union literal). Per
     /// expression this works the same as `prepare_single_expression`. However
     /// after each expression is evaluated we insert a `PushValToFront`
     /// instruction
     pub fn prepare_multiple_expressions(&mut self, heap: &Heap, expr_ids: &[ExpressionId]) {
         debug_assert!(self.expr_stack.is_empty());
         self.expr_values.clear();
         for expr_id in expr_ids {
             self.expr_stack.push_back(ExprInstruction::PushValToFront);
             self.serialize_expression(heap, *expr_id);
+        }
+    }
     /// Performs depth-first serialization of expression tree. Let's not care
     /// about performance for a temporary runtime implementation
     fn serialize_expression(&mut self, heap: &Heap, id: ExpressionId) {
         self.expr_stack.push_back(ExprInstruction::EvalExpr(id));
         match &heap[id] {
             Expression::Assignment(expr) => {
                 self.serialize_expression(heap, expr.left);
                 self.serialize_expression(heap, expr.right);
             },
             Expression::Binding(expr) => {
                 todo!("implement binding expression");
             },
             Expression::Conditional(expr) => {
                 self.serialize_expression(heap, expr.test);
             },
             Expression::Binary(expr) => {
                 self.serialize_expression(heap, expr.left);
                 self.serialize_expression(heap, expr.right);
             },
             Expression::Unary(expr) => {
                 self.serialize_expression(heap, expr.expression);
             },
             Expression::Indexing(expr) => {
                 self.serialize_expression(heap, expr.index);
                 self.serialize_expression(heap, expr.subject);
             },
             Expression::Slicing(expr) => {
                 self.serialize_expression(heap, expr.from_index);
                 self.serialize_expression(heap, expr.to_index);
                 self.serialize_expression(heap, expr.subject);
             },
             Expression::Select(expr) => {
                 self.serialize_expression(heap, expr.subject);
             },
             Expression::Literal(expr) => {
                 // Here we only care about literals that have subexpressions
                 match &expr.value {
                     Literal::Null | Literal::True | Literal::False |
                     Literal::Character(_) | Literal::String(_) |
                     Literal::Integer(_) | Literal::Enum(_) => {
                         // No subexpressions
                     },
                     Literal::Struct(literal) => {
                         for field in &literal.fields {
                             self.expr_stack.push_back(ExprInstruction::PushValToFront);
                             self.serialize_expression(heap, field.value);
+                        }
                     },
                     Literal::Union(literal) => {
                         for value_expr_id in &literal.values {
                             self.expr_stack.push_back(ExprInstruction::PushValToFront);
                             self.serialize_expression(heap, *value_expr_id);
+                        }
                     },
                     Literal::Array(value_expr_ids) => {
                         for value_expr_id in value_expr_ids {
                             self.expr_stack.push_back(ExprInstruction::PushValToFront);
                             self.serialize_expression(heap, *value_expr_id);
+                        }
+                    }
+                }
             },
             Expression::Call(expr) => {
                 for arg_expr_id in &expr.arguments {
                     self.expr_stack.push_back(ExprInstruction::PushValToFront);
                     self.serialize_expression(heap, *arg_expr_id);
+                }
             },
             Expression::Variable(expr) => {
                 // No subexpressions
+            }
+        }
+    }
+}
 type EvalResult = Result<EvalContinuation, ()>;
 pub enum EvalContinuation {
     Stepping,
     Inconsistent,
     Terminal,
     SyncBlockStart,
     SyncBlockEnd,
     NewComponent(DefinitionId, ValueGroup),
     BlockFires(Value),
     BlockGet(Value),
     Put(Value, Value),
+}
 // Note: cloning is fine, methinks. cloning all values and the heap regions then
 // we end up with valid "pointers" to heap regions.
 #[derive(Debug, Clone)]
 pub struct Prompt {
     pub(crate) frames: Vec<Frame>,
     pub(crate) store: Store,
+}
 impl Prompt {
     pub fn new(heap: &Heap, def: DefinitionId, args: ValueGroup) -> Self {
         let mut prompt = Self{
             frames: Vec::new(),
             store: Store::new(),
         };
         prompt.frames.push(Frame::new(heap, def));
         args.into_store(&mut prompt.store);
         prompt
+    }
     pub(crate) fn step(&mut self, heap: &Heap, ctx: &mut EvalContext) -> EvalResult {
         // Helper function to transfer multiple values from the expression value
         // array into a heap region (e.g. constructing arrays or structs).
         fn transfer_expression_values_front_into_heap(cur_frame: &mut Frame, store: &mut Store, num_values: usize) -> HeapPos {
             let heap_pos = store.alloc_heap();
             // Do the transformation first (because Rust...)
             for val_idx in 0..num_values {
                 cur_frame.expr_values[val_idx] = store.read_take_ownership(cur_frame.expr_values[val_idx].clone());
+            }
             // And now transfer to the heap region
             let values = &mut store.heap_regions[heap_pos as usize].values;
             debug_assert!(values.is_empty());
             values.reserve(num_values);
             for _ in 0..num_values {
                 values.push(cur_frame.expr_values.pop_front().unwrap());
+            }
             heap_pos
+        }
         // Checking if we're at the end of execution
         let cur_frame = self.frames.last_mut().unwrap();
         if cur_frame.position.is_invalid() {
             if heap[cur_frame.definition].is_function() {
                 todo!("End of function without return, return an evaluation error");
+            }
             return Ok(EvalContinuation::Terminal);
+        }
         debug_log!("Taking step in '{}'", heap[cur_frame.definition].identifier().value.as_str());
         // Execute all pending expressions
         while !cur_frame.expr_stack.is_empty() {
             let next = cur_frame.expr_stack.pop_back().unwrap();
             debug_log!("Expr stack: {:?}", next);
             match next {
                 ExprInstruction::PushValToFront => {
                     cur_frame.expr_values.rotate_right(1);
                 },
                 ExprInstruction::EvalExpr(expr_id) => {
                     let expr = &heap[expr_id];
                     match expr {
                         Expression::Assignment(expr) => {
                             // TODO: Stuff goes wrong here, either make these
                             //  utilities do the alloc/dealloc, or let it all be
                             //  done here.
                             let to = cur_frame.expr_values.pop_back().unwrap().as_ref();
                             let rhs = cur_frame.expr_values.pop_back().unwrap();
                             let rhs_heap_pos = rhs.get_heap_pos();
+                            // let rhs_heap_pos = rhs.get_heap_pos();
                             apply_assignment_operator(&mut self.store, to, expr.operation, rhs);
                             cur_frame.expr_values.push_back(self.store.read_copy(to));
                             self.store.drop_value(rhs_heap_pos);
+                            // self.store.drop_value(rhs_heap_pos);
                         },
                         Expression::Binding(_expr) => {
                             todo!("Binding expression");
                         },
                         Expression::Conditional(expr) => {
                             // Evaluate testing expression, then extend the
                             // expression stack with the appropriate expression
                             let test_result = cur_frame.expr_values.pop_back().unwrap().as_bool();
                             if test_result {
                                 cur_frame.serialize_expression(heap, expr.true_expression);
                             } else {
                                 cur_frame.serialize_expression(heap, expr.false_expression);
+                            }
                         },
                         Expression::Binary(expr) => {
                             let lhs = cur_frame.expr_values.pop_back().unwrap();
                             let rhs = cur_frame.expr_values.pop_back().unwrap();
                             let result = apply_binary_operator(&mut self.store, &lhs, expr.operation, &rhs);
                             cur_frame.expr_values.push_back(result);
                             self.store.drop_value(lhs.get_heap_pos());
                             self.store.drop_value(rhs.get_heap_pos());
                         },
                         Expression::Unary(expr) => {
                             let val = cur_frame.expr_values.pop_back().unwrap();
                             let result = apply_unary_operator(&mut self.store, expr.operation, &val);
                             cur_frame.expr_values.push_back(result);
                             self.store.drop_value(val.get_heap_pos());
                         },
                         Expression::Indexing(expr) => {
                             // TODO: Out of bounds checking
                             // Evaluate index. Never heap allocated so we do
                             // not have to drop it.
                             let index = cur_frame.expr_values.pop_back().unwrap();
                             let index = self.store.maybe_read_ref(&index);
                             debug_assert!(index.is_integer());
                             let index = if index.is_signed_integer() {
                                 index.as_signed_integer() as u32
                             } else {
                                 index.as_unsigned_integer() as u32
                             };
                             // TODO: This is probably wrong, we're dropping the
                             //  heap while refering to an element...
                             let subject = cur_frame.expr_values.pop_back().unwrap();
                             let subject_heap_pos = subject.get_heap_pos();
                             let heap_pos = match subject {
                                 Value::Ref(value_ref) => self.store.read_ref(value_ref).as_array(),
                                 Value::Ref(value_ref) => {
                                     println!("DEBUG: Called with {:?}", subject);
                                     let result = self.store.read_ref(value_ref);
                                     println!("DEBUG: And got {:?}", result);
                                     result.as_array()
                                 },
                                 val => val.as_array(),
                             };
                             cur_frame.expr_values.push_back(Value::Ref(ValueId::Heap(heap_pos, index)));
                             self.store.drop_value(subject_heap_pos);
                         },
                         Expression::Slicing(expr) => {
                             // TODO: Out of bounds checking
                             todo!("implement slicing")
                         },
                         Expression::Select(expr) => {
                             let subject= cur_frame.expr_values.pop_back().unwrap();
                             let heap_pos = match &subject {
                                 Value::Ref(value_ref) => self.store.read_ref(*value_ref).as_struct(),
                                 subject => subject.as_struct(),
                             };
                             cur_frame.expr_values.push_back(Value::Ref(ValueId::Heap(heap_pos, expr.field.as_symbolic().field_idx as u32)));
                             self.store.drop_value(subject.get_heap_pos());
                         },
                         Expression::Literal(expr) => {
                             let value = match &expr.value {
                                 Literal::Null => Value::Null,
                                 Literal::True => Value::Bool(true),
                                 Literal::False => Value::Bool(false),
                                 Literal::Character(lit_value) => Value::Char(*lit_value),
                                 Literal::String(lit_value) => {
                                     let heap_pos = self.store.alloc_heap();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     let value = lit_value.as_str();
                                     debug_assert!(values.is_empty());
                                     values.reserve(value.len());
                                     for character in value.as_bytes() {
                                         debug_assert!(character.is_ascii());
                                         values.push(Value::Char(*character as char));
+                                    }
                                     Value::String(heap_pos)
+                                }
                                 Literal::Integer(lit_value) => {
                                     use ConcreteTypePart as CTP;
                                     debug_assert_eq!(expr.concrete_type.parts.len(), 1);
                                     match expr.concrete_type.parts[0] {
                                         CTP::UInt8  => Value::UInt8(lit_value.unsigned_value as u8),
                                         CTP::UInt16 => Value::UInt16(lit_value.unsigned_value as u16),
                                         CTP::UInt32 => Value::UInt32(lit_value.unsigned_value as u32),
                                         CTP::UInt64 => Value::UInt64(lit_value.unsigned_value as u64),
                                         CTP::SInt8  => Value::SInt8(lit_value.unsigned_value as i8),
                                         CTP::SInt16 => Value::SInt16(lit_value.unsigned_value as i16),
                                         CTP::SInt32 => Value::SInt32(lit_value.unsigned_value as i32),
                                         CTP::SInt64 => Value::SInt64(lit_value.unsigned_value as i64),
                                         _ => unreachable!(),
+                                    }
+                                }
                                 Literal::Struct(lit_value) => {
                                     let heap_pos = self.store.alloc_heap();
                                     let num_fields = lit_value.fields.len();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     debug_assert!(values.is_empty());
                                     values.reserve(num_fields);
                                     for _ in 0..num_fields {
                                         values.push(cur_frame.expr_values.pop_front().unwrap());
+                                    }
                                     let heap_pos = transfer_expression_values_front_into_heap(
                                         cur_frame, &mut self.store, lit_value.fields.len()
                                     );
                                     Value::Struct(heap_pos)
+                                }
                                 Literal::Enum(lit_value) => {
                                     Value::Enum(lit_value.variant_idx as i64)
+                                }
                                 Literal::Union(lit_value) => {
                                     let heap_pos = self.store.alloc_heap();
                                     let num_values = lit_value.values.len();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     debug_assert!(values.is_empty());
                                     values.reserve(num_values);
                                     for _ in 0..num_values {
                                         values.push(cur_frame.expr_values.pop_front().unwrap());
+                                    }
                                     let heap_pos = transfer_expression_values_front_into_heap(
                                         cur_frame, &mut self.store, lit_value.values.len()
                                     );
                                     Value::Union(lit_value.variant_idx as i64, heap_pos)
+                                }
                                 Literal::Array(lit_value) => {
                                     let heap_pos = self.store.alloc_heap();
                                     let num_values = lit_value.len();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     debug_assert!(values.is_empty());
                                     values.reserve(num_values);
                                     for _ in 0..num_values {
                                         values.push(cur_frame.expr_values.pop_front().unwrap())
+                                    }
                                     let heap_pos = transfer_expression_values_front_into_heap(
                                         cur_frame, &mut self.store, lit_value.len()
                                     );
                                     Value::Array(heap_pos)
+                                }
                             };
                             cur_frame.expr_values.push_back(value);
                         },
                         Expression::Call(expr) => {
                             // Push a new frame. Note that all expressions have
                             // been pushed to the front, so they're in the order
                             // of the definition.
                             let num_args = expr.arguments.len();
-                            // Prepare stack for a new frame
+                            // Determine stack boundaries
                             let cur_stack_boundary = self.store.cur_stack_boundary;
                             self.store.cur_stack_boundary = self.store.stack.len();
                             let new_stack_boundary = self.store.stack.len();
                             // Push new boundary and function arguments for new frame
                             self.store.stack.push(Value::PrevStackBoundary(cur_stack_boundary as isize));
                             for _ in 0..num_args {
                                 self.store.stack.push(cur_frame.expr_values.pop_front().unwrap());
                                 let argument = self.store.read_take_ownership(cur_frame.expr_values.pop_front().unwrap());
                                 self.store.stack.push(argument);
+                            }
                             // Push the new frame
                             self.frames.push(Frame::new(heap, expr.definition));
                             self.store.cur_stack_boundary = new_stack_boundary;
                             // To simplify the logic a little bit we will now
                             // return and ask our caller to call us again
                             return Ok(EvalContinuation::Stepping);
                         },
                         Expression::Variable(expr) => {
                             let variable = &heap[expr.declaration.unwrap()];
                             cur_frame.expr_values.push_back(Value::Ref(ValueId::Stack(variable.unique_id_in_scope as StackPos)));
+                        }
+                    }
+                }
+            }
+        }
         debug_log!("Frame [{:?}] at {:?}, stack size = {}", cur_frame.definition, cur_frame.position, self.store.stack.len());
         if debug_enabled!() {
             debug_log!("Stack:");
             for (stack_idx, stack_val) in self.store.stack.iter().enumerate() {
                 debug_log!("  [{:03}] {:?}", stack_idx, stack_val);
+            }
             debug_log!("Heap:");
             for (heap_idx, heap_region) in self.store.heap_regions.iter().enumerate() {
                 let is_free = self.store.free_regions.iter().any(|idx| *idx as usize == heap_idx);
                 debug_log!("  [{:03}] in_use: {}, len: {}, vals: {:?}", heap_idx, !is_free, heap_region.values.len(), &heap_region.values);
+            }
+        }
         // No (more) expressions to evaluate. So evaluate statement (that may
         // depend on the result on the last evaluated expression(s))
         let stmt = &heap[cur_frame.position];
         let return_value = match stmt {
             Statement::Block(stmt) => {
                 // Reserve space on stack, but also make sure excess stack space
                 // is cleared
                 self.store.clear_stack(stmt.first_unique_id_in_scope as usize);
                 self.store.reserve_stack(stmt.next_unique_id_in_scope as usize);
                 cur_frame.position = stmt.statements[0];
                 Ok(EvalContinuation::Stepping)
             },
             Statement::EndBlock(stmt) => {
                 let block = &heap[stmt.start_block];
                 self.store.clear_stack(block.first_unique_id_in_scope as usize);
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Memory(stmt) => {
                         let variable = &heap[stmt.variable];
                         self.store.write(ValueId::Stack(variable.unique_id_in_scope as u32), Value::Unassigned);
                         cur_frame.position = stmt.next;
                     },
                     LocalStatement::Channel(stmt) => {
                         let [from_value, to_value] = ctx.new_channel();
                         self.store.write(ValueId::Stack(heap[stmt.from].unique_id_in_scope as u32), from_value);
                         self.store.write(ValueId::Stack(heap[stmt.to].unique_id_in_scope as u32), to_value);
                         cur_frame.position = stmt.next;
+                    }
+                }
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Labeled(stmt) => {
                 cur_frame.position = stmt.body;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::If(stmt) => {
                 debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for if statement");
                 let test_value = cur_frame.expr_values.pop_back().unwrap().as_bool();
                 if test_value {
                     cur_frame.position = stmt.true_body.upcast();
                 } else if let Some(false_body) = stmt.false_body {
                     cur_frame.position = false_body.upcast();
                 } else {
                     // Not true, and no false body
                     cur_frame.position = stmt.end_if.upcast();
+                }
                 Ok(EvalContinuation::Stepping)
             },
             Statement::EndIf(stmt) => {
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::While(stmt) => {
                 debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for while statement");
                 let test_value = cur_frame.expr_values.pop_back().unwrap().as_bool();
                 if test_value {
                     cur_frame.position = stmt.body.upcast();
                 } else {
                     cur_frame.position = stmt.end_while.upcast();
+                }
                 Ok(EvalContinuation::Stepping)
             },
             Statement::EndWhile(stmt) => {
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Break(stmt) => {
                 cur_frame.position = stmt.target.unwrap().upcast();
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Continue(stmt) => {
                 cur_frame.position = stmt.target.unwrap().upcast();
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Synchronous(stmt) => {
                 cur_frame.position = stmt.body.upcast();
                 Ok(EvalContinuation::SyncBlockStart)
             },
             Statement::EndSynchronous(stmt) => {
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::SyncBlockEnd)
             },
             Statement::Return(stmt) => {
                 debug_assert!(heap[cur_frame.definition].is_function());
                 debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for return statement");
                 // The preceding frame has executed a call, so is expecting the
                 // return expression on its expression value stack. Note that
                 // we may be returning a reference to something on our stack,
                 // so we need to read that value and clone it.
                 let return_value = cur_frame.expr_values.pop_back().unwrap();
                 println!("DEBUG: Pre-ret val {:?}", &return_value);
                 let return_value = match return_value {
                     Value::Ref(value_id) => self.store.read_copy(value_id),
                     _ => return_value,
                 };
                 println!("DEBUG: Pos-ret val {:?}", &return_value);
-                let prev_stack_idx = self.store.stack[self.store.cur_stack_boundary].as_stack_boundary();
+                // Pre-emptively pop our stack frame
                 self.frames.pop();
                 // Clean up our section of the stack
                 self.store.clear_stack(0);
                 let prev_stack_idx = self.store.stack.pop().unwrap().as_stack_boundary();
                 // TODO: Temporary hack for testing, remove at some point
                 if self.frames.is_empty() {
                     debug_assert!(prev_stack_idx == -1);
                     self.store.stack[0] = return_value;
                     debug_assert!(self.store.stack.len() == 0);
                     self.store.stack.push(return_value);
                     return Ok(EvalContinuation::Terminal);
+                }
                 debug_assert!(prev_stack_idx >= 0);
                 // Return to original state of stack frame
                 self.store.cur_stack_boundary = prev_stack_idx as usize;
                 let cur_frame = self.frames.last_mut().unwrap();
                 cur_frame.expr_values.push_back(return_value);
                 // Immediately return, we don't care about the current frame
                 // anymore and there is nothing left to evaluate
                 return Ok(EvalContinuation::Stepping);
             },
             Statement::Goto(stmt) => {
                 cur_frame.position = stmt.target.unwrap().upcast();
                 Ok(EvalContinuation::Stepping)
             },
             Statement::New(stmt) => {
                 let call_expr = &heap[stmt.expression];
                 debug_assert!(heap[call_expr.definition].is_component());
                 debug_assert_eq!(
                     cur_frame.expr_values.len(), heap[call_expr.definition].parameters().len(),
                     "mismatch in expr stack size and number of arguments for new statement"
                 );
                 // Note that due to expression value evaluation they exist in
                 // reverse order on the stack.
                 // TODO: Revise this code, keep it as is to be compatible with current runtime
                 let mut args = Vec::new();
                 while let Some(value) = cur_frame.expr_values.pop_front() {
                     args.push(value);
+                }
                 // Construct argument group, thereby copying heap regions
                 let argument_group = ValueGroup::from_store(&self.store, &args);
                 // Clear any heap regions
                 for arg in &args {
                     self.store.drop_value(arg.get_heap_pos());
+                }
                 cur_frame.position = stmt.next;
                 todo!("Make sure this is handled correctly, transfer 'heap' values to another Prompt");
                 Ok(EvalContinuation::NewComponent(call_expr.definition, argument_group))
             },
             Statement::Expression(stmt) => {
                 // The expression has just been completely evaluated. Some
                 // values might have remained on the expression value stack.
                 cur_frame.expr_values.clear();
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
         };
         // If the next statement requires evaluating expressions then we push
         // these onto the expression stack. This way we will evaluate this
         // stack in the next loop, then evaluate the statement using the result
         // from the expression evaluation.
         if !cur_frame.position.is_invalid() {
             let stmt = &heap[cur_frame.position];
             match stmt {
                 Statement::If(stmt) => cur_frame.prepare_single_expression(heap, stmt.test),
                 Statement::While(stmt) => cur_frame.prepare_single_expression(heap, stmt.test),
                 Statement::Return(stmt) => {
                     debug_assert_eq!(stmt.expressions.len(), 1); // TODO: @ReturnValues
                     cur_frame.prepare_single_expression(heap, stmt.expressions[0]);
                 },
                 Statement::New(stmt) => {
                     // Note that we will end up not evaluating the call itself.
                     // Rather we will evaluate its expressions and then
                     // instantiate the component upon reaching the "new" stmt.
                     let call_expr = &heap[stmt.expression];
                     cur_frame.prepare_multiple_expressions(heap, &call_expr.arguments);
                 },
                 Statement::Expression(stmt) => {
                     cur_frame.prepare_single_expression(heap, stmt.expression);
+                }
                 _ => {},
+            }
+        }
         return_value
+    }
+}
@@ \ No newline at end of file @@

src/protocol/eval/mod.rs

➞

Show inline comments

 /// eval
 ///
 /// Evaluator of the generated AST. Note that we use some misappropriated terms
 /// to describe where values live and what they do. This is a temporary
 /// implementation of an evaluator until some kind of appropriate bytecode or
 /// machine code is generated.
 ///
 /// Code is always executed within a "frame". For Reowolf the first frame is
 /// usually an executed component. All subsequent frames are function calls.
 /// Simple values live on the "stack". Each variable/parameter has a place on
 /// the stack where its values are stored. If the value is not a primitive, then
 /// its value will be stored in the "heap". Expressions are treated differently
 /// and use a separate "stack" for their evaluation.
 ///
 /// Since this is a value-based language, most values are copied. One has to be
 /// careful with values that reside in the "heap" and make sure that copies are
 /// properly removed from the heap..
 ///
 /// Just to reiterate: this is a temporary wasteful implementation. A proper
 /// implementation would fully fill out the type table with alignment/size/
 /// offset information and lay out bytecode.
 mod value;
 mod store;
 mod executor;
 pub(crate) mod value;
 pub(crate) mod store;
 pub(crate) mod executor;
 pub use value::{Value, ValueGroup};
 pub(crate) use store::{Store};
 pub use executor::{EvalContinuation, Prompt};

src/protocol/eval/store.rs

➞

Show inline comments

 use std::collections::VecDeque;
 use super::value::{Value, ValueId, HeapPos};
 #[derive(Debug, Clone)]
 pub(crate) struct HeapAllocation {
     pub values: Vec<Value>,
+}
 #[derive(Debug, Clone)]
 pub(crate) struct Store {
     // The stack where variables/parameters are stored. Note that this is a
     // non-shrinking stack. So it may be filled with garbage.
     pub(crate) stack: Vec<Value>,
     // Represents the place in the stack where we find the `PrevStackBoundary`
     // value containing the previous stack boundary. This is so we can pop from
     // the stack after function calls.
     pub(crate) cur_stack_boundary: usize,
     // A rather ridiculous simulated heap, but this allows us to "allocate"
     // things that occupy more then one stack slot.
     pub(crate) heap_regions: Vec<HeapAllocation>,
     pub(crate) free_regions: VecDeque<HeapPos>,
+}
 impl Store {
     pub(crate) fn new() -> Self {
         let mut store = Self{
             stack: Vec::with_capacity(64),
             cur_stack_boundary: 0,
             heap_regions: Vec::new(),
             free_regions: VecDeque::new(),
         };
         store.stack.push(Value::PrevStackBoundary(-1));
         store
+    }
     /// Resizes(!) the stack to fit the required number of values. Any
     /// unallocated slots are initialized to `Unassigned`. The specified stack
     /// index is exclusive.
     pub(crate) fn reserve_stack(&mut self, unique_stack_idx: usize) {
         let new_size = self.cur_stack_boundary + unique_stack_idx + 1;
         if new_size > self.stack.len() {
             self.stack.resize(new_size, Value::Unassigned);
+        }
+    }
     /// Clears values on the stack and removes their heap allocations when
     /// applicable. The specified index itself will also be cleared (so if you
     /// specify 0 all values in the frame will be destroyed)
     pub(crate) fn clear_stack(&mut self, unique_stack_idx: usize) {
         let new_size = self.cur_stack_boundary + unique_stack_idx + 1;
         for idx in new_size..self.stack.len() {
             self.drop_value(self.stack[idx].get_heap_pos());
             self.stack[idx] = Value::Unassigned;
+        }
         self.stack.truncate(new_size);
+    }
     /// Reads a value and takes ownership. This is different from a move because
     /// the value might indirectly reference stack/heap values. For these kinds
     /// values we will actually return a cloned value.
     pub(crate) fn read_take_ownership(&mut self, value: Value) -> Value {
         match value {
             Value::Ref(ValueId::Stack(pos)) => {
                 let abs_pos = self.cur_stack_boundary + 1 + pos as usize;
                 return self.clone_value(self.stack[abs_pos].clone());
             },
             Value::Ref(ValueId::Heap(heap_pos, value_idx)) => {
                 let heap_pos = heap_pos as usize;
                 let value_idx = value_idx as usize;
                 return self.clone_value(self.heap_regions[heap_pos].values[value_idx].clone());
             },
             _ => value
+        }
+    }
     /// Reads a value from a specific address. The value is always copied, hence
     /// if the value ends up not being written, one should call `drop_value` on
     /// it.
     pub(crate) fn read_copy(&mut self, address: ValueId) -> Value {
         match address {
             ValueId::Stack(pos) => {
                 let cur_pos = self.cur_stack_boundary + 1 + pos as usize;
                 return self.clone_value(self.stack[cur_pos].clone());
             },
             ValueId::Heap(heap_pos, region_idx) => {
                 return self.clone_value(self.heap_regions[heap_pos as usize].values[region_idx as usize].clone())
+            }
+        }
+    }
     /// Potentially reads a reference value. The supplied `Value` might not
     /// actually live in the store's stack or heap, but live on the expression
     /// stack. Generally speaking you only want to call this if the value comes
     /// from the expression stack due to borrowing issues.
     pub(crate) fn maybe_read_ref<'a>(&'a self, value: &'a Value) -> &'a Value {
         match value {
             Value::Ref(value_id) => self.read_ref(*value_id),
             _ => value,
+        }
+    }
     /// Returns an immutable reference to the value pointed to by an address
     pub(crate) fn read_ref(&self, address: ValueId) -> &Value {
         match address {
             ValueId::Stack(pos) => {
                 let cur_pos = self.cur_stack_boundary + 1 + pos as usize;
                 return &self.stack[cur_pos];
             },
             ValueId::Heap(heap_pos, region_idx) => {
                 return &self.heap_regions[heap_pos as usize].values[region_idx as usize];
+            }
+        }
+    }
     /// Returns a mutable reference to the value pointed to by an address
     pub(crate) fn read_mut_ref(&mut self, address: ValueId) -> &mut Value {
         match address {
             ValueId::Stack(pos) => {
                 let cur_pos = self.cur_stack_boundary + 1 + pos as usize;
                 return &mut self.stack[cur_pos];
             },
             ValueId::Heap(heap_pos, region_idx) => {
                 return &mut self.heap_regions[heap_pos as usize].values[region_idx as usize];
+            }
+        }
+    }
     /// Writes a value
     pub(crate) fn write(&mut self, address: ValueId, value: Value) {
         match address {
             ValueId::Stack(pos) => {
                 let cur_pos = self.cur_stack_boundary + 1 + pos as usize;
                 self.drop_value(self.stack[cur_pos].get_heap_pos());
                 self.stack[cur_pos] = value;
             },
             ValueId::Heap(heap_pos, region_idx) => {
                 let heap_pos = heap_pos as usize;
                 let region_idx = region_idx as usize;
                 self.drop_value(self.heap_regions[heap_pos].values[region_idx].get_heap_pos());
                 self.heap_regions[heap_pos].values[region_idx] = value
+            }
+        }
+    }
     /// This thing takes a cloned Value, because of borrowing issues (which is
     /// either a direct value, or might contain an index to a heap value), but
     /// should be treated by the programmer as a reference (i.e. don't call
     /// `drop_value(thing)` after calling `clone_value(thing.clone())`.
     fn clone_value(&mut self, value: Value) -> Value {
         // Quickly check if the value is not on the heap
         let source_heap_pos = value.get_heap_pos();
         println!("DEBUG: Cloning {:?}", value);
         if source_heap_pos.is_none() {
             // We can do a trivial copy
             return value;
             // We can do a trivial copy, unless we're dealing with a value
             // reference
             return match value {
                 Value::Ref(ValueId::Stack(stack_pos)) => {
                     let abs_stack_pos = self.cur_stack_boundary + stack_pos as usize + 1;
                     self.clone_value(self.stack[abs_stack_pos].clone())
                 },
                 Value::Ref(ValueId::Heap(heap_pos, val_idx)) => {
                     self.clone_value(self.heap_regions[heap_pos as usize].values[val_idx as usize].clone())
                 },
                 _ => value,
             };
+        }
         // Value does live on heap, copy it
         let source_heap_pos = source_heap_pos.unwrap() as usize;
         let target_heap_pos = self.alloc_heap();
         let target_heap_pos_usize = target_heap_pos as usize;
         let num_values = self.heap_regions[source_heap_pos].values.len();
         for value_idx in 0..num_values {
             let cloned = self.clone_value(self.heap_regions[source_heap_pos].values[value_idx].clone());
             self.heap_regions[target_heap_pos_usize].values.push(cloned);
+        }
         match value {
             Value::Message(_) => Value::Message(target_heap_pos),
             Value::Array(_) => Value::Array(target_heap_pos),
             Value::Union(tag, _) => Value::Union(tag, target_heap_pos),
             Value::Struct(_) => Value::Struct(target_heap_pos),
             _ => unreachable!("performed clone_value on heap, but {:?} is not a heap value", value),
+        }
+    }
     pub(crate) fn drop_value(&mut self, value: Option<HeapPos>) {
         if let Some(heap_pos) = value {
             self.drop_heap_pos(heap_pos);
+        }
+    }
     pub(crate) fn drop_heap_pos(&mut self, heap_pos: HeapPos) {
         let num_values = self.heap_regions[heap_pos as usize].values.len();
         for value_idx in 0..num_values {
             if let Some(other_heap_pos) = self.heap_regions[heap_pos as usize].values[value_idx].get_heap_pos() {
                 self.drop_heap_pos(other_heap_pos);
+            }
+        }
         self.heap_regions[heap_pos as usize].values.clear();
         self.free_regions.push_back(heap_pos);
+    }
     pub(crate) fn alloc_heap(&mut self) -> HeapPos {
         if self.free_regions.is_empty() {
             let idx = self.heap_regions.len() as HeapPos;
             self.heap_regions.push(HeapAllocation{ values: Vec::new() });
             return idx;
         } else {
             let idx = self.free_regions.pop_back().unwrap();
             return idx;
+        }
+    }
+}
@@ \ No newline at end of file @@

src/protocol/eval/value.rs

➞

Show inline comments

@@ @@ -27,470 +27,563 @@ pub enum Value { @@
     PrevStackBoundary(isize),   // Marker for stack frame beginning, so we can pop stack values
     Ref(ValueId),               // Reference to a value, used by expressions producing references
     // Builtin types
     Input(PortId),
     Output(PortId),
     Message(HeapPos),
     Null,
     Bool(bool),
     Char(char),
     String(HeapPos),
     UInt8(u8),
     UInt16(u16),
     UInt32(u32),
     UInt64(u64),
     SInt8(i8),
     SInt16(i16),
     SInt32(i32),
     SInt64(i64),
     Array(HeapPos),
     // Instances of user-defined types
     Enum(i64),
     Union(i64, HeapPos),
     Struct(HeapPos),
+}
 macro_rules! impl_union_unpack_as_value {
     ($func_name:ident, $variant_name:path, $return_type:ty) => {
         impl Value {
             pub(crate) fn $func_name(&self) -> $return_type {
                 match self {
                     $variant_name(v) => *v,
                     _ => panic!(concat!("called ", stringify!($func_name()), " on {:?}"), self),
+                }
+            }
+        }
+    }
+}
 impl_union_unpack_as_value!(as_stack_boundary, Value::PrevStackBoundary, isize);
 impl_union_unpack_as_value!(as_ref,     Value::Ref,     ValueId);
 impl_union_unpack_as_value!(as_input,   Value::Input,   PortId);
 impl_union_unpack_as_value!(as_output,  Value::Output,  PortId);
 impl_union_unpack_as_value!(as_message, Value::Message, HeapPos);
 impl_union_unpack_as_value!(as_bool,    Value::Bool,    bool);
 impl_union_unpack_as_value!(as_char,    Value::Char,    char);
 impl_union_unpack_as_value!(as_string,  Value::String,  HeapPos);
 impl_union_unpack_as_value!(as_uint8,   Value::UInt8,   u8);
 impl_union_unpack_as_value!(as_uint16,  Value::UInt16,  u16);
 impl_union_unpack_as_value!(as_uint32,  Value::UInt32,  u32);
 impl_union_unpack_as_value!(as_uint64,  Value::UInt64,  u64);
 impl_union_unpack_as_value!(as_sint8,   Value::SInt8,   i8);
 impl_union_unpack_as_value!(as_sint16,  Value::SInt16,  i16);
 impl_union_unpack_as_value!(as_sint32,  Value::SInt32,  i32);
 impl_union_unpack_as_value!(as_sint64,  Value::SInt64,  i64);
 impl_union_unpack_as_value!(as_array,   Value::Array,   HeapPos);
 impl_union_unpack_as_value!(as_enum,    Value::Enum,    i64);
 impl_union_unpack_as_value!(as_struct,  Value::Struct,  HeapPos);
 impl Value {
     pub(crate) fn as_union(&self) -> (i64, HeapPos) {
         match self {
             Value::Union(tag, v) => (*tag, *v),
             _ => panic!("called as_union on {:?}", self),
+        }
+    }
     pub(crate) fn is_integer(&self) -> bool {
         match self {
             Value::UInt8(_) | Value::UInt16(_) | Value::UInt32(_) | Value::UInt64(_) |
             Value::SInt8(_) | Value::SInt16(_) | Value::SInt32(_) | Value::SInt64(_) => true,
             _ => false
+        }
+    }
     pub(crate) fn is_unsigned_integer(&self) -> bool {
         match self {
             Value::UInt8(_) | Value::UInt16(_) | Value::UInt32(_) | Value::UInt64(_) => true,
             _ => false
+        }
+    }
     pub(crate) fn is_signed_integer(&self) -> bool {
         match self {
             Value::SInt8(_) | Value::SInt16(_) | Value::SInt32(_) | Value::SInt64(_) => true,
             _ => false
+        }
+    }
     pub(crate) fn as_unsigned_integer(&self) -> u64 {
         match self {
             Value::UInt8(v)  => *v as u64,
             Value::UInt16(v) => *v as u64,
             Value::UInt32(v) => *v as u64,
             Value::UInt64(v) => *v as u64,
             _ => unreachable!("called as_unsigned_integer on {:?}", self),
+        }
+    }
     pub(crate) fn as_signed_integer(&self) -> i64 {
         match self {
             Value::SInt8(v)  => *v as i64,
             Value::SInt16(v) => *v as i64,
             Value::SInt32(v) => *v as i64,
             Value::SInt64(v) => *v as i64,
             _ => unreachable!("called as_signed_integer on {:?}", self)
+        }
+    }
     /// Returns the heap position associated with the value. If the value
     /// doesn't store anything in the heap then we return `None`.
     pub(crate) fn get_heap_pos(&self) -> Option<HeapPos> {
         match self {
             Value::Message(v) => Some(*v),
             Value::Array(v) => Some(*v),
             Value::Union(_, v) => Some(*v),
             Value::Struct(v) => Some(*v),
             _ => None
+        }
+    }
+}
 /// When providing arguments to a new component, or when transferring values
 /// from one component's store to a newly instantiated component, one has to
 /// transfer stack and heap values. This `ValueGroup` represents such a
 /// temporary group of values with potential heap allocations.
 ///
 /// Constructing such a ValueGroup manually requires some extra care to make
 /// sure all elements of `values` point to valid elements of `regions`.
 ///
 /// Again: this is a temporary thing, hopefully removed once we move to a
 /// bytecode interpreter.
 pub struct ValueGroup {
     pub(crate) values: Vec<Value>,
     pub(crate) regions: Vec<Vec<Value>>
+}
 impl ValueGroup {
     pub(crate) fn new_stack(values: Vec<Value>) -> Self {
         debug_assert!(values.iter().all(|v| v.get_heap_pos().is_none()));
         Self{
             values,
             regions: Vec::new(),
+        }
+    }
     pub(crate) fn from_store(store: &Store, values: &[Value]) -> Self {
         let mut group = ValueGroup{
             values: Vec::with_capacity(values.len()),
             regions: Vec::with_capacity(values.len()), // estimation
         };
         for value in values {
             let transferred = group.retrieve_value(value, store);
             group.values.push(transferred);
+        }
         group
+    }
     /// Transfers a provided value from a store into a local value with its
     /// heap allocations (if any) stored in the ValueGroup. Calling this
     /// function will not store the returned value in the `values` member.
     fn retrieve_value(&mut self, value: &Value, from_store: &Store) -> Value {
         if let Some(heap_pos) = value.get_heap_pos() {
             // Value points to a heap allocation, so transfer the heap values
             // internally.
             let from_region = &from_store.heap_regions[heap_pos as usize].values;
             let mut new_region = Vec::with_capacity(from_region.len());
             for value in from_region {
                 let transferred = self.retrieve_value(value, from_store);
                 new_region.push(transferred);
+            }
             // Region is constructed, store internally and return the new value.
             let new_region_idx = self.regions.len() as HeapPos;
             self.regions.push(new_region);
             return match value {
                 Value::Message(_)    => Value::Message(new_region_idx),
                 Value::String(_)     => Value::String(new_region_idx),
                 Value::Array(_)      => Value::Array(new_region_idx),
                 Value::Union(tag, _) => Value::Union(*tag, new_region_idx),
                 Value::Struct(_)     => Value::Struct(new_region_idx),
                 _ => unreachable!(),
             };
         } else {
             return value.clone();
+        }
+    }
     /// Transfers the heap values and the stack values into the store. Stack
     /// values are pushed onto the Store's stack in the order in which they
     /// appear in the value group.
     pub(crate) fn into_store(self, store: &mut Store) {
         for value in &self.values {
             let transferred = self.provide_value(value, store);
             store.stack.push(transferred);
+        }
+    }
     fn provide_value(&self, value: &Value, to_store: &mut Store) -> Value {
         if let Some(from_heap_pos) = value.get_heap_pos() {
             let from_heap_pos = from_heap_pos as usize;
             let to_heap_pos = to_store.alloc_heap();
             let to_heap_pos_usize = to_heap_pos as usize;
             to_store.heap_regions[to_heap_pos_usize].values.reserve(self.regions[from_heap_pos].len());
             for value in &self.regions[from_heap_pos as usize] {
                 let transferred = self.provide_value(value, to_store);
                 to_store.heap_regions[to_heap_pos_usize].values.push(transferred);
+            }
             return match value {
                 Value::Message(_)    => Value::Message(to_heap_pos),
                 Value::String(_)     => Value::String(to_heap_pos),
                 Value::Array(_)      => Value::Array(to_heap_pos),
                 Value::Union(tag, _) => Value::Union(*tag, to_heap_pos),
                 Value::Struct(_)     => Value::Struct(to_heap_pos),
                 _ => unreachable!(),
             };
         } else {
             return value.clone();
+        }
+    }
+}
 impl Default for ValueGroup {
     /// Returns an empty ValueGroup
     fn default() -> Self {
         Self { values: Vec::new(), regions: Vec::new() }
+    }
+}
 pub(crate) fn apply_assignment_operator(store: &mut Store, lhs: ValueId, op: AssignmentOperator, rhs: Value) {
     use AssignmentOperator as AO;
     macro_rules! apply_int_op {
         ($lhs:ident, $assignment_tokens:tt, $operator:ident, $rhs:ident) => {
             match $lhs {
                 Value::UInt8(v)  => { *v $assignment_tokens $rhs.as_uint8();  },
                 Value::UInt16(v) => { *v $assignment_tokens $rhs.as_uint16(); },
                 Value::UInt32(v) => { *v $assignment_tokens $rhs.as_uint32(); },
                 Value::UInt64(v) => { *v $assignment_tokens $rhs.as_uint64(); },
                 Value::SInt8(v)  => { *v $assignment_tokens $rhs.as_sint8();  },
                 Value::SInt16(v) => { *v $assignment_tokens $rhs.as_sint16(); },
                 Value::SInt32(v) => { *v $assignment_tokens $rhs.as_sint32(); },
                 Value::SInt64(v) => { *v $assignment_tokens $rhs.as_sint64(); },
                 _ => unreachable!("apply_assignment_operator {:?} on lhs {:?} and rhs {:?}", $operator, $lhs, $rhs),
+            }
+        }
+    }
     let lhs = store.read_mut_ref(lhs);
     let mut to_dealloc = None;
     match op {
         AO::Set => {
             match lhs {
                 Value::Unassigned => { *lhs = rhs; },
                 Value::Input(v)  => { *v = rhs.as_input(); },
                 Value::Output(v) => { *v = rhs.as_output(); },
                 Value::Message(v)  => { to_dealloc = Some(*v); *v = rhs.as_message(); },
                 Value::Bool(v)    => { *v = rhs.as_bool(); },
                 Value::Char(v) => { *v = rhs.as_char(); },
                 Value::String(v) => { *v = rhs.as_string().clone(); },
                 Value::UInt8(v) => { *v = rhs.as_uint8(); },
                 Value::UInt16(v) => { *v = rhs.as_uint16(); },
                 Value::UInt32(v) => { *v = rhs.as_uint32(); },
                 Value::UInt64(v) => { *v = rhs.as_uint64(); },
                 Value::SInt8(v) => { *v = rhs.as_sint8(); },
                 Value::SInt16(v) => { *v = rhs.as_sint16(); },
                 Value::SInt32(v) => { *v = rhs.as_sint32(); },
                 Value::SInt64(v) => { *v = rhs.as_sint64(); },
                 Value::Array(v) => { to_dealloc = Some(*v); *v = rhs.as_array(); },
                 Value::Enum(v) => { *v = rhs.as_enum(); },
                 Value::Union(lhs_tag, lhs_heap_pos) => {
                     to_dealloc = Some(*lhs_heap_pos);
                     let (rhs_tag, rhs_heap_pos) = rhs.as_union();
                     *lhs_tag = rhs_tag;
                     *lhs_heap_pos = rhs_heap_pos;
+                }
                 Value::Struct(v) => { to_dealloc = Some(*v); *v = rhs.as_struct(); },
                 _ => unreachable!("apply_assignment_operator {:?} on lhs {:?} and rhs {:?}", op, lhs, rhs),
+            }
         },
         AO::Multiplied =>   { apply_int_op!(lhs, *=,  op, rhs) },
         AO::Divided =>      { apply_int_op!(lhs, /=,  op, rhs) },
         AO::Remained =>     { apply_int_op!(lhs, %=,  op, rhs) },
         AO::Added =>        { apply_int_op!(lhs, +=,  op, rhs) },
         AO::Subtracted =>   { apply_int_op!(lhs, -=,  op, rhs) },
         AO::ShiftedLeft =>  { apply_int_op!(lhs, <<=, op, rhs) },
         AO::ShiftedRight => { apply_int_op!(lhs, >>=, op, rhs) },
         AO::BitwiseAnded => { apply_int_op!(lhs, &=,  op, rhs) },
         AO::BitwiseXored => { apply_int_op!(lhs, ^=,  op, rhs) },
         AO::BitwiseOred =>  { apply_int_op!(lhs, |=,  op, rhs) },
+    }
     if let Some(heap_pos) = to_dealloc {
         store.drop_heap_pos(heap_pos);
+    }
+}
 pub(crate) fn apply_binary_operator(store: &mut Store, lhs: &Value, op: BinaryOperator, rhs: &Value) -> Value {
     use BinaryOperator as BO;
     macro_rules! apply_int_op_and_return_self {
         ($lhs:ident, $operator_tokens:tt, $operator:ident, $rhs:ident) => {
             return match $lhs {
                 Value::UInt8(v)  => { Value::UInt8( *v $operator_tokens $rhs.as_uint8() ) },
                 Value::UInt16(v) => { Value::UInt16(*v $operator_tokens $rhs.as_uint16()) },
                 Value::UInt32(v) => { Value::UInt32(*v $operator_tokens $rhs.as_uint32()) },
                 Value::UInt64(v) => { Value::UInt64(*v $operator_tokens $rhs.as_uint64()) },
                 Value::SInt8(v)  => { Value::SInt8( *v $operator_tokens $rhs.as_sint8() ) },
                 Value::SInt16(v) => { Value::SInt16(*v $operator_tokens $rhs.as_sint16()) },
                 Value::SInt32(v) => { Value::SInt32(*v $operator_tokens $rhs.as_sint32()) },
                 Value::SInt64(v) => { Value::SInt64(*v $operator_tokens $rhs.as_sint64()) },
                 _ => unreachable!("apply_binary_operator {:?} on lhs {:?} and rhs {:?}", $operator, $lhs, $rhs)
             };
+        }
+    }
     macro_rules! apply_int_op_and_return_bool {
         ($lhs:ident, $operator_tokens:tt, $operator:ident, $rhs:ident) => {
             return match $lhs {
                 Value::UInt8(v)  => { Value::Bool(*v $operator_tokens $rhs.as_uint8() ) },
                 Value::UInt16(v) => { Value::Bool(*v $operator_tokens $rhs.as_uint16()) },
                 Value::UInt32(v) => { Value::Bool(*v $operator_tokens $rhs.as_uint32()) },
                 Value::UInt64(v) => { Value::Bool(*v $operator_tokens $rhs.as_uint64()) },
                 Value::SInt8(v)  => { Value::Bool(*v $operator_tokens $rhs.as_sint8() ) },
                 Value::SInt16(v) => { Value::Bool(*v $operator_tokens $rhs.as_sint16()) },
                 Value::SInt32(v) => { Value::Bool(*v $operator_tokens $rhs.as_sint32()) },
                 Value::SInt64(v) => { Value::Bool(*v $operator_tokens $rhs.as_sint64()) },
                 _ => unreachable!("apply_binary_operator {:?} on lhs {:?} and rhs {:?}", $operator, $lhs, $rhs)
             };
+        }
+    }
     // We need to handle concatenate in a special way because it needs the store
     // mutably.
     if op == BO::Concatenate {
         let target_heap_pos = store.alloc_heap();
         let lhs_heap_pos;
         let rhs_heap_pos;
         let lhs = store.maybe_read_ref(lhs);
         let rhs = store.maybe_read_ref(rhs);
         enum ValueKind { Message, String, Array };
         let value_kind;
         match lhs {
             Value::Message(lhs_pos) => {
                 lhs_heap_pos = *lhs_pos;
                 rhs_heap_pos = rhs.as_message();
                 value_kind = ValueKind::Message;
             },
             Value::String(lhs_pos) => {
                 lhs_heap_pos = *lhs_pos;
                 rhs_heap_pos = rhs.as_string();
                 value_kind = ValueKind::String;
             },
             Value::Array(lhs_pos) => {
                 lhs_heap_pos = *lhs_pos;
                 rhs_heap_pos = rhs.as_array();
                 value_kind = ValueKind::Array;
             },
             _ => unreachable!("apply_binary_operator {:?} on lhs {:?} and rhs {:?}", op, lhs, rhs)
+        }
         // TODO: I hate this, but fine...
         let mut concatenated = Vec::new();
         concatenated.extend_from_slice(&store.heap_regions[lhs_heap_pos as usize].values);
         concatenated.extend_from_slice(&store.heap_regions[rhs_heap_pos as usize].values);
         store.heap_regions[target_heap_pos as usize].values = concatenated;
         return match value_kind{
             ValueKind::Message => Value::Message(target_heap_pos),
             ValueKind::String => Value::String(target_heap_pos),
             ValueKind::Array => Value::Array(target_heap_pos),
         };
+    }
     // If any of the values are references, retrieve the thing they're referring
     // to.
     let lhs = match lhs {
         Value::Ref(value_id) => store.read_ref(*value_id),
         _ => lhs,
     };
     let rhs = match rhs {
         Value::Ref(value_id) => store.read_ref(*value_id),
         _ => rhs,
     };
     let lhs = store.maybe_read_ref(lhs);
     let rhs = store.maybe_read_ref(rhs);
     match op {
         BO::Concatenate => unreachable!(),
         BO::LogicalOr => {
             return Value::Bool(lhs.as_bool() || rhs.as_bool());
         },
         BO::LogicalAnd => {
             return Value::Bool(lhs.as_bool() && rhs.as_bool());
         },
         BO::BitwiseOr        => { apply_int_op_and_return_self!(lhs, |,  op, rhs); },
         BO::BitwiseXor       => { apply_int_op_and_return_self!(lhs, ^,  op, rhs); },
         BO::BitwiseAnd       => { apply_int_op_and_return_self!(lhs, &,  op, rhs); },
         BO::Equality => { todo!("implement") },
         BO::Inequality =>  { todo!("implement") },
         BO::Equality         => { Value::Bool(apply_equality_operator(store, lhs, rhs)) },
         BO::Inequality       => { Value::Bool(apply_inequality_operator(store, lhs, rhs)) },
         BO::LessThan         => { apply_int_op_and_return_bool!(lhs, <,  op, rhs); },
         BO::GreaterThan      => { apply_int_op_and_return_bool!(lhs, >,  op, rhs); },
         BO::LessThanEqual    => { apply_int_op_and_return_bool!(lhs, <=, op, rhs); },
         BO::GreaterThanEqual => { apply_int_op_and_return_bool!(lhs, >=, op, rhs); },
         BO::ShiftLeft        => { apply_int_op_and_return_self!(lhs, <<, op, rhs); },
         BO::ShiftRight       => { apply_int_op_and_return_self!(lhs, >>, op, rhs); },
         BO::Add              => { apply_int_op_and_return_self!(lhs, +,  op, rhs); },
         BO::Subtract         => { apply_int_op_and_return_self!(lhs, -,  op, rhs); },
         BO::Multiply         => { apply_int_op_and_return_self!(lhs, *,  op, rhs); },
         BO::Divide           => { apply_int_op_and_return_self!(lhs, /,  op, rhs); },
         BO::Remainder        => { apply_int_op_and_return_self!(lhs, %,  op, rhs); }
+    }
+}
 pub(crate) fn apply_unary_operator(store: &mut Store, op: UnaryOperator, value: &Value) -> Value {
     use UnaryOperator as UO;
     macro_rules! apply_int_expr_and_return {
         ($value:ident, $apply:tt, $op:ident) => {
             return match $value {
                 Value::UInt8(v)  => Value::UInt8($apply *v),
                 Value::UInt16(v) => Value::UInt16($apply *v),
                 Value::UInt32(v) => Value::UInt32($apply *v),
                 Value::UInt64(v) => Value::UInt64($apply *v),
                 Value::SInt8(v)  => Value::SInt8($apply *v),
                 Value::SInt16(v) => Value::SInt16($apply *v),
                 Value::SInt32(v) => Value::SInt32($apply *v),
                 Value::SInt64(v) => Value::SInt64($apply *v),
                 _ => unreachable!("apply_unary_operator {:?} on value {:?}", $op, $value),
             };
+        }
+    }
     // If the value is a reference, retrieve the thing it is referring to
     let value = store.maybe_read_ref(value);
     match op {
         UO::Positive => {
             debug_assert!(value.is_integer());
             return value.clone();
         },
         UO::Negative => {
             // TODO: Error on negating unsigned integers
             return match value {
                 Value::SInt8(v) => Value::SInt8(-*v),
                 Value::SInt16(v) => Value::SInt16(-*v),
                 Value::SInt32(v) => Value::SInt32(-*v),
                 Value::SInt64(v) => Value::SInt64(-*v),
                 _ => unreachable!("apply_unary_operator {:?} on value {:?}", op, value),
+            }
         },
         UO::BitwiseNot => { apply_int_expr_and_return!(value, !, op)},
         UO::LogicalNot => { return Value::Bool(!value.as_bool()); },
         UO::PreIncrement => { todo!("implement") },
         UO::PreDecrement => { todo!("implement") },
         UO::PostIncrement => { todo!("implement") },
         UO::PostDecrement => { todo!("implement") },
+    }
+}
 pub(crate) fn apply_equality_operator(store: &Store, lhs: &Value, rhs: &Value) -> bool {
     let lhs = store.maybe_read_ref(lhs);
     let rhs = store.maybe_read_ref(rhs);
     fn eval_equality_heap(store: &Store, lhs_pos: HeapPos, rhs_pos: HeapPos) -> bool {
         let lhs_vals = &store.heap_regions[lhs_pos as usize].values;
         let rhs_vals = &store.heap_regions[rhs_pos as usize].values;
         let lhs_len = lhs_vals.len();
         if lhs_len != rhs_vals.len() {
             return false;
+        }
         for idx in 0..lhs_len {
             let lhs_val = &lhs_vals[idx];
             let rhs_val = &rhs_vals[idx];
             if !apply_equality_operator(store, lhs_val, rhs_val) {
                 return false;
+            }
+        }
         return true;
+    }
     match lhs {
         Value::Input(v) => *v == rhs.as_input(),
         Value::Output(v) => *v == rhs.as_output(),
         Value::Message(lhs_pos) => eval_equality_heap(store, *lhs_pos, rhs.as_message()),
         Value::Null => todo!("remove null"),
         Value::Bool(v) => *v == rhs.as_bool(),
         Value::Char(v) => *v == rhs.as_char(),
         Value::String(lhs_pos) => eval_equality_heap(store, *lhs_pos, rhs.as_string()),
         Value::UInt8(v) => *v == rhs.as_uint8(),
         Value::UInt16(v) => *v == rhs.as_uint16(),
         Value::UInt32(v) => *v == rhs.as_uint32(),
         Value::UInt64(v) => *v == rhs.as_uint64(),
         Value::SInt8(v) => *v == rhs.as_sint8(),
         Value::SInt16(v) => *v == rhs.as_sint16(),
         Value::SInt32(v) => *v == rhs.as_sint32(),
         Value::SInt64(v) => *v == rhs.as_sint64(),
         Value::Enum(v) => *v == rhs.as_enum(),
         Value::Union(lhs_tag, lhs_pos) => {
             let (rhs_tag, rhs_pos) = rhs.as_union();
             if *lhs_tag != rhs_tag {
                 return false;
+            }
             eval_equality_heap(store, *lhs_pos, rhs_pos)
         },
         Value::Struct(lhs_pos) => eval_equality_heap(store, *lhs_pos, rhs.as_struct()),
         _ => unreachable!("apply_equality_operator to lhs {:?}", lhs),
+    }
+}
 pub(crate) fn apply_inequality_operator(store: &Store, lhs: &Value, rhs: &Value) -> bool {
     let lhs = store.maybe_read_ref(lhs);
     let rhs = store.maybe_read_ref(rhs);
     fn eval_inequality_heap(store: &Store, lhs_pos: HeapPos, rhs_pos: HeapPos) -> bool {
         let lhs_vals = &store.heap_regions[lhs_pos as usize].values;
         let rhs_vals = &store.heap_regions[rhs_pos as usize].values;
         let lhs_len = lhs_vals.len();
         if lhs_len != rhs_vals.len() {
             return true;
+        }
         for idx in 0..lhs_len {
             let lhs_val = &lhs_vals[idx];
             let rhs_val = &rhs_vals[idx];
             if apply_inequality_operator(store, lhs_val, rhs_val) {
                 return true;
+            }
+        }
         return false;
+    }
     match lhs {
         Value::Input(v) => *v != rhs.as_input(),
         Value::Output(v) => *v != rhs.as_output(),
         Value::Message(lhs_pos) => eval_inequality_heap(store, *lhs_pos, rhs.as_message()),
         Value::Null => todo!("remove null"),
         Value::Bool(v) => *v != rhs.as_bool(),
         Value::Char(v) => *v != rhs.as_char(),
         Value::String(lhs_pos) => eval_inequality_heap(store, *lhs_pos, rhs.as_string()),
         Value::UInt8(v) => *v != rhs.as_uint8(),
         Value::UInt16(v) => *v != rhs.as_uint16(),
         Value::UInt32(v) => *v != rhs.as_uint32(),
         Value::UInt64(v) => *v != rhs.as_uint64(),
         Value::SInt8(v) => *v != rhs.as_sint8(),
         Value::SInt16(v) => *v != rhs.as_sint16(),
         Value::SInt32(v) => *v != rhs.as_sint32(),
         Value::SInt64(v) => *v != rhs.as_sint64(),
         Value::Enum(v) => *v != rhs.as_enum(),
         Value::Union(lhs_tag, lhs_pos) => {
             let (rhs_tag, rhs_pos) = rhs.as_union();
             if *lhs_tag != rhs_tag {
                 return true;
+            }
             eval_inequality_heap(store, *lhs_pos, rhs_pos)
         },
         Value::String(lhs_pos) => eval_inequality_heap(store, *lhs_pos, rhs.as_struct()),
         _ => unreachable!("apply_inequality_operator to lhs {:?}", lhs)
+    }
+}
@@ \ No newline at end of file @@

src/protocol/tests/eval_calls.rs

➞

Show inline comments

@@ new file 100644 @@
 use super::*;
 use crate::protocol::eval::*;
 #[test]
 fn test_function_call() {
     Tester::new_single_source_expect_ok("with literal arg", "
     func add_two(u32 value) -> u32 {
         return value + 2;
+    }
     func foo() -> u32 {
         return add_two(5);
+    }
     ").for_function("foo", |f| {
         f.call(Some(Value::UInt32(7)));
     });
     println!("\n\n\n\n\n\n\n");
     Tester::new_single_source_expect_ok("with variable arg", "
     func add_two(u32 value) -> u32 {
         value += 1;
         return value + 1;
+    }
     func foo() -> bool {
         auto initial = 5;
         auto result = add_two(initial);
         return initial == 5 && result == 7;
     }").for_function("foo", |f| {
         f.call(Some(Value::Bool(true)));
     });
+}
@@ \ No newline at end of file @@

src/protocol/tests/eval_operators.rs

➞

Show inline comments

 use super::*;
 use crate::protocol::eval::*;
 #[test]
-fn test_assignment() {
+fn test_assignment_operators() {
     fn construct_source(value_type: &str, value_initial: &str, value_op: &str) -> String {
         return format!(
             "func foo() -> {} {{
                 {} value = {};
                 value {};
                 return value;
             }}",
             value_type, value_type, value_initial, value_op
         );
+    }
     Tester::new_single_source_expect_ok(
         "set", construct_source("u32", "1", "= 5")
     ).for_function("foo", |f| { f.call(); });
     Tester::new_single_source_expect_ok(
         "multiplied", construct_source("u32", "2", "*= 4")
     ).for_function("foo", |f| { f.call(); });
     fn perform_test(name: &str, source: String, expected_value: Value) {
         Tester::new_single_source_expect_ok(name, source)
             .for_function("foo", move |f| {
                 f.call(Some(expected_value));
             });
+    }
     Tester::new_single_source_expect_ok(
         "divided", construct_source("u32", "8", "/= 4")
     ).for_function("foo", |f| { f.call(); });
     perform_test(
         "set",
         construct_source("u32", "1", "= 5"),
         Value::UInt32(5)
     );
     Tester::new_single_source_expect_ok(
         "remained", construct_source("u32", "8", "%= 3")
     ).for_function("foo", |f| { f.call(); });
     perform_test(
         "multiplied",
         construct_source("u32", "2", "*= 4"),
         Value::UInt32(8)
     );
     Tester::new_single_source_expect_ok(
         "added", construct_source("u32", "2", "+= 4")
     ).for_function("foo", |f| { f.call(); });
     perform_test(
         "divided",
         construct_source("u32", "8", "/= 4"),
         Value::UInt32(2)
     );
     Tester::new_single_source_expect_ok(
         "subtracted", construct_source("u32", "6", "-= 4")
     ).for_function("foo", |f| { f.call(); });
     perform_test(
         "remained",
         construct_source("u32", "8", "%= 3"),
         Value::UInt32(2)
     );
     Tester::new_single_source_expect_ok(
         "shifted left", construct_source("u32", "2", "<<= 2")
     ).for_function("foo", |f| { f.call(); });
     perform_test(
         "added",
         construct_source("u32", "2", "+= 4"),
         Value::UInt32(6)
     );
     Tester::new_single_source_expect_ok(
         "shifted right", construct_source("u32", "8", ">>= 2")
     ).for_function("foo", |f| { f.call(); });
     perform_test(
         "subtracted",
         construct_source("u32", "6", "-= 4"),
         Value::UInt32(2)
     );
     Tester::new_single_source_expect_ok(
         "bitwise and", construct_source("u32", "3", "&= 2")
     ).for_function("foo", |f| { f.call(); });
     perform_test(
         "shifted left",
         construct_source("u32", "2", "<<= 2"),
         Value::UInt32(8)
     );
     Tester::new_single_source_expect_ok(
         "bitwise xor", construct_source("u32", "3", "^= 7")
     ).for_function("foo", |f| { f.call(); });
     perform_test(
         "shifted right",
         construct_source("u32", "8", ">>= 2"),
         Value::UInt32(2)
     );
     Tester::new_single_source_expect_ok(
         "bitwise or", construct_source("u32", "12", "|= 3")
     ).for_function("foo", |f| { f.call(); });
     perform_test(
         "bitwise and",
         construct_source("u32", "15", "&= 35"),
         Value::UInt32(3)
     );
     perform_test(
         "bitwise xor",
         construct_source("u32", "3", "^= 7"),
         Value::UInt32(4)
     );
     perform_test(
         "bitwise or",
         construct_source("u32", "12", "|= 3"),
         Value::UInt32(15)
     );
+}
 #[test]
 fn test_function_call() {
     Tester::new_single_source_expect_ok("calling", "
     func add_two(u32 value) -> u32 {
         return value + 2;
 fn test_concatenate_operator() {
     Tester::new_single_source_expect_ok(
         "concatenate and check pairs",
+        "
         func check_pair<T>(T[] arr, u32 idx) -> bool {
             return arr[idx] == arr[idx + 1];
+        }
         struct Point2D {
             u32 x,
             u32 y,
+        }
         func create_point(u32 x, u32 y) -> Point2D {
             return Point2D{ x: x, y: y };
+        }
         func create_array() -> Point2D[] {
             return {
                 create_point(1, 2),
                 create_point(1, 2),
                 create_point(3, 4),
                 create_point(3, 4)
             };
+        }
         func foo() -> bool {
             auto lhs = create_array();
             auto rhs = create_array();
             auto total = lhs @ rhs;
             auto is_equal =
                 check_pair(total, 0) &&
                 check_pair(total, 2) &&
                 check_pair(total, 4) &&
                 check_pair(total, 6);
             auto is_not_equal =
                 !check_pair(total, 0) ||
                 !check_pair(total, 2) ||
                 !check_pair(total, 4) ||
                 !check_pair(total, 6);
             return is_equal && !is_not_equal;
+        }
+        "
     ).for_function("foo", |f| {
         f.call(Some(Value::Bool(true)));
     });
+}
 #[test]
 fn test_binary_integer_operators() {
     fn construct_source(value_type: &str, code: &str) -> String {
         format!("
         func foo() -> {} {{
             {}
         }}
         ", value_type, code)
+    }
     func foo() -> u32 {
         return add_two(5);
     fn perform_test(test_name: &str, value_type: &str, code: &str, expected_value: Value) {
         Tester::new_single_source_expect_ok(test_name, construct_source(value_type, code))
             .for_function("foo", move |f| {
                 f.call(Some(expected_value));
             });
+    }
     ").for_function("foo", |f| { f.call(); });
     perform_test(
         "bitwise_or", "u16",
         "auto a = 3; return a | 4;", Value::UInt16(7)
     );
     perform_test(
         "bitwise_xor", "u16",
         "auto a = 3; return a ^ 7;", Value::UInt16(4)
     );
     perform_test(
         "bitwise and", "u16",
         "auto a = 0b110011; return a & 0b011110;", Value::UInt16(0b010010)
     );
     perform_test(
         "shift left", "u16",
         "auto a = 0x0F; return a << 4;", Value::UInt16(0xF0)
     );
     perform_test(
         "shift right", "u64",
         "auto a = 0xF0; return a >> 4;", Value::UInt64(0x0F)
     );
     perform_test(
         "add", "u32",
         "auto a = 5; return a + 5;", Value::UInt32(10)
     );
     perform_test(
         "subtract", "u32",
         "auto a = 3; return a - 3;", Value::UInt32(0)
     );
     perform_test(
         "multiply", "u8",
         "auto a = 2 * 2; return a * 2 * 2;", Value::UInt8(16)
     );
     perform_test(
         "divide", "u8",
         "auto a = 32 / 2; return a / 2 / 2;", Value::UInt8(4)
     );
     perform_test(
         "remainder", "u16",
         "auto a = 29; return a % 3;", Value::UInt16(2)
     );
+}
@@ \ No newline at end of file @@

src/protocol/tests/mod.rs

➞

Show inline comments

 /**
  * protocol/tests.rs
+ *
  * Contains tests for various parts of the lexer/parser and the evaluator of the
  * code. These are intended to be temporary tests such that we're sure that we
  * don't break existing functionality.
+ *
  * In the future these should be replaced by proper testing protocols.
  */
 mod utils;
 mod lexer;
 mod parser_validation;
 mod parser_inference;
 mod parser_monomorphs;
 mod parser_imports;
 mod eval_operators;
 mod eval_calls;
 pub(crate) use utils::{Tester};
@@ \ No newline at end of file @@

src/protocol/tests/utils.rs

➞

Show inline comments

 use crate::collections::StringPool;
 use crate::protocol::{
     ast::*,
     input_source::*,
     parser::{
         *,
         type_table::TypeTable,
         symbol_table::SymbolTable,
         token_parsing::*,
     },
     eval::*,
 };
 // Carries information about the test into utility structures for builder-like
 // assertions
 #[derive(Clone, Copy)]
 struct TestCtx<'a> {
     test_name: &'a str,
     heap: &'a Heap,
     modules: &'a Vec<Module>,
     types: &'a TypeTable,
     symbols: &'a SymbolTable,
+}
 //------------------------------------------------------------------------------
 // Interface for parsing and compiling
 //------------------------------------------------------------------------------
 pub(crate) struct Tester {
     test_name: String,
     sources: Vec<String>
+}
 impl Tester {
     /// Constructs a new tester, allows adding multiple sources before compiling
     pub(crate) fn new<S: ToString>(test_name: S) -> Self {
         Self{
             test_name: test_name.to_string(),
             sources: Vec::new()
+        }
+    }
     /// Utility for quick tests that use a single source file and expect the
     /// compilation to succeed.
     pub(crate) fn new_single_source_expect_ok<T: ToString, S: ToString>(test_name: T, source: S) -> AstOkTester {
         Self::new(test_name)
             .with_source(source)
             .compile()
             .expect_ok()
+    }
     /// Utility for quick tests that use a single source file and expect the
     /// compilation to fail.
     pub(crate) fn new_single_source_expect_err<T: ToString, S: ToString>(test_name: T, source: S) -> AstErrTester {
         Self::new(test_name)
             .with_source(source)
             .compile()
             .expect_err()
+    }
     pub(crate) fn with_source<S: ToString>(mut self, source: S) -> Self {
         self.sources.push(source.to_string());
         self
+    }
     pub(crate) fn compile(self) -> AstTesterResult {
         let mut parser = Parser::new();
         for source in self.sources.into_iter() {
             let source = source.into_bytes();
             let input_source = InputSource::new(String::from(""), source);
             if let Err(err) = parser.feed(input_source) {
                 return AstTesterResult::Err(AstErrTester::new(self.test_name, err))
+            }
+        }
         if let Err(err) = parser.parse() {
             return AstTesterResult::Err(AstErrTester::new(self.test_name, err))
+        }
         AstTesterResult::Ok(AstOkTester::new(self.test_name, parser))
+    }
+}
 pub(crate) enum AstTesterResult {
     Ok(AstOkTester),
     Err(AstErrTester)
+}
 impl AstTesterResult {
     pub(crate) fn expect_ok(self) -> AstOkTester {
         match self {
             AstTesterResult::Ok(v) => v,
             AstTesterResult::Err(err) => {
                 let wrapped = ErrorTester{ test_name: &err.test_name, error: &err.error };
                 println!("DEBUG: Full error:\n{}", &err.error);
                 assert!(
                     false,
                     "[{}] Expected compilation to succeed, but it failed with {}",
                     err.test_name, wrapped.assert_postfix()
                 );
                 unreachable!();
+            }
+        }
+    }
     pub(crate) fn expect_err(self) -> AstErrTester {
         match self {
             AstTesterResult::Ok(ok) => {
                 assert!(false, "[{}] Expected compilation to fail, but it succeeded", ok.test_name);
                 unreachable!();
             },
             AstTesterResult::Err(err) => err,
+        }
+    }
+}
 //------------------------------------------------------------------------------
 // Interface for successful compilation
 //------------------------------------------------------------------------------
 pub(crate) struct AstOkTester {
     test_name: String,
     modules: Vec<Module>,
     heap: Heap,
     symbols: SymbolTable,
     types: TypeTable,
     pool: StringPool, // This is stored because if we drop it on the floor, we lose all our `StringRef<'static>`s
+}
 impl AstOkTester {
     fn new(test_name: String, parser: Parser) -> Self {
         Self {
             test_name,
             modules: parser.modules,
             heap: parser.heap,
             symbols: parser.symbol_table,
             types: parser.type_table,
             pool: parser.string_pool,
+        }
+    }
     pub(crate) fn for_struct<F: Fn(StructTester)>(self, name: &str, f: F) -> Self {
         let mut found = false;
         for definition in self.heap.definitions.iter() {
             if let Definition::Struct(definition) = definition {
                 if definition.identifier.value.as_str() != name {
                     continue;
+                }
                 // Found struct with the same name
                 let tester = StructTester::new(self.ctx(), definition);
                 f(tester);
                 found = true;
                 break
+            }
+        }
         assert!(
             found, "[{}] Failed to find definition for struct '{}'",
             self.test_name, name
         );
         self
+    }
     pub(crate) fn for_enum<F: Fn(EnumTester)>(self, name: &str, f: F) -> Self {
         let mut found = false;
         for definition in self.heap.definitions.iter() {
             if let Definition::Enum(definition) = definition {
                 if definition.identifier.value.as_str() != name {
                     continue;
+                }
                 // Found enum with the same name
                 let tester = EnumTester::new(self.ctx(), definition);
                 f(tester);
                 found = true;
                 break;
+            }
+        }
         assert!(
             found, "[{}] Failed to find definition for enum '{}'",
             self.test_name, name
         );
         self
+    }
     pub(crate) fn for_union<F: Fn(UnionTester)>(self, name: &str, f: F) -> Self {
         let mut found = false;
         for definition in self.heap.definitions.iter() {
             if let Definition::Union(definition) = definition {
                 if definition.identifier.value.as_str() != name {
                     continue;
+                }
                 // Found union with the same name
                 let tester = UnionTester::new(self.ctx(), definition);
                 f(tester);
                 found = true;
                 break;
+            }
+        }
         assert!(
             found, "[{}] Failed to find definition for union '{}'",
             self.test_name, name
         );
         self
+    }
-    pub(crate) fn for_function<F: Fn(FunctionTester)>(self, name: &str, f: F) -> Self {
+    pub(crate) fn for_function<F: FnOnce(FunctionTester)>(self, name: &str, f: F) -> Self {
         let mut found = false;
         for definition in self.heap.definitions.iter() {
             if let Definition::Function(definition) = definition {
                 if definition.identifier.value.as_str() != name {
                     continue;
+                }
                 // Found function
                 let tester = FunctionTester::new(self.ctx(), definition);
                 f(tester);
                 found = true;
                 break;
+            }
+        }
         if found { return self }
         assert!(
             false, "[{}] failed to find definition for function '{}'",
             self.test_name, name
         );
         unreachable!();
+    }
     fn ctx(&self) -> TestCtx {
         TestCtx{
             test_name: &self.test_name,
             modules: &self.modules,
             heap: &self.heap,
             types: &self.types,
             symbols: &self.symbols,
+        }
+    }
+}
 //------------------------------------------------------------------------------
 // Utilities for successful compilation
 //------------------------------------------------------------------------------
 pub(crate) struct StructTester<'a> {
     ctx: TestCtx<'a>,
     def: &'a StructDefinition,
+}
 impl<'a> StructTester<'a> {
     fn new(ctx: TestCtx<'a>, def: &'a StructDefinition) -> Self {
         Self{ ctx, def }
+    }
     pub(crate) fn assert_num_fields(self, num: usize) -> Self {
         assert_eq!(
             num, self.def.fields.len(),
             "[{}] Expected {} struct fields, but found {} for {}",
             self.ctx.test_name, num, self.def.fields.len(), self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_num_monomorphs(self, num: usize) -> Self {
         let (is_equal, num_encountered) = has_equal_num_monomorphs(self.ctx, num, self.def.this.upcast());
         assert!(
             is_equal, "[{}] Expected {} monomorphs, but got {} for {}",
             self.ctx.test_name, num, num_encountered, self.assert_postfix()
         );
         self
+    }
     /// Asserts that a monomorph exist, separate polymorphic variable types by
     /// a semicolon.
     pub(crate) fn assert_has_monomorph(self, serialized_monomorph: &str) -> Self {
         let (has_monomorph, serialized) = has_monomorph(self.ctx, self.def.this.upcast(), serialized_monomorph);
         assert!(
             has_monomorph, "[{}] Expected to find monomorph {}, but got {} for {}",
             self.ctx.test_name, serialized_monomorph, &serialized, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn for_field<F: Fn(StructFieldTester)>(self, name: &str, f: F) -> Self {
         // Find field with specified name
         for field in &self.def.fields {
             if field.field.value.as_str() == name {
                 let tester = StructFieldTester::new(self.ctx, field);
                 f(tester);
                 return self;
+            }
+        }
         assert!(
             false, "[{}] Could not find struct field '{}' for {}",
             self.ctx.test_name, name, self.assert_postfix()
         );
         unreachable!();
+    }
     fn assert_postfix(&self) -> String {
         let mut v = String::new();
         v.push_str("Struct{ name: ");
         v.push_str(self.def.identifier.value.as_str());
         v.push_str(", fields: [");
         for (field_idx, field) in self.def.fields.iter().enumerate() {
             if field_idx != 0 { v.push_str(", "); }
             v.push_str(field.field.value.as_str());
+        }
         v.push_str("] }");
+        v
+    }
+}
 pub(crate) struct StructFieldTester<'a> {
     ctx: TestCtx<'a>,
     def: &'a StructFieldDefinition,
+}
 impl<'a> StructFieldTester<'a> {
     fn new(ctx: TestCtx<'a>, def: &'a StructFieldDefinition) -> Self {
         Self{ ctx, def }
+    }
     pub(crate) fn assert_parser_type(self, expected: &str) -> Self {
         let mut serialized_type = String::new();
         serialize_parser_type(&mut serialized_type, &self.ctx.heap, &self.def.parser_type);
         assert_eq!(
             expected, &serialized_type,
             "[{}] Expected type '{}', but got '{}' for {}",
             self.ctx.test_name, expected, &serialized_type, self.assert_postfix()
         );
         self
+    }
     fn assert_postfix(&self) -> String {
         let mut serialized_type = String::new();
         serialize_parser_type(&mut serialized_type, &self.ctx.heap, &self.def.parser_type);
         format!("StructField{{ name: {}, parser_type: {} }}", self.def.field.value.as_str(), serialized_type)
+    }
+}
 pub(crate) struct EnumTester<'a> {
     ctx: TestCtx<'a>,
     def: &'a EnumDefinition,
+}
 impl<'a> EnumTester<'a> {
     fn new(ctx: TestCtx<'a>, def: &'a EnumDefinition) -> Self {
         Self{ ctx, def }
+    }
     pub(crate) fn assert_num_variants(self, num: usize) -> Self {
         assert_eq!(
             num, self.def.variants.len(),
             "[{}] Expected {} enum variants, but found {} for {}",
             self.ctx.test_name, num, self.def.variants.len(), self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_num_monomorphs(self, num: usize) -> Self {
         let (is_equal, num_encountered) = has_equal_num_monomorphs(self.ctx, num, self.def.this.upcast());
         assert!(
             is_equal, "[{}] Expected {} monomorphs, but got {} for {}",
             self.ctx.test_name, num, num_encountered, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_has_monomorph(self, serialized_monomorph: &str) -> Self {
         let (has_monomorph, serialized) = has_monomorph(self.ctx, self.def.this.upcast(), serialized_monomorph);
         assert!(
             has_monomorph, "[{}] Expected to find monomorph {}, but got {} for {}",
             self.ctx.test_name, serialized_monomorph, serialized, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_postfix(&self) -> String {
         let mut v = String::new();
         v.push_str("Enum{ name: ");
         v.push_str(self.def.identifier.value.as_str());
         v.push_str(", variants: [");
         for (variant_idx, variant) in self.def.variants.iter().enumerate() {
             if variant_idx != 0 { v.push_str(", "); }
             v.push_str(variant.identifier.value.as_str());
+        }
         v.push_str("] }");
+        v
+    }
+}
 pub(crate) struct UnionTester<'a> {
     ctx: TestCtx<'a>,
     def: &'a UnionDefinition,
+}
 impl<'a> UnionTester<'a> {
     fn new(ctx: TestCtx<'a>, def: &'a UnionDefinition) -> Self {
         Self{ ctx, def }
+    }
     pub(crate) fn assert_num_variants(self, num: usize) -> Self {
         assert_eq!(
             num, self.def.variants.len(),
             "[{}] Expected {} union variants, but found {} for {}",
             self.ctx.test_name, num, self.def.variants.len(), self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_num_monomorphs(self, num: usize) -> Self {
         let (is_equal, num_encountered) = has_equal_num_monomorphs(self.ctx, num, self.def.this.upcast());
         assert!(
             is_equal, "[{}] Expected {} monomorphs, but got {} for {}",
             self.ctx.test_name, num, num_encountered, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_has_monomorph(self, serialized_monomorph: &str) -> Self {
         let (has_monomorph, serialized) = has_monomorph(self.ctx, self.def.this.upcast(), serialized_monomorph);
         assert!(
             has_monomorph, "[{}] Expected to find monomorph {}, but got {} for {}",
             self.ctx.test_name, serialized_monomorph, serialized, self.assert_postfix()
         );
         self
+    }
     fn assert_postfix(&self) -> String {
         let mut v = String::new();
         v.push_str("Union{ name: ");
         v.push_str(self.def.identifier.value.as_str());
         v.push_str(", variants: [");
         for (variant_idx, variant) in self.def.variants.iter().enumerate() {
             if variant_idx != 0 { v.push_str(", "); }
             v.push_str(variant.identifier.value.as_str());
+        }
         v.push_str("] }");
+        v
+    }
+}
 pub(crate) struct FunctionTester<'a> {
     ctx: TestCtx<'a>,
     def: &'a FunctionDefinition,
+}
 impl<'a> FunctionTester<'a> {
     fn new(ctx: TestCtx<'a>, def: &'a FunctionDefinition) -> Self {
         Self{ ctx, def }
+    }
     pub(crate) fn for_variable<F: Fn(VariableTester)>(self, name: &str, f: F) -> Self {
         // Find the memory statement in order to find the local
         let mem_stmt_id = seek_stmt(
             self.ctx.heap, self.def.body.upcast(),
             &|stmt| {
                 if let Statement::Local(local) = stmt {
                     if let LocalStatement::Memory(memory) = local {
                         let local = &self.ctx.heap[memory.variable];
                         if local.identifier.value.as_str() == name {
                             return true;
+                        }
+                    }
+                }
                 false
+            }
         );
         assert!(
             mem_stmt_id.is_some(), "[{}] Failed to find variable '{}' in {}",
             self.ctx.test_name, name, self.assert_postfix()
         );
         let mem_stmt_id = mem_stmt_id.unwrap();
         let local_id = self.ctx.heap[mem_stmt_id].as_memory().variable;
         let local = &self.ctx.heap[local_id];
         // Find the assignment expression that follows it
         let assignment_id = seek_expr_in_stmt(
             self.ctx.heap, self.def.body.upcast(),
             &|expr| {
                 if let Expression::Assignment(assign_expr) = expr {
                     if let Expression::Variable(variable_expr) = &self.ctx.heap[assign_expr.left] {
                         if variable_expr.identifier.span.begin.offset == local.identifier.span.begin.offset {
                             return true;
+                        }
+                    }
+                }
                 false
+            }
         );
         assert!(
             assignment_id.is_some(), "[{}] Failed to find assignment to variable '{}' in {}",
             self.ctx.test_name, name, self.assert_postfix()
         );
         let assignment = &self.ctx.heap[assignment_id.unwrap()];
         // Construct tester and pass to tester function
         let tester = VariableTester::new(
             self.ctx, self.def.this.upcast(), local,
             assignment.as_assignment()
         );
         f(tester);
         self
+    }
     /// Finds a specific expression within a function. There are two matchers:
     /// one outer matcher (to find a rough indication of the expression) and an
     /// inner matcher to find the exact expression.
     ///
     /// The reason being that, for example, a function's body might be littered
     /// with addition symbols, so we first match on "some_var + some_other_var",
     /// and then match exactly on "+".
     pub(crate) fn for_expression_by_source<F: Fn(ExpressionTester)>(self, outer_match: &str, inner_match: &str, f: F) -> Self {
         // Seek the expression in the source code
         assert!(outer_match.contains(inner_match), "improper testing code");
         let module = seek_def_in_modules(
             &self.ctx.heap, &self.ctx.modules, self.def.this.upcast()
         ).unwrap();
         // Find the first occurrence of the expression after the definition of
         // the function, we'll check that it is included in the body later.
         let mut outer_match_idx = self.def.span.begin.offset as usize;
         while outer_match_idx < module.source.input.len() {
             if module.source.input[outer_match_idx..].starts_with(outer_match.as_bytes()) {
                 break;
+            }
             outer_match_idx += 1
+        }
         assert!(
             outer_match_idx < module.source.input.len(),
             "[{}] Failed to find '{}' within the source that contains {}",
             self.ctx.test_name, outer_match, self.assert_postfix()
         );
         let inner_match_idx = outer_match_idx + outer_match.find(inner_match).unwrap();
         // Use the inner match index to find the expression
         let expr_id = seek_expr_in_stmt(
             &self.ctx.heap, self.def.body.upcast(),
             &|expr| expr.span().begin.offset as usize == inner_match_idx
         );
         assert!(
             expr_id.is_some(),
             "[{}] Failed to find '{}' within the source that contains {} \
             (note: expression was found, but not within the specified function",
             self.ctx.test_name, outer_match, self.assert_postfix()
         );
         let expr_id = expr_id.unwrap();
         // We have the expression, call the testing function
         let tester = ExpressionTester::new(
             self.ctx, self.def.this.upcast(), &self.ctx.heap[expr_id]
         );
         f(tester);
         self
+    }
     pub(crate) fn call(self, expected_result: Option<Value>) -> Self {
         use crate::protocol::*;
         use crate::runtime::*;
         let mut prompt = Prompt::new(&self.ctx.heap, self.def.this.upcast(), ValueGroup::new_stack(Vec::new()));
         let mut call_context = EvalContext::None;
         loop {
             let result = prompt.step(&self.ctx.heap, &mut call_context).unwrap();
             match result {
                 EvalContinuation::Stepping => {},
                 _ => break,
+            }
+        }
         assert!(
             prompt.store.stack.len() > 0, // note: stack never shrinks
             "[{}] No value on stack after calling function for {}",
             self.ctx.test_name, self.assert_postfix()
         );
         if let Some(expected_result) = expected_result {
             debug_assert!(expected_result.get_heap_pos().is_none(), "comparing against heap thingamajigs is not yet implemented");
             assert!(
                 value::apply_equality_operator(&prompt.store, &prompt.store.stack[0], &expected_result),
                 "[{}] Result from call was {:?}, but expected {:?} for {}",
                 self.ctx.test_name, &prompt.store.stack[0], &expected_result, self.assert_postfix()
+            )
+        }
         self
+    }
     fn assert_postfix(&self) -> String {
         format!("Function{{ name: {} }}", self.def.identifier.value.as_str())
+    }
+}
 pub(crate) struct VariableTester<'a> {
     ctx: TestCtx<'a>,
     definition_id: DefinitionId,
     variable: &'a Variable,
     assignment: &'a AssignmentExpression,
+}
 impl<'a> VariableTester<'a> {
     fn new(
         ctx: TestCtx<'a>, definition_id: DefinitionId, variable: &'a Variable, assignment: &'a AssignmentExpression
     ) -> Self {
         Self{ ctx, definition_id, variable, assignment }
+    }
     pub(crate) fn assert_parser_type(self, expected: &str) -> Self {
         let mut serialized = String::new();
         serialize_parser_type(&mut serialized, self.ctx.heap, &self.variable.parser_type);
         assert_eq!(
             expected, &serialized,
             "[{}] Expected parser type '{}', but got '{}' for {}",
             self.ctx.test_name, expected, &serialized, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_concrete_type(self, expected: &str) -> Self {
         let mut serialized = String::new();
         serialize_concrete_type(
             &mut serialized, self.ctx.heap, self.definition_id,
             &self.assignment.concrete_type
         );
         assert_eq!(
             expected, &serialized,
             "[{}] Expected concrete type '{}', but got '{}' for {}",
             self.ctx.test_name, expected, &serialized, self.assert_postfix()
         );
         self
+    }
     fn assert_postfix(&self) -> String {
         format!("Variable{{ name: {} }}", self.variable.identifier.value.as_str())
+    }
+}
 pub(crate) struct ExpressionTester<'a> {
     ctx: TestCtx<'a>,
     definition_id: DefinitionId, // of the enclosing function/component
     expr: &'a Expression
+}
 impl<'a> ExpressionTester<'a> {
     fn new(
         ctx: TestCtx<'a>, definition_id: DefinitionId, expr: &'a Expression
     ) -> Self {
         Self{ ctx, definition_id, expr }
+    }
     pub(crate) fn assert_concrete_type(self, expected: &str) -> Self {
         let mut serialized = String::new();
         serialize_concrete_type(
             &mut serialized, self.ctx.heap, self.definition_id,
             self.expr.get_type()
         );
         assert_eq!(
             expected, &serialized,
             "[{}] Expected concrete type '{}', but got '{}' for {}",
             self.ctx.test_name, expected, &serialized, self.assert_postfix()
         );
         self
+    }
     fn assert_postfix(&self) -> String {
         format!(
             "Expression{{ debug: {:?} }}",
             self.expr
+        )
+    }
+}
 //------------------------------------------------------------------------------
 // Interface for failed compilation
 //------------------------------------------------------------------------------
 pub(crate) struct AstErrTester {
     test_name: String,
     error: ParseError,
+}
 impl AstErrTester {
     fn new(test_name: String, error: ParseError) -> Self {
         Self{ test_name, error }
+    }
     pub(crate) fn error<F: Fn(ErrorTester)>(&self, f: F) {
         // Maybe multiple errors will be supported in the future
         let tester = ErrorTester{ test_name: &self.test_name, error: &self.error };
         f(tester)
+    }
+}
 //------------------------------------------------------------------------------
 // Utilities for failed compilation
 //------------------------------------------------------------------------------
 pub(crate) struct ErrorTester<'a> {
     test_name: &'a str,
     error: &'a ParseError,
+}
 impl<'a> ErrorTester<'a> {
     pub(crate) fn assert_num(self, num: usize) -> Self {
         assert_eq!(
             num, self.error.statements.len(),
             "[{}] expected error to consist of '{}' parts, but encountered '{}' for {}",
             self.test_name, num, self.error.statements.len(), self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_ctx_has(self, idx: usize, msg: &str) -> Self {
         assert!(
             self.error.statements[idx].context.contains(msg),
             "[{}] expected error statement {}'s context to contain '{}' for {}",
             self.test_name, idx, msg, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_msg_has(self, idx: usize, msg: &str) -> Self {
         assert!(
             self.error.statements[idx].message.contains(msg),
             "[{}] expected error statement {}'s message to contain '{}' for {}",
             self.test_name, idx, msg, self.assert_postfix()
         );
         self
+    }
     // TODO: @tokenizer This should really be removed, as compilation should be
     //  deterministic, but we're currently using rather inefficient hashsets for
     //  the type inference, so remove once compiler architecture has changed.
     pub(crate) fn assert_any_msg_has(self, msg: &str) -> Self {
         let mut is_present = false;
         for statement in &self.error.statements {
             if statement.message.contains(msg) {
                 is_present = true;
                 break;
+            }
+        }
         assert!(
             is_present, "[{}] Expected an error statement to contain '{}' for {}",
             self.test_name, msg, self.assert_postfix()
         );
         self
+    }
     /// Seeks the index of the pattern in the context message, then checks if
     /// the input position corresponds to that index.
     pub (crate) fn assert_occurs_at(self, idx: usize, pattern: &str) -> Self {
         let pos = self.error.statements[idx].context.find(pattern);
         assert!(
             pos.is_some(),
             "[{}] incorrect occurs_at: '{}' could not be found in the context for {}",
             self.test_name, pattern, self.assert_postfix()
         );
         let pos = pos.unwrap();
         let col = self.error.statements[idx].start_column as usize;
         assert_eq!(
             pos + 1, col,
             "[{}] Expected error to occur at column {}, but found it at {} for {}",
             self.test_name, pos + 1, col, self.assert_postfix()
         );
         self
+    }
     fn assert_postfix(&self) -> String {
         let mut v = String::new();
         v.push_str("error: [");
         for (idx, stmt) in self.error.statements.iter().enumerate() {
             if idx != 0 {
                 v.push_str(", ");
+            }
             v.push_str(&format!("{{ context: {}, message: {} }}", &stmt.context, stmt.message));
+        }
         v.push(']');
+        v
+    }
+}
 //------------------------------------------------------------------------------
 // Generic utilities
 //------------------------------------------------------------------------------
 fn has_equal_num_monomorphs<'a>(ctx: TestCtx<'a>, num: usize, definition_id: DefinitionId) -> (bool, usize) {
     let type_def = ctx.types.get_base_definition(&definition_id).unwrap();
     let num_on_type = type_def.monomorphs.len();
     (num_on_type == num, num_on_type)
+}
 fn has_monomorph<'a>(ctx: TestCtx<'a>, definition_id: DefinitionId, serialized_monomorph: &str) -> (bool, String) {
     let type_def = ctx.types.get_base_definition(&definition_id).unwrap();
     let mut full_buffer = String::new();
     let mut has_match = false;
     full_buffer.push('[');
     for (monomorph_idx, monomorph) in type_def.monomorphs.iter().enumerate() {
         let mut buffer = String::new();
         for (element_idx, monomorph_element) in monomorph.iter().enumerate() {
             if element_idx != 0 { buffer.push(';'); }
             serialize_concrete_type(&mut buffer, ctx.heap, definition_id, monomorph_element);
+        }
         if buffer == serialized_monomorph {
             // Found an exact match
             has_match = true;
+        }
         if monomorph_idx != 0 {
             full_buffer.push_str(", ");
+        }
         full_buffer.push('"');
         full_buffer.push_str(&buffer);
         full_buffer.push('"');
+    }
     full_buffer.push(']');
     (has_match, full_buffer)
+}
 fn serialize_parser_type(buffer: &mut String, heap: &Heap, parser_type: &ParserType) {
     use ParserTypeVariant as PTV;
     fn write_bytes(buffer: &mut String, bytes: &[u8]) {
         let utf8 = String::from_utf8_lossy(bytes);
         buffer.push_str(&utf8);
+    }
     fn serialize_variant(buffer: &mut String, heap: &Heap, parser_type: &ParserType, mut idx: usize) -> usize {
         match &parser_type.elements[idx].variant {
             PTV::Void => buffer.push_str("void"),
             PTV::InputOrOutput => {
                 buffer.push_str("portlike<");
                 idx = serialize_variant(buffer, heap, parser_type, idx + 1);
                 buffer.push('>');
             },
             PTV::ArrayLike => {
                 idx = serialize_variant(buffer, heap, parser_type, idx + 1);
                 buffer.push_str("[???]");
             },
             PTV::IntegerLike => buffer.push_str("integerlike"),
             PTV::Message => buffer.push_str(KW_TYPE_MESSAGE_STR),
             PTV::Bool => buffer.push_str(KW_TYPE_BOOL_STR),
             PTV::UInt8 => buffer.push_str(KW_TYPE_UINT8_STR),
             PTV::UInt16 => buffer.push_str(KW_TYPE_UINT16_STR),
             PTV::UInt32 => buffer.push_str(KW_TYPE_UINT32_STR),
             PTV::UInt64 => buffer.push_str(KW_TYPE_UINT64_STR),
             PTV::SInt8 => buffer.push_str(KW_TYPE_SINT8_STR),
             PTV::SInt16 => buffer.push_str(KW_TYPE_SINT16_STR),
             PTV::SInt32 => buffer.push_str(KW_TYPE_SINT32_STR),
             PTV::SInt64 => buffer.push_str(KW_TYPE_SINT64_STR),
             PTV::Character => buffer.push_str(KW_TYPE_CHAR_STR),
             PTV::String => buffer.push_str(KW_TYPE_STRING_STR),
             PTV::IntegerLiteral => buffer.push_str("int_literal"),
             PTV::Inferred => buffer.push_str(KW_TYPE_INFERRED_STR),
             PTV::Array => {
                 idx = serialize_variant(buffer, heap, parser_type, idx + 1);
                 buffer.push_str("[]");
             },
             PTV::Input => {
                 buffer.push_str(KW_TYPE_IN_PORT_STR);
                 buffer.push('<');
                 idx = serialize_variant(buffer, heap, parser_type, idx + 1);
                 buffer.push('>');
             },
             PTV::Output => {
                 buffer.push_str(KW_TYPE_OUT_PORT_STR);
                 buffer.push('<');
                 idx = serialize_variant(buffer, heap, parser_type, idx + 1);
                 buffer.push('>');
             },
             PTV::PolymorphicArgument(definition_id, poly_idx) => {
                 let definition = &heap[*definition_id];
                 let poly_arg = &definition.poly_vars()[*poly_idx];
                 buffer.push_str(poly_arg.value.as_str());
             },
             PTV::Definition(definition_id, num_embedded) => {
                 let definition = &heap[*definition_id];
                 buffer.push_str(definition.identifier().value.as_str());
                 let num_embedded = *num_embedded;
                 if num_embedded != 0 {
                     buffer.push('<');
                     for embedded_idx in 0..num_embedded {
                         if embedded_idx != 0 {
                             buffer.push(',');
+                        }
                         idx = serialize_variant(buffer, heap, parser_type, idx + 1);
+                    }
                     buffer.push('>');
+                }
+            }
+        }
         idx
+    }
     serialize_variant(buffer, heap, parser_type, 0);
+}
 fn serialize_concrete_type(buffer: &mut String, heap: &Heap, def: DefinitionId, concrete: &ConcreteType) {
     // Retrieve polymorphic variables
     let poly_vars = heap[def].poly_vars();
     fn write_bytes(buffer: &mut String, bytes: &[u8]) {
         let utf8 = String::from_utf8_lossy(bytes);
         buffer.push_str(&utf8);
+    }
     fn serialize_recursive(
         buffer: &mut String, heap: &Heap, poly_vars: &Vec<Identifier>, concrete: &ConcreteType, mut idx: usize
     ) -> usize {
         use ConcreteTypePart as CTP;
         let part = &concrete.parts[idx];
         match part {
             CTP::Marker(poly_idx) => {
                 buffer.push_str(poly_vars[*poly_idx].value.as_str());
             },
             CTP::Void => buffer.push_str("void"),
             CTP::Message => write_bytes(buffer, KW_TYPE_MESSAGE),
             CTP::Bool => write_bytes(buffer, KW_TYPE_BOOL),
             CTP::UInt8 => write_bytes(buffer, KW_TYPE_UINT8),
             CTP::UInt16 => write_bytes(buffer, KW_TYPE_UINT16),
             CTP::UInt32 => write_bytes(buffer, KW_TYPE_UINT32),
             CTP::UInt64 => write_bytes(buffer, KW_TYPE_UINT64),
             CTP::SInt8 => write_bytes(buffer, KW_TYPE_SINT8),
             CTP::SInt16 => write_bytes(buffer, KW_TYPE_SINT16),
             CTP::SInt32 => write_bytes(buffer, KW_TYPE_SINT32),
             CTP::SInt64 => write_bytes(buffer, KW_TYPE_SINT64),
             CTP::Character => write_bytes(buffer, KW_TYPE_CHAR),
             CTP::String => write_bytes(buffer, KW_TYPE_STRING),
             CTP::Array => {
                 idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);
                 buffer.push_str("[]");
             },
             CTP::Slice => {
                 idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);
                 buffer.push_str("[..]");
             },
             CTP::Input => {
                 write_bytes(buffer, KW_TYPE_IN_PORT);
                 buffer.push('<');
                 idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);
                 buffer.push('>');
             },
             CTP::Output => {
                 write_bytes(buffer, KW_TYPE_OUT_PORT);
                 buffer.push('<');
                 idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);
                 buffer.push('>');
             },
             CTP::Instance(definition_id, num_sub) => {
                 let definition_name = heap[*definition_id].identifier();
                 buffer.push_str(definition_name.value.as_str());
                 if *num_sub != 0 {

0 comments (0 inline, 0 general)