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

Changeset - cc8030b35903

Parent rev.

Child rev.

[Not reviewed]

1 5 0

MH - 4 years ago 2021-09-07 17:41:31
contact@maxhenger.nl

more WIP on runtime revisiting

6 files changed with 597 insertions and 55 deletions:

src/common.rs

src/protocol/eval/executor.rs

src/protocol/mod.rs

src/runtime2/mod.rs

src/runtime2/registry.rs

src/runtime2/runtime.rs

473

0 comments (0 inline, 0 general)

src/common.rs

➞

Show inline comments

 ///////////////////// PRELUDE /////////////////////
 pub(crate) use crate::protocol::{ComponentState, ProtocolDescription};
 pub(crate) use crate::runtime::{error::AddComponentError, NonsyncProtoContext, SyncProtoContext};
 pub(crate) use core::{
     cmp::Ordering,
     fmt::{Debug, Formatter},
     hash::Hash,
     ops::Range,
     time::Duration,
 };
 pub(crate) use maplit::hashmap;
 pub(crate) use mio::{
     net::{TcpListener, TcpStream},
     Events, Interest, Poll, Token,
 };
 pub(crate) use std::{
     collections::{BTreeMap, HashMap, HashSet},
     io::{Read, Write},
     net::SocketAddr,
     sync::Arc,
     time::Instant,
 };
 pub(crate) use Polarity::*;
 pub(crate) trait IdParts {
     fn id_parts(self) -> (ConnectorId, U32Suffix);
+}
 /// Used by various distributed algorithms to identify connectors.
 pub type ConnectorId = u32;
 /// Used in conjunction with the `ConnectorId` type to create identifiers for ports and components
 pub type U32Suffix = u32;
 #[derive(Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd)]
 /// Generalization of a port/component identifier
 #[derive(serde::Serialize, serde::Deserialize)]
 #[repr(C)]
 pub struct Id {
     pub(crate) connector_id: ConnectorId,
     pub(crate) u32_suffix: U32Suffix,
+}
 #[derive(Clone, Debug, Default)]
 pub struct U32Stream {
     next: u32,
+}
 /// Identifier of a component in a session
 #[derive(Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd, serde::Serialize, serde::Deserialize)]
 pub struct ComponentId(Id); // PUB because it can be returned by errors
 /// Identifier of a port in a session
 #[derive(Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd, serde::Serialize, serde::Deserialize)]
 #[repr(transparent)]
 pub struct PortId(Id);
+pub struct PortId(pub(crate) Id);
 /// A safely aliasable heap-allocated payload of message bytes
 #[derive(Default, Eq, PartialEq, Clone, Ord, PartialOrd)]
 pub struct Payload(pub Arc<Vec<u8>>);
 #[derive(Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd)]
 /// "Orientation" of a port, determining whether they can send or receive messages with `put` and `get` respectively.
 #[repr(C)]
 #[derive(serde::Serialize, serde::Deserialize)]
 pub enum Polarity {
     Putter, // output port (from the perspective of the component)
     Getter, // input port (from the perspective of the component)
+}
 #[derive(Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd)]
 /// "Orientation" of a transport-layer network endpoint, dictating how it's connection procedure should
 /// be conducted. Corresponds with connect() / accept() familiar to TCP socket programming.
 #[repr(C)]
 pub enum EndpointPolarity {
     Active,  // calls connect()
     Passive, // calls bind() listen() accept()
+}
 #[derive(Debug, Clone)]
 pub(crate) enum NonsyncBlocker {
     Inconsistent,
     ComponentExit,
     SyncBlockStart,
+}
 #[derive(Debug, Clone)]
 pub(crate) enum SyncBlocker {
     Inconsistent,
     SyncBlockEnd,
     CouldntReadMsg(PortId),
     CouldntCheckFiring(PortId),
     PutMsg(PortId, Payload),
+}
 pub(crate) struct DenseDebugHex<'a>(pub &'a [u8]);
 pub(crate) struct DebuggableIter<I: Iterator<Item = T> + Clone, T: Debug>(pub(crate) I);
 ///////////////////// IMPL /////////////////////
 impl IdParts for Id {
     fn id_parts(self) -> (ConnectorId, U32Suffix) {
         (self.connector_id, self.u32_suffix)
+    }
+}
 impl IdParts for PortId {
     fn id_parts(self) -> (ConnectorId, U32Suffix) {
         self.0.id_parts()
+    }
+}
 impl IdParts for ComponentId {
     fn id_parts(self) -> (ConnectorId, U32Suffix) {
         self.0.id_parts()
+    }
+}
 impl U32Stream {
     pub(crate) fn next(&mut self) -> u32 {
         if self.next == u32::MAX {
             panic!("NO NEXT!")
+        }
         self.next += 1;
         self.next - 1
+    }
     pub(crate) fn n_skipped(mut self, n: u32) -> Self {
         self.next = self.next.saturating_add(n);
         self
+    }
+}
 impl From<Id> for PortId {
     fn from(id: Id) -> PortId {
         Self(id)
+    }
+}
 impl From<Id> for ComponentId {
     fn from(id: Id) -> Self {
         Self(id)
+    }
+}
 impl From<&[u8]> for Payload {
     fn from(s: &[u8]) -> Payload {
         Payload(Arc::new(s.to_vec()))
+    }
+}
 impl Payload {
     /// Create a new payload of uninitialized bytes with the given length.
     pub fn new(len: usize) -> Payload {
         let mut v = Vec::with_capacity(len);
         unsafe {
             v.set_len(len);
+        }
         Payload(Arc::new(v))
+    }
     /// Returns the length of the payload's byte sequence
     pub fn len(&self) -> usize {
         self.0.len()
+    }
     /// Allows shared reading of the payload's contents
     pub fn as_slice(&self) -> &[u8] {
         &self.0
+    }
     /// Allows mutation of the payload's contents.
     /// Results in a deep copy in the event this payload is aliased.
     pub fn as_mut_vec(&mut self) -> &mut Vec<u8> {
         Arc::make_mut(&mut self.0)
+    }
     /// Modifies this payload, concatenating the given immutable payload's contents.
     /// Results in a deep copy in the event this payload is aliased.
     pub fn concatenate_with(&mut self, other: &Self) {
         let bytes = other.as_slice().iter().copied();
         let me = self.as_mut_vec();
         me.extend(bytes);
+    }
+}
 impl serde::Serialize for Payload {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
+    {
         let inner: &Vec<u8> = &self.0;
         inner.serialize(serializer)
+    }
+}
 impl<'de> serde::Deserialize<'de> for Payload {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
+    {
         let inner: Vec<u8> = Vec::deserialize(deserializer)?;
         Ok(Self(Arc::new(inner)))
+    }
+}
 impl From<Vec<u8>> for Payload {
     fn from(s: Vec<u8>) -> Self {
         Self(s.into())
+    }
+}
 impl Debug for PortId {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         let (a, b) = self.id_parts();
         write!(f, "pid{}_{}", a, b)
+    }
+}
 impl Debug for ComponentId {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         let (a, b) = self.id_parts();
         write!(f, "cid{}_{}", a, b)
+    }
+}
 impl Debug for Payload {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         write!(f, "Payload[{:?}]", DenseDebugHex(self.as_slice()))
+    }
+}
 impl std::ops::Not for Polarity {
     type Output = Self;
     fn not(self) -> Self::Output {
         use Polarity::*;
         match self {
             Putter => Getter,
             Getter => Putter,
+        }
+    }
+}
 impl Debug for DenseDebugHex<'_> {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         for b in self.0 {
             write!(f, "{:02X?}", b)?;
+        }
         Ok(())
+    }
+}
 impl<I: Iterator<Item = T> + Clone, T: Debug> Debug for DebuggableIter<I, T> {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
         f.debug_list().entries(self.0.clone()).finish()
+    }
+}

src/protocol/eval/executor.rs

➞

Show inline comments

@@ @@ -10,957 +10,996 @@ use crate::protocol::type_table::*; @@
 macro_rules! debug_enabled { () => { false }; }
 macro_rules! debug_log {
     ($format:literal) => {
         enabled_debug_print!(false, "exec", $format);
     };
     ($format:literal, $($args:expr),*) => {
         enabled_debug_print!(false, "exec", $format, $($args),*);
     };
+}
 #[derive(Debug, Clone)]
 pub(crate) enum ExprInstruction {
     EvalExpr(ExpressionId),
     PushValToFront,
+}
 #[derive(Debug, Clone)]
 pub(crate) struct Frame {
     pub(crate) definition: DefinitionId,
     pub(crate) monomorph_idx: i32,
     pub(crate) position: StatementId,
     pub(crate) expr_stack: VecDeque<ExprInstruction>, // hack for expression evaluation, evaluated by popping from back
     pub(crate) expr_values: VecDeque<Value>, // hack for expression results, evaluated by popping from front/back
     pub(crate) max_stack_size: u32,
+}
 impl Frame {
     /// Creates a new execution frame. Does not modify the stack in any way.
     pub fn new(heap: &Heap, definition_id: DefinitionId, monomorph_idx: i32) -> 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),
         };
         // Another not-so-pretty thing that has to be replaced somewhere in the
         // future...
         fn determine_max_stack_size(heap: &Heap, block_id: BlockStatementId, max_size: &mut u32) {
             let block_stmt = &heap[block_id];
             debug_assert!(block_stmt.next_unique_id_in_scope >= 0);
             // Check current block
             let cur_size = block_stmt.next_unique_id_in_scope as u32;
             if cur_size > *max_size { *max_size = cur_size; }
             // And child blocks
             for child_scope in &block_stmt.scope_node.nested {
                 determine_max_stack_size(heap, child_scope.to_block(), max_size);
+            }
+        }
         let mut max_stack_size = 0;
         determine_max_stack_size(heap, first_statement, &mut max_stack_size);
         Frame{
             definition: definition_id,
             monomorph_idx,
             position: first_statement.upcast(),
             expr_stack: VecDeque::with_capacity(128),
             expr_values: VecDeque::with_capacity(128),
             max_stack_size,
+        }
+    }
     /// 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) => {
                 self.serialize_expression(heap, expr.bound_to);
                 self.serialize_expression(heap, expr.bound_from);
             },
             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) => {
                         // Note: fields expressions are evaluated in programmer-
                         // specified order. But struct construction expects them
                         // in type-defined order. I might want to come back to
                         // this.
                         let mut _num_pushed = 0;
                         for want_field_idx in 0..literal.fields.len() {
                             for field in &literal.fields {
                                 if field.field_idx == want_field_idx {
                                     _num_pushed += 1;
                                     self.expr_stack.push_back(ExprInstruction::PushValToFront);
                                     self.serialize_expression(heap, field.value);
+                                }
+                            }
+                        }
                         debug_assert_eq!(_num_pushed, literal.fields.len())
                     },
                     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::Cast(expr) => {
                 self.serialize_expression(heap, expr.subject);
+            }
             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, EvalError>;
 pub enum EvalContinuation {
     Stepping,
     Inconsistent,
     Terminal,
     SyncBlockStart,
     SyncBlockEnd,
     NewComponent(DefinitionId, i32, ValueGroup),
     BlockFires(Value),
     BlockGet(Value),
     Put(Value, Value),
     NewChannel,
     BlockFires(PortId),
     BlockGet(PortId),
     Put(PortId, 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(_types: &TypeTable, heap: &Heap, def: DefinitionId, monomorph_idx: i32, args: ValueGroup) -> Self {
         let mut prompt = Self{
             frames: Vec::new(),
             store: Store::new(),
         };
         // Maybe do typechecking in the future?
         debug_assert!((monomorph_idx as usize) < _types.get_base_definition(&def).unwrap().definition.procedure_monomorphs().len());
         let new_frame = Frame::new(heap, def, monomorph_idx);
         let max_stack_size = new_frame.max_stack_size;
         prompt.frames.push(new_frame);
         args.into_store(&mut prompt.store);
         prompt.store.reserve_stack(max_stack_size);
         prompt
+    }
     pub(crate) fn step(&mut self, types: &TypeTable, heap: &Heap, modules: &[Module], ctx: &mut EvalContext) -> EvalResult {
     /// Big 'ol function right here. Didn't want to break it up unnecessarily.
     /// It consists of, in sequence: executing any expressions that should be
     /// executed before the next statement can be evaluated, then a section that
     /// performs debug printing, and finally a section that takes the next
     /// statement and executes it. If the statement requires any expressions to
     /// be evaluated, then they will be added such that the next time `step` is
     /// called, all of these expressions are indeed evaluated.
     pub(crate) fn step(&mut self, types: &TypeTable, heap: &Heap, modules: &[Module], ctx: &mut impl RunContext) -> 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
+        }
         // Helper function to make sure that an index into an aray is valid.
         fn array_inclusive_index_is_invalid(store: &Store, array_heap_pos: u32, idx: i64) -> bool {
             let array_len = store.heap_regions[array_heap_pos as usize].values.len();
             return idx < 0 || idx >= array_len as i64;
+        }
         fn array_exclusive_index_is_invalid(store: &Store, array_heap_pos: u32, idx: i64) -> bool {
             let array_len = store.heap_regions[array_heap_pos as usize].values.len();
             return idx < 0 || idx > array_len as i64;
+        }
         fn construct_array_error(prompt: &Prompt, modules: &[Module], heap: &Heap, expr_id: ExpressionId, heap_pos: u32, idx: i64) -> EvalError {
             let array_len = prompt.store.heap_regions[heap_pos as usize].values.len();
             return EvalError::new_error_at_expr(
                 prompt, modules, heap, expr_id,
                 format!("index {} is out of bounds: array length is {}", idx, array_len)
+            )
+        }
         // 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) => {
                             let to = cur_frame.expr_values.pop_back().unwrap().as_ref();
                             let rhs = cur_frame.expr_values.pop_back().unwrap();
                             // Note: although not pretty, the assignment operator takes ownership
                             // of the right-hand side value when possible. So we do not drop the
                             // rhs's optionally owned heap data.
                             let rhs = self.store.read_take_ownership(rhs);
                             apply_assignment_operator(&mut self.store, to, expr.operation, rhs);
                         },
                         Expression::Binding(_expr) => {
                             let bind_to = cur_frame.expr_values.pop_back().unwrap();
                             let bind_from = cur_frame.expr_values.pop_back().unwrap();
                             let bind_to_heap_pos = bind_to.get_heap_pos();
                             let bind_from_heap_pos = bind_from.get_heap_pos();
                             let result = apply_binding_operator(&mut self.store, bind_to, bind_from);
                             self.store.drop_value(bind_to_heap_pos);
                             self.store.drop_value(bind_from_heap_pos);
                             cur_frame.expr_values.push_back(Value::Bool(result));
                         },
                         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) => {
                             // 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 i64
                             } else {
                                 index.as_unsigned_integer() as i64
                             };
                             let subject = cur_frame.expr_values.pop_back().unwrap();
                             let (deallocate_heap_pos, value_to_push) = match subject {
                                 Value::Ref(value_ref) => {
                                     // Our expression stack value is a reference to something that
                                     // exists in the normal stack/heap. We don't want to deallocate
                                     // this thing. Rather we want to return a reference to it.
                                     let subject = self.store.read_ref(value_ref);
                                     let subject_heap_pos = match subject {
                                         Value::String(v) => *v,
                                         Value::Array(v) => *v,
                                         Value::Message(v) => *v,
                                         _ => unreachable!(),
                                     };
                                     if array_inclusive_index_is_invalid(&self.store, subject_heap_pos, index) {
                                         return Err(construct_array_error(self, modules, heap, expr_id, subject_heap_pos, index));
+                                    }
                                     (None, Value::Ref(ValueId::Heap(subject_heap_pos, index as u32)))
                                 },
                                 _ => {
                                     // Our value lives on the expression stack, hence we need to
                                     // clone whatever we're referring to. Then drop the subject.
                                     let subject_heap_pos = match &subject {
                                         Value::String(v) => *v,
                                         Value::Array(v) => *v,
                                         Value::Message(v) => *v,
                                         _ => unreachable!(),
                                     };
                                     if array_inclusive_index_is_invalid(&self.store, subject_heap_pos, index) {
                                         return Err(construct_array_error(self, modules, heap, expr_id, subject_heap_pos, index));
+                                    }
                                     let subject_indexed = Value::Ref(ValueId::Heap(subject_heap_pos, index as u32));
                                     (Some(subject_heap_pos), self.store.clone_value(subject_indexed))
                                 },
                             };
                             cur_frame.expr_values.push_back(value_to_push);
                             self.store.drop_value(deallocate_heap_pos);
                         },
                         Expression::Slicing(expr) => {
                             // Evaluate indices
                             let from_index = cur_frame.expr_values.pop_back().unwrap();
                             let from_index = self.store.maybe_read_ref(&from_index);
                             let to_index = cur_frame.expr_values.pop_back().unwrap();
                             let to_index = self.store.maybe_read_ref(&to_index);
                             debug_assert!(from_index.is_integer() && to_index.is_integer());
                             let from_index = if from_index.is_signed_integer() {
                                 from_index.as_signed_integer()
                             } else {
                                 from_index.as_unsigned_integer() as i64
                             };
                             let to_index = if to_index.is_signed_integer() {
                                 to_index.as_signed_integer()
                             } else {
                                 to_index.as_unsigned_integer() as i64
                             };
                             // Dereference subject if needed
                             let subject = cur_frame.expr_values.pop_back().unwrap();
                             let deref_subject = self.store.maybe_read_ref(&subject);
                             // Slicing needs to produce a copy anyway (with the
                             // current evaluator implementation)
                             enum ValueKind{ Array, String, Message }
                             let (value_kind, array_heap_pos) = match deref_subject {
                                 Value::Array(v) => (ValueKind::Array, *v),
                                 Value::String(v) => (ValueKind::String, *v),
                                 Value::Message(v) => (ValueKind::Message, *v),
                                 _ => unreachable!()
                             };
                             if array_inclusive_index_is_invalid(&self.store, array_heap_pos, from_index) {
                                 return Err(construct_array_error(self, modules, heap, expr.from_index, array_heap_pos, from_index));
+                            }
                             if array_exclusive_index_is_invalid(&self.store, array_heap_pos, to_index) {
                                 return Err(construct_array_error(self, modules, heap, expr.to_index, array_heap_pos, to_index));
+                            }
                             // Again: would love to push directly, but rust...
                             let new_heap_pos = self.store.alloc_heap();
                             debug_assert!(self.store.heap_regions[new_heap_pos as usize].values.is_empty());
                             if to_index > from_index {
                                 let from_index = from_index as usize;
                                 let to_index = to_index as usize;
                                 let mut values = Vec::with_capacity(to_index - from_index);
                                 for idx in from_index..to_index {
                                     let value = self.store.heap_regions[array_heap_pos as usize].values[idx].clone();
                                     values.push(self.store.clone_value(value));
+                                }
                                 self.store.heap_regions[new_heap_pos as usize].values = values;
                             } // else: empty range
                             cur_frame.expr_values.push_back(match value_kind {
                                 ValueKind::Array => Value::Array(new_heap_pos),
                                 ValueKind::String => Value::String(new_heap_pos),
                                 ValueKind::Message => Value::Message(new_heap_pos),
                             });
                             // Dropping the original subject, because we don't
                             // want to drop something on the stack
                             self.store.drop_value(subject.get_heap_pos());
                         },
                         Expression::Select(expr) => {
                             let subject= cur_frame.expr_values.pop_back().unwrap();
                             let mono_data = types.get_procedure_expression_data(&cur_frame.definition, cur_frame.monomorph_idx);
                             let field_idx = mono_data.expr_data[expr.unique_id_in_definition as usize].field_or_monomorph_idx as u32;
                             // Note: same as above: clone if value lives on expr stack, simply
                             // refer to it if it already lives on the stack/heap.
                             let (deallocate_heap_pos, value_to_push) = match subject {
                                 Value::Ref(value_ref) => {
                                     let subject = self.store.read_ref(value_ref);
                                     let subject_heap_pos = subject.as_struct();
                                     (None, Value::Ref(ValueId::Heap(subject_heap_pos, field_idx)))
                                 },
                                 _ => {
                                     let subject_heap_pos = subject.as_struct();
                                     let subject_indexed = Value::Ref(ValueId::Heap(subject_heap_pos, field_idx));
                                     (Some(subject_heap_pos), self.store.clone_value(subject_indexed))
                                 },
                             };
                             cur_frame.expr_values.push_back(value_to_push);
                             self.store.drop_value(deallocate_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;
                                     let def_types = types.get_procedure_expression_data(&cur_frame.definition, cur_frame.monomorph_idx);
                                     let concrete_type = &def_types.expr_data[expr.unique_id_in_definition as usize].expr_type;
                                     debug_assert_eq!(concrete_type.parts.len(), 1);
                                     match 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!("got concrete type {:?} for integer literal at expr {:?}", concrete_type, expr_id),
+                                    }
+                                }
                                 Literal::Struct(lit_value) => {
                                     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 = 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 = 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::Cast(expr) => {
                             let mono_data = types.get_procedure_expression_data(&cur_frame.definition, cur_frame.monomorph_idx);
                             let output_type = &mono_data.expr_data[expr.unique_id_in_definition as usize].expr_type;
                             // Typechecking reduced this to two cases: either we
                             // have casting noop (same types), or we're casting
                             // between integer/bool/char types.
                             let subject = cur_frame.expr_values.pop_back().unwrap();
                             match apply_casting(&mut self.store, output_type, &subject) {
                                 Ok(value) => cur_frame.expr_values.push_back(value),
                                 Err(msg) => {
                                     return Err(EvalError::new_error_at_expr(self, modules, heap, expr.this.upcast(), msg));
+                                }
+                            }
                             self.store.drop_value(subject.get_heap_pos());
+                        }
                         Expression::Call(expr) => {
                             // If we're dealing with a builtin we don't do any
                             // fancy shenanigans at all, just push the result.
                             match expr.method {
                                 Method::Get => {
                                     let value = cur_frame.expr_values.pop_front().unwrap();
                                     let value = self.store.maybe_read_ref(&value).clone();
                                     match ctx.get(value.clone(), &mut self.store) {
                                     let port_id = if let Value::Input(port_id) = value {
                                         port_id
                                     } else {
                                         unreachable!("executor calling 'get' on value {:?}", value)
                                     };
                                     match ctx.get(port_id, &mut self.store) {
                                         Some(result) => {
                                             // We have the result
                                             cur_frame.expr_values.push_back(result)
                                         },
                                         None => {
                                             // Don't have the result yet, prepare the expression to
                                             // get run again after we've received a message.
                                             cur_frame.expr_values.push_front(value.clone());
                                             cur_frame.expr_stack.push_back(ExprInstruction::EvalExpr(expr_id));
-                                            return Ok(EvalContinuation::BlockGet(value));
+                                            return Ok(EvalContinuation::BlockGet(port_id));
+                                        }
+                                    }
                                 },
                                 Method::Put => {
                                     let port_value = cur_frame.expr_values.pop_front().unwrap();
                                     let deref_port_value = self.store.maybe_read_ref(&port_value).clone();
                                     let port_id = if let Value::Output(port_id) = deref_port_value {
                                         port_id
                                     } else {
                                         unreachable!("executor calling 'put' on value {:?}", deref_port_value)
                                     };
                                     let msg_value = cur_frame.expr_values.pop_front().unwrap();
                                     let deref_msg_value = self.store.maybe_read_ref(&msg_value).clone();
                                     match deref_msg_value {
                                         Value::Message(_) => {},
                                         _ => {
                                             return Err(EvalError::new_error_at_expr(
                                                 self, modules, heap, expr_id,
                                                 String::from("Calls to `put` are currently restricted to only send instances of `msg` types. This will change in the future")
                                             ));
+                                        }
+                                    }
-                                    if ctx.did_put(deref_port_value.clone()) {
+                                    if ctx.did_put(port_id) {
                                         // We're fine, deallocate in case the expression value stack
                                         // held an owned value
                                         self.store.drop_value(msg_value.get_heap_pos());
                                     } else {
                                         cur_frame.expr_values.push_front(msg_value);
                                         cur_frame.expr_values.push_front(port_value);
                                         cur_frame.expr_stack.push_back(ExprInstruction::EvalExpr(expr_id));
-                                        return Ok(EvalContinuation::Put(deref_port_value, deref_msg_value));
+                                        return Ok(EvalContinuation::Put(port_id, deref_msg_value));
+                                    }
                                 },
                                 Method::Fires => {
                                     let port_value = cur_frame.expr_values.pop_front().unwrap();
                                     let port_value_deref = self.store.maybe_read_ref(&port_value).clone();
                                     match ctx.fires(port_value_deref.clone()) {
                                     let port_id = match port_value_deref {
                                         Value::Input(port_id) => port_id,
                                         Value::Output(port_id) => port_id,
                                         _ => unreachable!("executor calling 'fires' on value {:?}", value),
                                     };
                                     match ctx.fires(port_id) {
                                         None => {
                                             cur_frame.expr_values.push_front(port_value);
                                             cur_frame.expr_stack.push_back(ExprInstruction::EvalExpr(expr_id));
-                                            return Ok(EvalContinuation::BlockFires(port_value_deref));
+                                            return Ok(EvalContinuation::BlockFires(port_id));
                                         },
                                         Some(value) => {
                                             cur_frame.expr_values.push_back(value);
+                                        }
+                                    }
                                 },
                                 Method::Create => {
                                     let length_value = cur_frame.expr_values.pop_front().unwrap();
                                     let length_value = self.store.maybe_read_ref(&length_value);
                                     let length = if length_value.is_signed_integer() {
                                         let length_value = length_value.as_signed_integer();
                                         if length_value < 0 {
                                             return Err(EvalError::new_error_at_expr(
                                                 self, modules, heap, expr_id,
                                                 format!("got length '{}', can only create a message with a non-negative length", length_value)
                                             ));
+                                        }
                                         length_value as u64
                                     } else {
                                         debug_assert!(length_value.is_unsigned_integer());
                                         length_value.as_unsigned_integer()
                                     };
                                     let heap_pos = self.store.alloc_heap();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     debug_assert!(values.is_empty());
                                     values.resize(length as usize, Value::UInt8(0));
                                     cur_frame.expr_values.push_back(Value::Message(heap_pos));
                                 },
                                 Method::Length => {
                                     let value = cur_frame.expr_values.pop_front().unwrap();
                                     let value_heap_pos = value.get_heap_pos();
                                     let value = self.store.maybe_read_ref(&value);
                                     let heap_pos = match value {
                                         Value::Array(pos) => *pos,
                                         Value::String(pos) => *pos,
                                         _ => unreachable!("length(...) on {:?}", value),
                                     };
                                     let len = self.store.heap_regions[heap_pos as usize].values.len();
                                     // TODO: @PtrInt
                                     cur_frame.expr_values.push_back(Value::UInt32(len as u32));
                                     self.store.drop_value(value_heap_pos);
                                 },
                                 Method::Assert => {
                                     let value = cur_frame.expr_values.pop_front().unwrap();
                                     let value = self.store.maybe_read_ref(&value).clone();
                                     if !value.as_bool() {
                                         return Ok(EvalContinuation::Inconsistent)
+                                    }
                                 },
                                 Method::UserComponent => {
                                     // This is actually handled by the evaluation
                                     // of the statement.
                                     debug_assert_eq!(heap[expr.definition].parameters().len(), cur_frame.expr_values.len());
                                     debug_assert_eq!(heap[cur_frame.position].as_new().expression, expr.this)
                                 },
                                 Method::UserFunction => {
                                     // 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();
                                     // Determine stack boundaries
                                     let cur_stack_boundary = self.store.cur_stack_boundary;
                                     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 {
                                         let argument = self.store.read_take_ownership(cur_frame.expr_values.pop_front().unwrap());
                                         self.store.stack.push(argument);
+                                    }
                                     // Determine the monomorph index of the function we're calling
                                     let mono_data = types.get_procedure_expression_data(&cur_frame.definition, cur_frame.monomorph_idx);
                                     let call_data = &mono_data.expr_data[expr.unique_id_in_definition as usize];
                                     // Push the new frame and reserve its stack size
                                     let new_frame = Frame::new(heap, expr.definition, call_data.field_or_monomorph_idx);
                                     let new_stack_size = new_frame.max_stack_size;
                                     self.frames.push(new_frame);
                                     self.store.cur_stack_boundary = new_stack_boundary;
                                     self.store.reserve_stack(new_stack_size);
                                     // 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()];
                             let ref_value = if expr.used_as_binding_target {
                                 Value::Binding(variable.unique_id_in_scope as StackPos)
                             } else {
                                 Value::Ref(ValueId::Stack(variable.unique_id_in_scope as StackPos))
                             };
                             cur_frame.expr_values.push_back(ref_value);
+                        }
+                    }
+                }
+            }
+        }
         debug_log!("Frame [{:?}] at {:?}", cur_frame.definition, cur_frame.position);
         if debug_enabled!() {
             debug_log!("Expression value stack (size = {}):", cur_frame.expr_values.len());
             for (_stack_idx, _stack_val) in cur_frame.expr_values.iter().enumerate() {
                 debug_log!("  [{:03}] {:?}", _stack_idx, _stack_val);
+            }
             debug_log!("Stack (size = {}):", self.store.stack.len());
             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) => {
                 debug_assert!(stmt.statements.is_empty() || stmt.next == stmt.statements[0]);
                 cur_frame.position = stmt.next;
                 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;
                         Ok(EvalContinuation::Stepping)
                     },
                     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);
                         // Need to create a new channel by requesting it from
                         // the runtime.
                         match ctx.get_channel() {
                             None => {
                                 // No channel is pending. So request one
                                 Ok(EvalContinuation::NewChannel)
                             },
                             Some((put_port, get_port)) => {
                                 self.store.write(ValueId::Stack(heap[stmt.from].unique_id_in_scope as u32), put_port);
                                 self.store.write(ValueId::Stack(heap[stmt.to].unique_id_in_scope as u32), get_port);
                                 cur_frame.position = stmt.next;
                                 Ok(EvalContinuation::Stepping)
+                            }
+                        }
+                    }
+                }
                 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();
                 let test_value = self.store.maybe_read_ref(&test_value).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();
                 let test_value = self.store.maybe_read_ref(&test_value).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();
                 let return_value = match return_value {
                     Value::Ref(value_id) => self.store.read_copy(value_id),
                     _ => return_value,
                 };
                 // Pre-emptively pop our stack frame
                 self.frames.pop();
                 // Clean up our section of the stack
                 self.store.clear_stack(0);
                 self.store.stack.truncate(self.store.cur_stack_boundary + 1);
                 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);
                     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);
                 // We just returned to the previous frame, which might be in
                 // the middle of evaluating expressions for a particular
                 // statement. So we don't want to enter the code below.
                 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"
                 );
                 let mono_data = types.get_procedure_expression_data(&cur_frame.definition, cur_frame.monomorph_idx);
                 let expr_data = &mono_data.expr_data[call_expr.unique_id_in_definition as usize];
                 // 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;
                 Ok(EvalContinuation::NewComponent(call_expr.definition, expr_data.field_or_monomorph_idx, 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(); PROPER CLEARING
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
         };
         assert!(
             cur_frame.expr_values.is_empty(),
             "This is a debugging assertion that will fail if you perform expressions without \
             assigning to anything. This should be completely valid, and this assertion should be \
             replaced by something that clears the expression values if needed, but I'll keep this \
             in for now for debugging purposes."
         );
         // 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/mod.rs

➞

Show inline comments

 mod arena;
 pub(crate) mod eval;
 pub(crate) mod input_source;
 mod parser;
 #[cfg(test)] mod tests;
 pub(crate) mod ast;
 pub(crate) mod ast_printer;
 use std::sync::Mutex;
 use crate::collections::{StringPool, StringRef};
 use crate::common::*;
 use crate::protocol::ast::*;
 use crate::protocol::eval::*;
 use crate::protocol::input_source::*;
 use crate::protocol::parser::*;
 use crate::protocol::type_table::*;
 /// A protocol description module
 pub struct Module {
     pub(crate) source: InputSource,
     pub(crate) root_id: RootId,
     pub(crate) name: Option<StringRef<'static>>,
+}
 /// Description of a protocol object, used to configure new connectors.
 #[repr(C)]
 pub struct ProtocolDescription {
     modules: Vec<Module>,
     heap: Heap,
     types: TypeTable,
     pool: Mutex<StringPool>,
     pub(crate) modules: Vec<Module>,
     pub(crate) heap: Heap,
     pub(crate) types: TypeTable,
     pub(crate) pool: Mutex<StringPool>,
+}
 #[derive(Debug, Clone)]
 pub(crate) struct ComponentState {
     prompt: Prompt,
+    pub(crate) prompt: Prompt,
+}
 #[allow(dead_code)]
 pub(crate) enum EvalContext<'a> {
     Nonsync(&'a mut NonsyncProtoContext<'a>),
     Sync(&'a mut SyncProtoContext<'a>),
     None,
+}
 //////////////////////////////////////////////
 impl std::fmt::Debug for ProtocolDescription {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "(An opaque protocol description)")
+    }
+}
 impl ProtocolDescription {
     // TODO: Allow for multi-file compilation
     pub fn parse(buffer: &[u8]) -> Result<Self, String> {
         // TODO: @fixme, keep code compilable, but needs support for multiple
         //  input files.
         let source = InputSource::new(String::new(), Vec::from(buffer));
         let mut parser = Parser::new();
         parser.feed(source).expect("failed to feed source");
         if let Err(err) = parser.parse() {
             println!("ERROR:\n{}", err);
             return Err(format!("{}", err))
+        }
         debug_assert_eq!(parser.modules.len(), 1, "only supporting one module here for now");
         let modules: Vec<Module> = parser.modules.into_iter()
             .map(|module| Module{
                 source: module.source,
                 root_id: module.root_id,
                 name: module.name.map(|(_, name)| name)
             })
             .collect();
         return Ok(ProtocolDescription {
             modules,
             heap: parser.heap,
             types: parser.type_table,
             pool: Mutex::new(parser.string_pool),
         });
+    }
     pub(crate) fn component_polarities(
         &self,
         module_name: &[u8],
         identifier: &[u8],
     ) -> Result<Vec<Polarity>, AddComponentError> {
         use AddComponentError::*;
         let module_root = self.lookup_module_root(module_name);
         if module_root.is_none() {
             return Err(AddComponentError::NoSuchModule);
+        }
         let module_root = module_root.unwrap();
         let root = &self.heap[module_root];
         let def = root.get_definition_ident(&self.heap, identifier);
         if def.is_none() {
             return Err(NoSuchComponent);
+        }
         let def = &self.heap[def.unwrap()];
         if !def.is_component() {
             return Err(NoSuchComponent);
+        }
         for &param in def.parameters().iter() {
             let param = &self.heap[param];
             let first_element = &param.parser_type.elements[0];
             match first_element.variant {
                 ParserTypeVariant::Input | ParserTypeVariant::Output => continue,
                 _ => {
                     return Err(NonPortTypeParameters);
+                }
+            }
+        }
         let mut result = Vec::new();
         for &param in def.parameters().iter() {
             let param = &self.heap[param];
             let first_element = &param.parser_type.elements[0];
             if first_element.variant == ParserTypeVariant::Input {
                 result.push(Polarity::Getter)
             } else if first_element.variant == ParserTypeVariant::Output {
                 result.push(Polarity::Putter)
             } else {
                 unreachable!()
+            }
+        }
         Ok(result)
+    }
     // expects port polarities to be correct
     pub(crate) fn new_component(&self, module_name: &[u8], identifier: &[u8], ports: &[PortId]) -> ComponentState {
         let mut args = Vec::new();
         for (&x, y) in ports.iter().zip(self.component_polarities(module_name, identifier).unwrap()) {
             match y {
                 Polarity::Getter => args.push(Value::Input(x)),
                 Polarity::Putter => args.push(Value::Output(x)),
+            }
+        }
         let module_root = self.lookup_module_root(module_name).unwrap();
         let root = &self.heap[module_root];
         let def = root.get_definition_ident(&self.heap, identifier).unwrap();
         // TODO: Check for polymorph
         ComponentState { prompt: Prompt::new(&self.types, &self.heap, def, 0, ValueGroup::new_stack(args)) }
+    }
     fn lookup_module_root(&self, module_name: &[u8]) -> Option<RootId> {
         for module in self.modules.iter() {
             match &module.name {
                 Some(name) => if name.as_bytes() == module_name {
                     return Some(module.root_id);
                 },
                 None => if module_name.is_empty() {
                     return Some(module.root_id);
+                }
+            }
+        }
         return None;
+    }
+}
 // TODO: @temp Should just become a concrete thing that is passed in
 pub trait RunContext {
     fn did_put(&self, port: PortId) -> bool;
     fn get(&self, port: PortId) -> Option<Value>; // None if still waiting on message
     fn fires(&self, port: PortId) -> Option<Value>; // None if not yet branched
     fn get_channel(&self) -> Option<(Value, Value)>; // None if not yet prepared
+}
 #[derive(Debug)]
 pub enum RunResult {
     // Can only occur outside sync blocks
     ComponentTerminated, // component has exited its procedure
     ComponentAtSyncStart,
     NewComponent(DefinitionId, i32, ValueGroup), // should also be possible inside sync
     NewChannel, // should also be possible inside sync
     // Can only occur inside sync blocks
     BranchInconsistent, // branch has inconsistent behaviour
     BranchMissingPortState(PortId), // branch doesn't know about port firing
     BranchMissingPortValue(PortId), // branch hasn't received message on input port yet
     BranchAtSyncEnd,
     BranchPut(PortId, ValueGroup),
+}
 impl ComponentState {
     pub(crate) fn run(&mut self, ctx: &mut impl RunContext, pd: &ProtocolDescription) -> RunResult {
         use EvalContinuation as EC;
         use RunResult as RR;
         loop {
             let step_result = self.prompt.step(&pd.types, &pd.heap, &pd.modules, ctx);
             match step_result {
                 Err(reason) => {
                     // TODO: @temp
                     println!("Evaluation error:\n{}", reason);
                     todo!("proper error handling/bubbling up");
                 },
                 Ok(continuation) => match continuation {
                     // TODO: Probably want to remove this translation
                     EC::Stepping => continue,
                     EC::Inconsistent => return RR::BranchInconsistent,
                     EC::Terminal => return RR::ComponentTerminated,
                     EC::SyncBlockStart => return RR::ComponentAtSyncStart,
                     EC::SyncBlockEnd => return RR::BranchAtSyncEnd,
                     EC::NewComponent(definition_id, monomorph_idx, args) =>
                         return RR::NewComponent(definition_id, monomorph_idx, arg),
                     EC::NewChannel =>
                         return RR::NewChannel,
                     EC::BlockFires(port_id) => return RR::BranchMissingPortState(port_id),
                     EC::BlockGet(port_id) => return RR::BranchMissingPortValue(port_id),
                     EC::Put(port_id, value) => {
                         let value_group = ValueGroup::from_store(&self.prompt.store, &[value]);
                         return RR::BranchPut(port_id, value_group);
                     },
+                }
+            }
+        }
+    }
+}
 // TODO: @remove the old stuff
 impl ComponentState {
     pub(crate) fn nonsync_run<'a: 'b, 'b>(
         &'a mut self,
         context: &'b mut NonsyncProtoContext<'b>,
         pd: &'a ProtocolDescription,
     ) -> NonsyncBlocker {
         let mut context = EvalContext::Nonsync(context);
         loop {
             let result = self.prompt.step(&pd.types, &pd.heap, &pd.modules, &mut context);
             match result {
                 Err(err) => {
                     println!("Evaluation error:\n{}", err);
                     panic!("proper error handling when component fails");
                 },
                 Ok(cont) => match cont {
                     EvalContinuation::Stepping => continue,
                     EvalContinuation::Inconsistent => return NonsyncBlocker::Inconsistent,
                     EvalContinuation::Terminal => return NonsyncBlocker::ComponentExit,
                     EvalContinuation::SyncBlockStart => return NonsyncBlocker::SyncBlockStart,
                     // Not possible to end sync block if never entered one
                     EvalContinuation::SyncBlockEnd => unreachable!(),
                     EvalContinuation::NewComponent(definition_id, monomorph_idx, args) => {
                         // Look up definition (TODO for now, assume it is a definition)
                         let mut moved_ports = HashSet::new();
                         for arg in args.values.iter() {
                             match arg {
                                 Value::Output(port) => {
                                     moved_ports.insert(*port);
+                                }
                                 Value::Input(port) => {
                                     moved_ports.insert(*port);
+                                }
                                 _ => {}
+                            }
+                        }
                         for region in args.regions.iter() {
                             for arg in region {
                                 match arg {
                                     Value::Output(port) => { moved_ports.insert(*port); },
                                     Value::Input(port) => { moved_ports.insert(*port); },
                                     _ => {},
+                                }
+                            }
+                        }
                         let init_state = ComponentState { prompt: Prompt::new(&pd.types, &pd.heap, definition_id, monomorph_idx, args) };
                         context.new_component(moved_ports, init_state);
                         // Continue stepping
                         continue;
+                    }
                     // Outside synchronous blocks, no fires/get/put happens
                     EvalContinuation::BlockFires(_) => unreachable!(),
                     EvalContinuation::BlockGet(_) => unreachable!(),
                     EvalContinuation::Put(_, _) => unreachable!(),
                 },
+            }
+        }
+    }
     pub(crate) fn sync_run<'a: 'b, 'b>(
         &'a mut self,
         context: &'b mut SyncProtoContext<'b>,
         pd: &'a ProtocolDescription,
     ) -> SyncBlocker {
         let mut context = EvalContext::Sync(context);
         loop {
             let result = self.prompt.step(&pd.types, &pd.heap, &pd.modules, &mut context);
             match result {
                 Err(err) => {
                     println!("Evaluation error:\n{}", err);
                     panic!("proper error handling when component fails");
                 },
                 Ok(cont) => match cont {
                     EvalContinuation::Stepping => continue,
                     EvalContinuation::Inconsistent => return SyncBlocker::Inconsistent,
                     // First need to exit synchronous block before definition may end
                     EvalContinuation::Terminal => unreachable!(),
                     // No nested synchronous blocks
                     EvalContinuation::SyncBlockStart => unreachable!(),
                     EvalContinuation::SyncBlockEnd => return SyncBlocker::SyncBlockEnd,
                     // Not possible to create component in sync block
                     EvalContinuation::NewComponent(_, _, _) => unreachable!(),
                     EvalContinuation::BlockFires(port) => match port {
                         Value::Output(port) => {
                             return SyncBlocker::CouldntCheckFiring(port);
+                        }
                         Value::Input(port) => {
                             return SyncBlocker::CouldntCheckFiring(port);
+                        }
                         _ => unreachable!(),
                     },
                     EvalContinuation::BlockGet(port) => match port {
                         Value::Output(port) => {
                             return SyncBlocker::CouldntReadMsg(port);
+                        }
                         Value::Input(port) => {
                             return SyncBlocker::CouldntReadMsg(port);
+                        }
                         _ => unreachable!(),
                     },
                     EvalContinuation::Put(port, message) => {
                         let value;
                         match port {
                             Value::Output(port_value) => {
                                 value = port_value;
+                            }
                             Value::Input(port_value) => {
                                 value = port_value;
+                            }
                             _ => unreachable!(),
+                        }
                         let payload;
                         match message {
                             Value::Null => {
                                 return SyncBlocker::Inconsistent;
                             },
                             Value::Message(heap_pos) => {
                                 // Create a copy of the payload
                                 let values = &self.prompt.store.heap_regions[heap_pos as usize].values;
                                 let mut bytes = Vec::with_capacity(values.len());
                                 for value in values {
                                     bytes.push(value.as_uint8());
+                                }
                                 payload = Payload(Arc::new(bytes));
+                            }
                             _ => unreachable!(),
+                        }
-                        return SyncBlocker::PutMsg(value, payload);
+                        return SyncBlocker::PutMsg(port, payload);
+                    }
                 },
+            }
+        }
+    }
+}
 impl EvalContext<'_> {
     // fn random(&mut self) -> LongValue {
     //     match self {
     //         // EvalContext::None => unreachable!(),
     //         EvalContext::Nonsync(_context) => todo!(),
     //         EvalContext::Sync(_) => unreachable!(),
     //     }
     // }
     fn new_component(&mut self, moved_ports: HashSet<PortId>, init_state: ComponentState) -> () {
         match self {
             EvalContext::None => unreachable!(),
             EvalContext::Nonsync(context) => {
                 context.new_component(moved_ports, init_state)
+            }
             EvalContext::Sync(_) => unreachable!(),
+        }
+    }
     fn new_channel(&mut self) -> [Value; 2] {
         match self {
             EvalContext::None => unreachable!(),
             EvalContext::Nonsync(context) => {
                 let [from, to] = context.new_port_pair();
                 let from = Value::Output(from);
                 let to = Value::Input(to);
                 return [from, to];
+            }
             EvalContext::Sync(_) => unreachable!(),
+        }
+    }
     fn fires(&mut self, port: Value) -> Option<Value> {
         match self {
             EvalContext::None => unreachable!(),
             EvalContext::Nonsync(_) => unreachable!(),
             EvalContext::Sync(context) => match port {
                 Value::Output(port) => context.is_firing(port).map(Value::Bool),
                 Value::Input(port) => context.is_firing(port).map(Value::Bool),
                 _ => unreachable!(),
             },
+        }
+    }
     fn get(&mut self, port: Value, store: &mut Store) -> Option<Value> {
         match self {
             EvalContext::None => unreachable!(),
             EvalContext::Nonsync(_) => unreachable!(),
             EvalContext::Sync(context) => match port {
                 Value::Input(port) => {
                     let payload = context.read_msg(port);
                     if payload.is_none() { return None; }
                     let heap_pos = store.alloc_heap();
                     let heap_pos_usize = heap_pos as usize;
                     let payload = payload.unwrap();
                     store.heap_regions[heap_pos_usize].values.reserve(payload.0.len());
                     for value in payload.0.iter() {
                         store.heap_regions[heap_pos_usize].values.push(Value::UInt8(*value));
+                    }
                     return Some(Value::Message(heap_pos));
+                }
                 _ => unreachable!(),
             },
+        }
+    }
     fn did_put(&mut self, port: Value) -> bool {
         match self {
             EvalContext::None => unreachable!("did_put in None context"),
             EvalContext::Nonsync(_) => unreachable!("did_put in nonsync context"),
             EvalContext::Sync(context) => match port {
                 Value::Output(port) => {
                     context.did_put_or_get(port)
                 },
                 _ => unreachable!("did_put on non-output port value")
+            }
+        }
+    }
+}

src/runtime2/mod.rs

➞

Show inline comments

		mod runtime;
		\ No newline at end of file
		mod registry;
		\ No newline at end of file

src/runtime2/registry.rs

➞

Show inline comments

deleted file

src/runtime2/runtime.rs

➞

Show inline comments

 use std::sync::Arc;
 use std::collections::{HashMap, VecDeque};
 use std::collections::hash_map::{Entry};
 use crate::runtime::error as old_error;
 use crate::Polarity;
 use crate::{Polarity, PortId};
 use crate::common::Id;
 use crate::protocol::*;
 use crate::protocol::eval::*;
 use super::registry::Registry;
 enum AddComponentError {
     ModuleDoesNotExist,
     ConnectorDoesNotExist,
     InvalidArgumentType(usize), // value is index of (first) invalid argument
+}
 struct PortDesc {
     id: u32,
     peer_id: u32,
     owning_connector_id: Option<u32>,
     is_getter: bool, // otherwise one can only call `put`
+}
 // Message received from some kind of peer
 struct BufferedMessage {
     // If in inbox, then sender is the connector's peer. If in the outbox, then
     // the sender is the connector itself.
     sending_port: PortId,
     receiving_port: PortId,
     peer_prev_branch_id: Option<u32>, // of the sender
     peer_cur_branch_id: u32, // of the sender
     message: ValueGroup,
+}
 struct ConnectorDesc {
     id: u32,
     in_sync: bool,
     branches: Vec<BranchDesc>, // first one is always non-speculative one
     branch_id_counter: u32,
     spec_branches_active: VecDeque<u32>, // branches that can be run immediately
     spec_branches_pending_receive: HashMap<PortId, u32>, // from port_id to branch index
     global_inbox: HashMap<(PortId, u32), BufferedMessage>,
     global_outbox: HashMap<(PortId, u32), BufferedMessage>,
+}
 impl ConnectorDesc {
     /// Creates a new connector description. Implicit assumption is that there
     /// is one (non-sync) branch that can be immediately executed.
     fn new(id: u32, component_state: ComponentState, owned_ports: Vec<u32>) -> Self {
         let mut branches_active = VecDeque::new();
         branches_active.push_back(0);
         Self{
             id,
             in_sync: false,
             branches: vec![BranchDesc::new_non_sync(component_state, owned_ports)],
             branch_id_counter: 1,
             spec_branches_active: branches_active,
             spec_branches_pending_receive: HashMap::new(),
             global_inbox: HashMap::new(),
             global_outbox: HashMap::new(),
+        }
+    }
+}
 enum BranchState {
     RunningNonSync, // regular running non-speculative branch
     RunningSync, // regular running speculative branch
     BranchPoint, // branch which ended up being a branching point
     ReachedEndSync, // branch that successfully reached the end-sync point, is a possible local solution
     Failed, // branch that became inconsistent
+}
 struct BranchPortDesc {
     last_registered_identifier: Option<u32>, // if putter, then last sent branch ID, if getter, then last received branch ID
     num_times_fired: u32, // number of puts/gets on this port
+}
 struct BranchDesc {
     index: u32,
     parent_index: Option<u32>,
     identifier: u32,
     code_state: ComponentState,
     branch_state: BranchState,
     owned_ports: Vec<u32>,
     message_inbox: HashMap<(PortId, u32), ValueGroup>, // from (port id, 1-based recv index) to received value
     port_mapping: HashMap<PortId, BranchPortDesc>,
+}
 impl BranchDesc {
     /// Creates the first non-sync branch of a connector
     fn new_non_sync(component_state: ComponentState, owned_ports: Vec<u32>) -> Self {
         Self{
             index: 0,
             parent_index: None,
             identifier: 0,
             code_state: component_state,
             branch_state: BranchState::RunningNonSync,
             owned_ports,
             message_inbox: HashMap::new(),
             port_mapping: HashMap::new(),
+        }
+    }
     /// Creates a sync branch based on the supplied branch. This supplied branch
     /// is the branching point for the new one, i.e. the parent in the branching
     /// tree.
     fn new_sync_from(index: u32, identifier: u32, branch_state: &BranchDesc) -> Self {
         Self{
             index,
             parent_index: Some(branch_state.index),
             identifier,
             code_state: branch_state.code_state.clone(),
             branch_state: BranchState::RunningSync,
             owned_ports: branch_state.owned_ports.clone(),
             message_inbox: branch_state.message_inbox.clone(),
             port_mapping: branch_state.port_mapping.clone(),
+        }
+    }
+}
 // Separate from Runtime for borrowing reasons
 struct Registry {
     ports: HashMap<u32, PortDesc>,
     port_counter: u32,
     connectors: HashMap<u32, ConnectorDesc>,
     connector_counter: u32,
+}
 impl Registry {
     fn new() -> Self {
         Self{
             ports: HashMap::new(),
             port_counter: 0,
             connectors: HashMap::new(),
             connector_counter: 0,
+        }
+    }
     /// Returns (putter_port, getter_port)
     pub fn add_channel(&mut self, owning_connector_id: Option<u32>) -> (u32, u32) {
         let get_id = self.generate_port_id();
         let put_id = self.generate_port_id();
         self.ports.insert(get_id, PortDesc{
             id: get_id,
             peer_id: put_id,
             owning_connector_id,
             is_getter: true,
         });
         self.ports.insert(put_id, PortDesc{
             id: put_id,
             peer_id: get_id,
             owning_connector_id,
             is_getter: false,
         });
         return (put_id, get_id);
+    }
     fn generate_port_id(&mut self) -> u32 {
         let id = self.port_counter;
         self.port_counter += 1;
         return id;
+    }
+}
 // TODO: @performance, use freelists+ids instead of HashMaps
 struct Runtime {
     protocol: Arc<ProtocolDescription>,
     registry: Registry,
     connectors_active: VecDeque<u32>,
+}
 impl Runtime {
     pub fn new(pd: Arc<ProtocolDescription>) -> Self {
         Self{ protocol: pd }
         Self{
             protocol: pd,
             registry: Registry::new(),
             connectors_active: VecDeque::new(),
+        }
+    }
     /// Creates a new channel that is not owned by any connector and returns its
     /// endpoints. The returned values are of the (putter port, getter port)
     /// respectively.
     pub fn add_channel(&mut self) -> (Value, Value) {
         let (put_id, get_id) = self.registry.add_channel(None);
         return (
             port_value_from_id(None, put_id, true),
             port_value_from_id(None, get_id, false)
         );
+    }
     pub fn add_component(&mut self, module: &str, procedure: &str, values: ValueGroup) -> Result<(), AddComponentError> {
         use AddComponentError as ACE;
-        use old_error::AddComponentError as OldACE;
+        use crate::runtime::error::AddComponentError as OldACE;
         // TODO: Allow the ValueGroup to contain any kind of value
         // TODO: Remove the responsibility of adding a component from the PD
         // Lookup module and the component
         // TODO: Remove this error enum translation
         // TODO: Remove this error enum translation. Note that for now this
         //  function forces port-only arguments
         let port_polarities = match self.protocol.component_polarities(module.as_bytes(), procedure.as_bytes()) {
             Ok(polarities) => polarities,
             Err(reason) => match reason {
                 OldACE::NonPortTypeParameters => return Err(ACE::InvalidArgumentType(0)),
                 OldACE::NoSuchModule => return Err(ACE::ModuleDoesNotExist),
                 OldACE::NoSuchComponent => return Err(ACE::ModuleDoesNotExist),
                 _ => unreachable!(),
+            }
         };
         // Make sure supplied values (and types) are correct
         let mut ports = Vec::with_capacity(values.values.len());
         for (value_idx, value) in values.values.iter().enumerate() {
             let polarity = &port_polarities[value_idx];
             match value {
                 Value::Input(port_id) => {
                     if *polarity != Polarity::Getter {
                         return Err(ACE::InvalidArgumentType(value_idx))
+                    }
                     ports.push(*port_id);
                 },
                 Value::Output(port_id) => {
                     if *polarity != Polarity::Putter {
                         return Err(ACE::InvalidArgumentType(value_idx))
+                    }
                     ports.push(*port_id);
                 },
                 _ => return Err(ACE::InvalidArgumentType(value_idx))
+            }
+        }
         // Instantiate the component
         let component_id = self.generate_connector_id();
         let component_state = self.protocol.new_component(module.as_bytes(), procedure.as_bytes(), &ports);
         let ports = ports.into_iter().map(|v| v.0.u32_suffix).collect();
         self.registry.connectors.insert(component_id, ConnectorDesc::new(component_id, component_state, ports));
         self.connectors_active.push_back(component_id);
         Ok(())
+    }
     pub fn run(&mut self) {
         // Go through all active connectors
         while !self.connectors_active.is_empty() {
             let next_id = self.connectors_active.pop_front().unwrap();
             self.run_connector(next_id);
+        }
+    }
     /// Runs a connector for as long as sensible, then returns `true` if the
     /// connector should be run again in the future, and return `false` if the
     /// connector has terminated. Note that a terminated connector still
     /// requires cleanup.
     pub fn run_connector(&mut self, id: u32) -> bool {
         let desc = self.registry.connectors.get_mut(&id).unwrap();
         let mut run_context = Context{
             connector_id: id,
             branch_id: None,
             pending_channel: None,
         };
         let mut call_again = false;
         while call_again {
             call_again = false; // bit of a silly pattern, maybe revise
             if desc.in_sync {
                 // Running in synchronous mode, so run all branches until their
                 // blocking point
                 debug_assert!(!desc.spec_branches_active.is_empty());
                 let branch_index = desc.spec_branches_active.pop_front().unwrap();
                 let branch = &mut desc.branches[branch_index as usize];
                 let run_result = branch.code_state.run(&mut run_context, &self.protocol);
                 match run_result {
                     RunResult::BranchInconsistent => {
                         // Speculative branch became inconsistent. So we don't
                         // run it again
                         branch.branch_state = BranchState::Failed;
                     },
                     RunResult::BranchMissingPortState(port_id) => {
                         // Branch called `fires()` on a port that did not have a
                         // value assigned yet. So branch and keep running
                         debug_assert!(branch.owned_ports.contains(&port_id.0.u32_suffix));
                         debug_assert!(branch.port_mapping.get(&port_id).is_none());
                         let copied_index = Self::duplicate_branch(desc, branch_index);
                         // Need to re-borrow to assign changed port state
                         let original_branch = &mut desc.branches[branch_index as usize];
                         original_branch.port_mapping.insert(port_id, BranchPortDesc{
                             last_registered_identifier: None,
                             num_times_fired: 0,
                         });
                         let copied_branch = &mut desc.branches[copied_index as usize];
                         copied_branch.port_mapping.insert(port_id, BranchPortDesc{
                             last_registered_identifier: None,
                             num_times_fired: 1,
                         });
                         // Run both again
                         desc.spec_branches_active.push_back(branch_index);
                         desc.spec_branches_active.push_back(copied_index);
                     },
                     RunResult::BranchMissingPortValue(port_id) => {
                         // Branch just performed a `get()` on a port that did
                         // not yet receive a value.
                         // First check if a port value is assigned to the
                         // current branch. If so, check if it is consistent.
                         debug_assert!(branch.owned_ports.contains(&port_id.0.u32_suffix));
                         match branch.port_mapping.entry(port_id) {
                             Entry::Vacant(entry) => {
                                 // No entry yet, so force to firing
                                 entry.insert(BranchPortDesc{
                                     last_registered_identifier: None,
                                     num_times_fired: 1,
                                 });
                                 branch.branch_state = BranchState::BranchPoint;
                                 desc.spec_branches_pending_receive.insert(port_id, branch_index);
                             },
                             Entry::Occupied(entry) => {
                                 // Have an entry, check if it is consistent
                                 let entry = entry.get();
                                 if entry.num_times_fired == 0 {
                                     // Inconsistent
                                     branch.branch_state = BranchState::Failed;
                                 } else {
                                     // Perfectly fine, add to queue
                                     branch.branch_state = BranchState::BranchPoint;
                                     desc.spec_branches_pending_receive.insert(port_id, branch_index);
+                                }
+                            }
+                        }
                     },
                     RunResult::BranchAtSyncEnd => {
                         branch.branch_state = BranchState::ReachedEndSync;
                         todo!("somehow propose solution");
                     },
                     RunResult::BranchPut(port_id, value_group) => {
                         debug_assert!(branch.owned_ports.contains(&port_id.0.u32_suffix));
                         debug_assert_eq!(value_group.values.len(), 1)
                     },
                     _ => unreachable!("got result '{:?}' from running component in sync mode", run_result),
+                }
             } else {
                 // Running in non-synchronous mode
                 let branch = &mut desc.branches[0];
                 let run_result = branch.code_state.run(&mut run_context, &self.protocol);
                 match run_result {
                     RunResult::ComponentTerminated => return false,
                     RunResult::ComponentAtSyncStart => {
                         // Prepare for sync execution
                         Self::prepare_branch_for_sync(desc);
                         call_again = true;
                     },
                     RunResult::NewComponent(definition_id, monomorph_idx, arguments) => {
                         // Generate a new connector with its own state
                         let new_component_id = self.generate_connector_id();
                         let new_component_state = ComponentState {
                             prompt: Prompt::new(&self.protocol.types, &self.protocol.heap, definition_id, monomorph_idx, arguments)
                         };
                         // Transfer the ownership of any ports to the new connector
                         let mut ports = Vec::with_capacity(arguments.values.len());
                         find_ports_in_value_group(&arguments, &mut ports);
                         for port_id in &ports {
                             let port = self.registry.ports.get_mut(&port_id.0.u32_suffix).unwrap();
                             debug_assert_eq!(port.owning_connector_id.unwrap(), run_context.connector_id);
                             port.owning_connector_id = Some(new_component_id)
+                        }
                         // Finally push the new connector into the registry
                         let ports = ports.into_iter().map(|v| v.0.u32_suffix).collect();
                         self.registry.connectors.insert(new_component_id, ConnectorDesc::new(new_component_id, new_component_state, ports));
                         self.connectors_active.push_back(new_component_id);
                     },
                     RunResult::NewChannel => {
                         // Prepare channel
                         debug_assert!(run_context.pending_channel.is_none());
                         let (put_id, get_id) = self.registry.add_channel(Some(run_context.connector_id));
                         run_context.pending_channel = Some((
                             port_value_from_id(Some(run_context.connector_id), put_id, true),
                             port_value_from_id(Some(run_context.connector_id), get_id, false)
                         ));
                         // Call again so it is retrieved from the context
                         call_again = true;
                     },
                     _ => unreachable!("got result '{:?}' from running component in non-sync mode", run_result),
+                }
+            }
+        }
         return true;
+    }
     fn generate_connector_id(&mut self) -> u32 {
         let id = self.registry.connector_counter;
         self.registry.connector_counter += 1;
         return id;
+    }
     // -------------------------------------------------------------------------
     // Helpers for branch management
     // -------------------------------------------------------------------------
     /// Prepares a speculative branch for further execution from the connector's
     /// non-speculative base branch.
     fn prepare_branch_for_sync(desc: &mut ConnectorDesc) {
         // Ensure only one branch is active, the non-sync branch
         debug_assert!(!desc.in_sync);
         debug_assert_eq!(desc.branches.len(), 1);
         debug_assert!(desc.spec_branches_active.is_empty());
         let new_branch_index = 1;
         let new_branch_identifier = desc.branch_id_counter;
         desc.branch_id_counter += 1;
         // Push first speculative branch as active branch
         let new_branch = BranchDesc::new_sync_from(new_branch_index, new_branch_identifier, &desc.branches[0]);
         desc.branches.push(new_branch);
         desc.spec_branches_active.push_back(new_id);
         desc.in_sync = true;
+    }
     /// Duplicates a particular (speculative) branch and returns its index.
     fn duplicate_branch(desc: &mut ConnectorDesc, original_branch_idx: u32) -> u32 {
         let original_branch = &desc.branches[original_branch_idx as usize];
         debug_assert!(desc.in_sync);
         let copied_index = desc.branches.len() as u32;
         let copied_id = desc.branch_id_counter;
         desc.branch_id_counter += 1;
         let copied_branch = BranchDesc::new_sync_from(copied_index, copied_id, original_branch);
         desc.branches.push(copied_branch);
         return copied_index;
+    }
+}
 /// Context accessible by the code while being executed by the runtime. When the
 /// code is being executed by the runtime it sometimes needs to interact with
 /// the runtime. This is achieved by the "code throwing an error code", after
 /// which the runtime modifies the appropriate variables and continues executing
 /// the code again.
 struct Context<'a> {
     // Properties of currently running connector/branch
     connector_id: u32,
     branch_id: Option<u32>,
     // Resources ready to be retrieved by running code
     pending_channel: Option<(Value, Value)>, // (put, get) ports
+}
 impl<'a> crate::protocol::RunContext for Context<'a> {
     fn did_put(&self, port: PortId) -> bool {
         todo!()
+    }
     fn get(&self, port: PortId) -> Option<Value> {
         todo!()
+    }
     fn fires(&self, port: PortId) -> Option<Value> {
         todo!()
+    }
     fn get_channel(&mut self) -> Option<(Value, Value)> {
         self.pending_channel.take()
+    }
+}
 /// Recursively goes through the value group, attempting to find ports.
 /// Duplicates will only be added once.
 fn find_ports_in_value_group(value_group: &ValueGroup, ports: &mut Vec<PortId>) {
     // Helper to check a value for a port and recurse if needed.
     fn find_port_in_value(group: &ValueGroup, value: &Value, ports: &mut Vec<PortId>) {
         match value {
             Value::Input(port_id) | Value::Output(port_id) => {
                 // This is an actual port
                 for prev_port in ports {
                     if prev_port == port_id {
                         // Already added
                         return;
+                    }
+                }
                 ports.push(*port_id);
             },
             Value::Array(heap_pos) |
             Value::Message(heap_pos) |
             Value::String(heap_pos) |
             Value::Struct(heap_pos) |
             Value::Union(_, heap_pos) => {
                 // Reference to some dynamic thing which might contain ports,
                 // so recurse
                 let heap_region = &group.regions[*heap_pos as usize];
                 for embedded_value in heap_region {
                     find_port_in_value(group, embedded_value, ports);
+                }
             },
             _ => {}, // values we don't care about
+        }
+    }
     // Clear the ports, then scan all the available values
     ports.clear();
     for value in &value_group.values {
         find_port_in_value(value_group, value, ports);
+    }
+}
 fn port_value_from_id(connector_id: Option<u32>, port_id: u32, is_output: bool) -> Value {
     let connector_id = connector_id.unwrap_or(u32::MAX); // TODO: @hack, review entire PortId/ConnectorId/Id system
     if is_output {
         return Value::Output(PortId(Id{
             connector_id,
             u32_suffix: port_id
         }));
     } else {
         return Value::Input(PortId(Id{
             connector_id,
             u32_suffix: port_id,
         }));
+    }
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)