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

Changeset - 9206016be13b

Parent rev.

Child rev.

[Not reviewed]

Merge

0 31 2

Max Henger - 3 years ago 2022-05-15 16:45:34
henger@cwi.nl

Merge branch 'feat-tcp-listener' into 'master'

feat: tcp listener

See merge request nl-cwi-csy/reowolf!9

33 files changed with 1419 insertions and 308 deletions:

docs/runtime/consensus.md

213

docs/runtime/known_issues.md

src/protocol/ast.rs

src/protocol/eval/executor.rs

src/protocol/mod.rs

src/protocol/parser/pass_definitions.rs

src/protocol/parser/pass_symbols.rs

src/protocol/parser/pass_tokenizer.rs

src/protocol/parser/pass_validation_linking.rs

src/protocol/parser/token_parsing.rs

src/protocol/parser/type_table.rs

src/protocol/tests/parser_validation.rs

src/runtime/tests/api_component.rs

src/runtime/tests/data_transmission.rs

src/runtime/tests/network_shapes.rs

src/runtime/tests/speculation.rs

src/runtime/tests/sync_failure.rs

src/runtime2/component/component.rs

154

src/runtime2/component/component_internet.rs

482

src/runtime2/component/consensus.rs

src/runtime2/poll/mod.rs

src/runtime2/stdlib/internet.rs

src/runtime2/tests/error_handling.rs

src/runtime2/tests/internet.rs

196

src/runtime2/tests/messaging.rs

src/runtime2/tests/mod.rs

src/runtime2/tests/transfer_ports.rs

std/std.internet.pdl

std/std.random.pdl

testdata/basic-modules/consumer.pdl

testdata/basic-modules/main.pdl

testdata/basic-modules/producer.pdl

testdata/basic/testing.pdl

0 comments (0 inline, 0 general)

docs/runtime/consensus.md

➞

Show inline comments

 # Consensus Algorithm
 ## Introduction.
 An essential concept within the Reowolf language is the `sync` block. Behaviours that are specified within such a block (as imperative code, containing the instructions to send or receive information, and conditions on the values in memory) must agree with all other parties that participate in the interaction. An additional concept within such a `sync` block is speculative execution. Code that uses this execution temporarily forks and is allowed to perform multiple behaviours at the same time. At the end of the `sync` block only one particular execution (i.e. local behaviour) is allowed to complete. This results in additional complexity in finding satisfactory global behaviour.
 This document attempts to explain the chosen implementation of the initial consensus protocol. At some point one should be able to write consensus protocols associated with `sync` blocks within PDL. As initial experimentation (mainly to see which information should be available to a programmer using PDL) the consensus protocol will be written in the language in which the runtime is written.
 The Reowolf 1.2 consensus protocol aims to fix several issues that were present in the Reowolf 1.0 consensus protocol, among which:
 - The newer protocol should not synchronize among all known connectors on a machine. Rather, it should only aim to achieve consensus among the connectors that are actually communicating to one-another in the same interaction. Any connector that does not send or receive messages to this "synchronous region" does not belong to that synchronous region.
 - The newer protocol should aim to be leaderless. The old protocol featured a leader per interaction. Both the leader election itself and the subsequent picking of the global behaviour caused a large message overhead. Additionally the leader is tasked with a large computational overhead. Especially in the context of relatively large synchronous regions where some participants are running code on low-powered devices this is troublesome.
 - With regards to performance, the new consensus protocol should aim to reduce the message complexity and amount of transmitted bytes as much as possible. Additionally computational complexity should be reduced by attempting to perform a reduction in the number of valid local connector behaviours, thereby reducing the search space of the global connector behaviour.
 In the following discussion, there is a lot of room for optimization. But we'll describe the general algorithm first, and the specific optimizations in a different document in the future.
 ## Data Structures
 ### Speculative Execution
 First we create a data structure for the speculative execution itself. Speculative execution is tracked in memory as an execution tree. At the root we find the very first bit of code that is executed without any speculative execution. Each node contains the executed code associated with a particular branch. The edges in this tree might imply speculative execution (if there is more than one edge leaving a particular node), or might simply imply a "dependency" (explained later) if there is only one edge.
 At the leaves of the tree we find successful executions, where the very last instruction is the "end of the sync block" instruction. Reaching such a leaf implies that we found a local behaviour that satisfies the local constraints placed upon the behaviour. If we trace the path from the root to the particular leaf then we find the execution path. If one imagines that all of the code in all of the nodes in the execution path are concatenated, then one finds all executed instructions in order of execution.
 Each time a connector reaches a sync block, it will associate a number with that sync block. We'll call this the `round ID`. Each executed sync block will have a unique `round ID` (up to some reasonable limit in case of integer overflow). Likewise each of the nodes in the execution tree will have a unique number called the `branch ID`. The branch ID is unique among all branches in the execution tree, but numbers may be reused in different `round ID`s.
 ### Tracking Dependencies
 One of the implications of being able to send messages and perform speculative execution is that branches will also be created upon receiving messages. One may imagine connectors `S` and `R`. `R` simply has the behaviour of receiving a message and handing it off to some native application. But `S` branches and sends, in each branch, a message over the same port. This implies that `R` will also end up with two branches: one per received message. In order to track dependencies between these two parties it is sufficient to annotate each message with its sender's branch number. Afterwards we can pick the branch numbers that are consistent between the two parties.
 When more than two parties are communicating, the behaviour becomes more complicated. A series of connectors `A`, `B`, `C`, etc. may have behaviours that depend on one-another in convoluted fashion. A particular valid execution trace in `A` may have send message to multiple different connectors `B`, `C` and `D`, influencing their speculative behaviour. In turn `B`, `C` and `D` may have done some branching on their own, and each of them sends messages to a final connector `E`. We now have that the branches in `B`, `C` and `D` depend on `A`, and `E` depending on the former three. A consensus protocol needs to be able to reason about these dependencies and, when a solution is possible, pick a single execution path in each of the connectors.
 In order to achieve this, we'll simplify the subsequent discussion for now by assuming that there is some later algorithm that will kick in once a connector has found a local solution. This algorithm will somehow seek among all connectors if they agree with a particular solution. For now we'll just consider the necessary information that needs to be provided to this algorithm in order for it to find a solution.
+\
+\
+\
 To start the train of thought, suppose that each connector that sends a message will append its execution path's branch numbers, and any of the branch numbers it has received through messages. This implies that each branch in the execution tree is associated with a mapping from `connector ID` to a set of branch numbers. If a connector receives a message then it can deposit the message in a branch if the received message's mapping contains `connector ID`s that map to a branch number set that is a superset of branch numbers in the branch's mapping itself. There are no restrictions on the set of `connector ID`s itself. Only on the branch number sets that are associated with the intersection of the `connector ID` sets.
 The upside of this scheme is that each connector has a complete view of the dependencies that exist within the synchonous region that resulted in the branch. The downside is that the amount of data quickly balloons. Each branch that encountered a `get` call needs to wait for more messages, and needs to keep the complete branch number mapping around.
 The subsequent algorithm, the one that makes sure that everyone agrees to a particular solution, then results in sending around this mapping, each connector adding its own compatible branch number mapping to it (or, if there is no compatible mapping, deleting the solution). If this messages reaches all connectors, and all connectors agree to the chosen mapping, then we have found a solution.
+\
+\
+\
 A different approach would be to take a different look at the global behaviour centered around the channels themselves. Two connectors can only have a dependency on one another if they communicate through a channel. Furthermore, suppose connector `A` sends to `B` and `B` sends to `C`. In the scheme described above `C` would know about its dependency on `A`. However, this is redundant information. If `C` knows about its dependency on `B`, and `B` knows about its dependency on `A`, then globally we have a full view on the dependencies as well. If `A` sends to `C` as well, then `C` does not know about the interdependency between the message traversing `A -> B -> C` and the message traversing `A -> C`. But again: if we take a global view and join the branch number mapping of `A`, `B` and `C`, then we're able to determine the global behaviour.
 So instead of sending all branch number information received. We can append only the sending connector's branch numbers along with a message. A receiving connector will now associate these branch numbers with the port through which the message was received. Hence a connector's branch will have a branch number, but also a mapping from `port ID` to the branch number set of the sending party.
 If we send around a solution to all connectors (again, the procedure for which will be detailed later) they can be reconciled in the following manner. The connectors sharing a port will always have the "putter" choosing the port number mapping. And the "putter" may have advanced its execution and increased the number of elements in the branch number set. So if the "putter" receives a solution, then it needs to check if the port's branch number set is a subset of its own branch number set. If a "getter" receives a solution then it needs to check if the port's branch number set is a superset of its own branch number set.
 Taking a step back: if a global solution exists, then it is composed out of the local solutions per connector, of which there is at least one per connector. The fact that all connectors are part of the same synchronous region implies that each channel will have seen at least one interaction between the connector(s) that own the ports. Hence each channel will have had one set of branch IDs mapped to it. Hence if we were to take the branch ID sets associated with each channel, then we're able to find the global solution.
@@ \ No newline at end of file @@
 # Previous Consensus Algorithm
 ## Introduction
 The previous consensus algorithm (the one within Reowolf 1.0 and 1.1) had support for speculative execution. This means that the user may (directly or indirectly) fork the execution of a component. That particular execution then becomes two executions. At some point a component will have to choose which particular execution will be committed to memory. This is one reason for the existence of a `sync` block: a block of code wherein one may perform forking, and at the end a component will have to choose the execution that is committed to memory.
 With speculative execution we may have multiple components that are all forking their execution and sending/receiving messages. So we do not end up with one component that has to choose its final execution, but all components choosing their final execution. Note that one component's execution may apply restrictions on the validity of another component's execution. As an example, suppose the following components and their executions:
 - Component A: Has two executions:
     - Execution A1: Component A has sent a message to component B.
     - Execution A2: Component A has received a message from component B.
 - Component B: Has three executions:
     - Execution B1: Component B has received a message from component A, then sends a message back to component A.
     - Execution B2: Component B has received a message from component A.
     - Execution B3: Component B has sent two messages to component A.
 Without delving into too much detail, one may see that the only valid solution to this problem is the combination of `A1` and `B2`.
 ## Component Execution Tree, and Execution Traces
 Components execute PDL code, which may contain calls to `fork`, `put`, and `get`. A `fork` explicitly forks the execution of the code. A `put` sends a message to a particular component, and a `get` receives a message from a component and forks (as explained later).
 As the component enters a `sync` block, it has only one possible execution. But as stated above there are reasons for the execution to split up. These individual executions may themselves split up later, thereby forming a so-called "execution tree":
 ```
                              +-----+       +------+
                              | put |------>| sync |
 +-------+      +------+----->+-----+       | end  |
 | sync  |      | fork |                    +------+
 | start |----->+------+----->+-----+
 +-------+                    | get |------>+------+
                              +-----+       | sync |
                                    |       | end  |
                                    |       +------+
+                                   |
                                    +------>+------+
                                    |       | sync |
                                    |       | end  |
                                    |       +------+
+                                   |
                                    +--> ...
 ```
 This corresponds to the following PDL code:
 ```
 primitive some_component(out<u32> tx, in<u32> rx) {
   sync {
     fork {
       put(tx, 5);
     } or fork {
       get(rx, 1);
+    }
+}
 ```
 We can see the reason for calling the execution tree a "tree". There are several things to note about the execution tree: Firstly that some executions have been completed and form a complete trace, that is: starting from the "sync start" a complete trace may be represented by the line running to the "sync end". Conversely, there is one trace that is incomplete: there is a trace waiting at the `get` for a message. We'll call a place where the execution splits into multiple branches/executions a "branching point".
 Note that the branching points can in the *general case* only be discovered at runtime. Any code may have control flow points like `if` statements, or `while` loops. Consider the following code:
 ```
 primitive some_component(out<u32> tx, bool which_way) {
   sync {
     if (which_way) {
       fork {
         put(tx, 1);
       } or fork {
         put(tx, 2);
+      }
     } else {
       put(tx, 3);
+    }
+  }
+}
 ```
 Depending on the value of `which_way` we produce two different execution trees (of which we can determine all traces). The compiler cannot decide at compile time which execution tree will be generated.
 Note that the `get` branching points have an arbitrary number of forked executions arising from them. We'll call them "waiting points". In the *general case* we cannot figure out how many forked executions arise from a `get` branching point. The reason being might be illustrated by the following simple example:
 ```
 primitive sender(out<u32> tx, u32 num_forks) {
   sync {
     auto fork_counter = 1;
     while (fork_counter < num_forks) {
       fork {
         put(tx, fork_counter);
       } or fork { } // empty case
+    }
     put(tx, num_forks);
+  }
+}
 primitive receiver(in<u32> rx) {
   u32[] values = {};
   sync {
     bool keep_going = true;
     while (keep_going) {
       auto new_value = get(rx);
       values @= { new_value }; // append
       fork {
         keep_going = false;
       } or fork { }
+    }
+  }
+}
 ```
 If the sender is connected to the receiver, then the sender will send anywhere between `1` and `num_forks` messages (distributed over `num_forks` forks), depending on a user-supplied parameter (which we cannot figure out at compile-time). The isolated receiver can generate an infinite number of forked executions. We can analyze that the receiver will at most have `num_forks + 1` forked executions arising from its `get` branching point (the `num_forks` branches that do receive, and one final fork that is infinitely waiting on another message), but the compiler cannot.
 For this reason a `get` branching point needs to be kept around for the entire duration of the sync block. The runtime will always need to have a copy of the component's memory and execution state the moment it encountered a `get` instruction, because it might just be that another component (in perhaps a new fork, which we cannot predict) will send it another message, such that it needs to produce a new forked execution.
 A `get` operation is also a "blocking operation": in the *general case* the component needs to know the value produced by the `get` operation in order to continue its execution (perhaps more specifically: the first time a `read` operation is performed on the variable that will store the transmitted message). Consider the simple case where the received message contains a boolean that is used in the test expression of an `if` statement: we'll need to have actually received that boolean before we can decide which control flow path to take. Speculating on the contents of messages is too computationally expensive to be taken seriously. A put operation is not a blocking operation: the message is sent and the component continues executing its code.
 We've touched upon control flow points multiple times. We'll touch upon some aspects of control flow here, to more easily introduce the algorithm for finding consensus later. A component is fully described by its memory (i.e. all of the memory locations it has access to through its variables) and execution state (i.e. its current position in its code). So once a component encounters a control flow point, it can only take one control flow path. The calling of certain impure functions (e.g. retrieving a cryptographically secure random number) does not change this fact. Note that receiving values from other components might change a component's memory state, hence influence the control flow path it takes in the subsequent forked execution. Conversely, a component sending a value might influence another component's memory state.
 So before treading into more detail, here we've found that in the general case:
 - A interior of a sync block demarks the place where speculative execution may occur.
 - Speculative execution implies that we end up with an execution tree.
 - A path through the execution tree that reaches the end of the sync block is called a trace, and represents a valid execution of the sync block for the component (but perhaps not for a peer it interacted with).
 - The set of traces produced by a component in its sync block can practically only be discovered at runtime.
 - A `get` operation is necessarily a blocking operation that always incurs a branching point. A `put` operation is a nonblocking operation that does not incur a branching point.
 - The trace of a component is influenced by the messages it has received.
 ## Towards a Consensus Algorithm
 The solution to the consensus problem is somehow discovering the ways in which the components have influenced the memory state of their peers. If we have a complete trace for each component, for which all peer components agree on the way they have influenced that complete trace, then we've found a solution to the consensus problem. Hence we can subdivide the consensus problem into four parts:
 . Keeping track of the messages that influence the memory state of components.
 . Keeping track of the peers that influence the memory state of components.
 . Finding a set of interactions between components on which all involved components agree, i.e. each `put` should have a corresponding `get` at the peer.
 . Somehow having a communication protocol that finds these agreeable interactions.
 We'll incrementally work towards a solution that satisfies the first three points. We'll not consider the last point, as this is essentially a gossip protocol. We define some terms to make the following discussion easier:
 - "sync region": The group of components that have interacted with one another and should agree on the global consensus solutionj.
 - "local solution": A complete trace of a component. For the component this is a valid local solution, but might not be part of a global solution.
 - "global solution": A set of traces, one for each of the components in the sync region, that all agree on the interactions that took place between the components in the sync region.
 Suppose a component can somehow predict exactly which messages we're going to receive during the execution of its code, we'll assume that each received message has the appropriate `get` call associated with it. In this case we're able to produce the set of complete traces that a component produces by symbolically executing its code: we start out with the initial memory state, might perhaps do some explicit `fork`ing, know exactly which messages we receive and how they influence the control flow, and arrive at the end of the sync block.
 However, as we've outlined above, we cannot know exactly which messages we're going to receive. We'll have to discover these messages while executing a component. The next best thing is to keep track of the values of the messages that we've received in a complete trace. Once we have complete traces for all of the interacting components, we can check that the received value corresponds to a sent value. e.g.
 ```
 primitive sender(out<u32> tx) {
   sync {
     fork {
       put(tx, 1);
     } or fork {
       put(tx, 2);
+    }
+  }
+}
 primitive receiver(in<u32> rx) {
   u32 value = 0;
   sync {
     value = get(rx);
+  }
+}
 ```
 Where `tx` is part of the same channel as `rx`. In this case we'll have two traces for each of the components, resulting in two valid global consensus solutions. In one solution the message `1` was transferred, in another the message `2` was transferred. There are two problems with this solution: firstly it doesn't take the identity of the channel into account. And secondly it doesn't take the effects of previous messages into account.
 To illustrate the first problem, consider:
 ```
 primitive sender(out<u32> tx_a, out<u32> tx_b) {
   sync {
     fork {
       put(tx_a, 1);
     } or fork {
       put(tx_b, 1);
+    }
+  }
+}
 primitive receiver(in<u32> rx_a, in<u32> rx_b) {
   u32 value = 0;
   sync {
     value = get(rx_a);
+  }
+}
 ```
 Here the fact that the sender has the solutions `1` and `1` does not help the receiver figure out which of those corresponds to its own solution of `1`.
 To illustrate the second problem, consider:
 ```
 primitive sender(out<u32> tx) {
   sync {
     fork {
       put(tx, 1);
       put(tx, 2);
     } or fork {
       put(tx, 2);
+    }
+  }
+}
 primitive receiver(in<u32> rx) {
   u32 value = 0;
   sync {
     value = get(rx);
+  }
+}
 ```
 Now we'll have `sender` contributing the solutions `1, 2` and `2`. While the receiver will generate the solutions `1`, `2` and `2`. The reason there are three solutions for the receiver is because it cannot figure out that the message `2` from the sender depended on the first message `1` from the sender having arrived.
 We can solve this by somehow embedding the identity of the channel associated with the message, and by describing all of the previous interactions
@@ \ No newline at end of file @@

docs/runtime/known_issues.md

➞

Show inline comments

@@ new file 100644 @@
 # Known Issues
 The current implementation of Reowolf has the following known issues:
 - Cannot create uninitialized variables that are later known to be initialized. This is not a problem for the regular types (perhaps a bit tedious), but is a problem for channels/ports. That is to say: if a component needs a temporary variable for a port, then it must create a complete channel. e.g.
   ```
   comp send(out<u32> tx1, out<u32> tx2, in<bool> which) {
     channel unused -> temporary;
     while (true) sync {
       if (get(which)) {
         temporary = tx1;
       } else {
         temporary = tx2;
+      }
       put(temporary, 1);
+    }
+  }
   ```
 - Reserved memory for ports will grow without bounds: Ports can be given away from one component to another by creating a component, or by sending a message containing them. The component sending those ports cannot remove them from its own memory if there are still other references to the transferred port in its memory. This is because we want to throw a reasonable error if that transferred port is used by the original owner. Hence we need to keep some information about that transferred port in the sending component's memory. The solution is to have reference counting for the ports, but this is not implemented.
 - An extra to the above statements: when transferring ports to a new component, the memory that remembers the state of that port is removed from the component that is creating the new one. Hence using old references to that port within the creating component's PDL code results in a crash.
 - Some control algorithms are not robust under multithreading. Mainly error handling when in sync mode (because there needs to be a revision where we keep track of which components are still reachable by another component). And complicated scenarios where ports are transferred.
@@ \ No newline at end of file @@

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -628,1363 +628,1363 @@ impl ConcreteType { @@
             CTP::String => { target.push_str(KW_TYPE_STRING_STR); },
             CTP::Array | CTP::Slice => {
                 idx = Self::render_type_part_at(parts, heap, idx, target);
                 target.push_str("[]");
             },
             CTP::Input => {
                 target.push_str(KW_TYPE_IN_PORT_STR);
                 target.push('<');
                 idx = Self::render_type_part_at(parts, heap, idx, target);
                 target.push('>');
             },
             CTP::Output => {
                 target.push_str(KW_TYPE_OUT_PORT_STR);
                 target.push('<');
                 idx = Self::render_type_part_at(parts, heap, idx, target);
                 target.push('>');
             },
             CTP::Pointer => {
                 target.push('*');
                 idx = Self::render_type_part_at(parts, heap, idx, target);
+            }
             CTP::Tuple(num_parts) => {
                 target.push('(');
                 if num_parts != 0 {
                     idx = Self::render_type_part_at(parts, heap, idx, target);
                     for _ in 1..num_parts {
                         target.push(',');
                         idx = Self::render_type_part_at(parts, heap, idx, target);
+                    }
+                }
                 target.push(')');
             },
             CTP::Instance(definition_id, num_poly_args) => {
                 idx = Self::render_definition_type_parts_at(parts, heap, definition_id, num_poly_args, idx, target);
+            }
             CTP::Function(definition_id, num_poly_args) |
             CTP::Component(definition_id, num_poly_args) => {
                 idx = Self::render_definition_type_parts_at(parts, heap, definition_id.upcast(), num_poly_args, idx, target);
+            }
+        }
         idx
+    }
     fn render_definition_type_parts_at(parts: &[ConcreteTypePart], heap: &Heap, definition_id: DefinitionId, num_poly_args: u32, mut idx: usize, target: &mut String) -> usize {
         let definition = &heap[definition_id];
         target.push_str(definition.identifier().value.as_str());
         if num_poly_args != 0 {
             target.push('<');
             for poly_arg_idx in 0..num_poly_args {
                 if poly_arg_idx != 0 {
                     target.push(',');
+                }
                 idx = Self::render_type_part_at(parts, heap, idx, target);
+            }
             target.push('>');
+        }
         return idx;
+    }
+}
 #[derive(Debug)]
 pub struct ConcreteTypeIter<'a> {
     parts: &'a [ConcreteTypePart],
     idx_embedded: u32,
     num_embedded: u32,
     part_idx: usize,
+}
 impl<'a> ConcreteTypeIter<'a> {
     pub(crate) fn new(parts: &'a[ConcreteTypePart], parent_idx: usize) -> Self {
         let num_embedded = parts[parent_idx].num_embedded();
         return ConcreteTypeIter{
             parts,
             idx_embedded: 0,
             num_embedded,
             part_idx: parent_idx + 1,
+        }
+    }
+}
 impl<'a> Iterator for ConcreteTypeIter<'a> {
     type Item = &'a [ConcreteTypePart];
     fn next(&mut self) -> Option<Self::Item> {
         if self.idx_embedded == self.num_embedded {
             return None;
+        }
         // Retrieve the subtree of interest
         let start_idx = self.part_idx;
         let end_idx = ConcreteType::type_parts_subtree_end_idx(&self.parts, start_idx);
         self.idx_embedded += 1;
         self.part_idx = end_idx;
         return Some(&self.parts[start_idx..end_idx]);
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum ScopeAssociation {
     Definition(DefinitionId),
     Block(BlockStatementId),
     If(IfStatementId, bool), // if true, then body of "if", otherwise body of "else"
     While(WhileStatementId),
     Synchronous(SynchronousStatementId),
     SelectCase(SelectStatementId, u32), // index is select case
+}
 /// `ScopeNode` is a helper that links scopes in two directions. It doesn't
 /// actually contain any information associated with the scope, this may be
 /// found on the AST elements that `Scope` points to.
 #[derive(Debug, Clone)]
 pub struct Scope {
     // Relation to other scopes
     pub this: ScopeId,
     pub parent: Option<ScopeId>,
     pub nested: Vec<ScopeId>,
     // Locally available variables/labels
     pub association: ScopeAssociation,
     pub variables: Vec<VariableId>,
     pub labels: Vec<LabeledStatementId>,
     // Location trackers/counters
     pub relative_pos_in_parent: i32,
     pub first_unique_id_in_scope: i32,
     pub next_unique_id_in_scope: i32,
+}
 impl Scope {
     pub(crate) fn new(id: ScopeId, association: ScopeAssociation) -> Self {
         return Self{
             this: id,
             parent: None,
             nested: Vec::new(),
             association,
             variables: Vec::new(),
             labels: Vec::new(),
             relative_pos_in_parent: -1,
             first_unique_id_in_scope: -1,
             next_unique_id_in_scope: -1,
+        }
+    }
+}
 impl Scope {
     pub(crate) fn new_invalid(this: ScopeId) -> Self {
         return Self{
             this,
             parent: None,
             nested: Vec::new(),
             association: ScopeAssociation::Definition(DefinitionId::new_invalid()),
             variables: Vec::new(),
             labels: Vec::new(),
             relative_pos_in_parent: -1,
             first_unique_id_in_scope: -1,
             next_unique_id_in_scope: -1,
         };
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum VariableKind {
     Parameter,      // in parameter list of function/component
     Local,          // declared in function/component body
     Binding,        // may be bound to in a binding expression (determined in validator/linker)
+}
 #[derive(Debug, Clone)]
 pub struct Variable {
     pub this: VariableId,
     // Parsing
     pub kind: VariableKind,
     pub parser_type: ParserType,
     pub identifier: Identifier,
     // Validator/linker
     pub relative_pos_in_parent: i32,
     pub unique_id_in_scope: i32, // Temporary fix until proper bytecode/asm is generated
+}
 #[derive(Debug)]
 pub enum Definition {
     Struct(StructDefinition),
     Enum(EnumDefinition),
     Union(UnionDefinition),
     Procedure(ProcedureDefinition),
+}
 impl Definition {
     pub fn is_struct(&self) -> bool {
         match self {
             Definition::Struct(_) => true,
             _ => false
+        }
+    }
     pub(crate) fn as_struct(&self) -> &StructDefinition {
         match self {
             Definition::Struct(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'StructDefinition'"),
+        }
+    }
     pub(crate) fn as_struct_mut(&mut self) -> &mut StructDefinition {
         match self {
             Definition::Struct(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'StructDefinition'"),
+        }
+    }
     pub fn is_enum(&self) -> bool {
         match self {
             Definition::Enum(_) => true,
             _ => false,
+        }
+    }
     pub(crate) fn as_enum(&self) -> &EnumDefinition {
         match self {
             Definition::Enum(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'EnumDefinition'"),
+        }
+    }
     pub(crate) fn as_enum_mut(&mut self) -> &mut EnumDefinition {
         match self {
             Definition::Enum(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'EnumDefinition'"),
+        }
+    }
     pub fn is_union(&self) -> bool {
         match self {
             Definition::Union(_) => true,
             _ => false,
+        }
+    }
     pub(crate) fn as_union(&self) -> &UnionDefinition {
         match self {
             Definition::Union(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'UnionDefinition'"),
+        }
+    }
     pub(crate) fn as_union_mut(&mut self) -> &mut UnionDefinition {
         match self {
             Definition::Union(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'UnionDefinition'"),
+        }
+    }
     pub fn is_procedure(&self) -> bool {
         match self {
             Definition::Procedure(_) => true,
             _ => false,
+        }
+    }
     pub(crate) fn as_procedure(&self) -> &ProcedureDefinition {
         match self {
             Definition::Procedure(result) => result,
             _ => panic!("Unable to cast `Definition` to `Function`"),
+        }
+    }
     pub(crate) fn as_procedure_mut(&mut self) -> &mut ProcedureDefinition {
         match self {
             Definition::Procedure(result) => result,
             _ => panic!("Unable to cast `Definition` to `Function`"),
+        }
+    }
     pub fn defined_in(&self) -> RootId {
         match self {
             Definition::Struct(def) => def.defined_in,
             Definition::Enum(def) => def.defined_in,
             Definition::Union(def) => def.defined_in,
             Definition::Procedure(def) => def.defined_in,
+        }
+    }
     pub fn identifier(&self) -> &Identifier {
         match self {
             Definition::Struct(def) => &def.identifier,
             Definition::Enum(def) => &def.identifier,
             Definition::Union(def) => &def.identifier,
             Definition::Procedure(def) => &def.identifier,
+        }
+    }
     pub fn poly_vars(&self) -> &Vec<Identifier> {
         match self {
             Definition::Struct(def) => &def.poly_vars,
             Definition::Enum(def) => &def.poly_vars,
             Definition::Union(def) => &def.poly_vars,
             Definition::Procedure(def) => &def.poly_vars,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct StructFieldDefinition {
     pub span: InputSpan,
     pub field: Identifier,
     pub parser_type: ParserType,
+}
 #[derive(Debug, Clone)]
 pub struct StructDefinition {
     pub this: StructDefinitionId,
     pub defined_in: RootId,
     // Symbol scanning
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Parsing
     pub fields: Vec<StructFieldDefinition>
+}
 impl StructDefinition {
     pub(crate) fn new_empty(
         this: StructDefinitionId, defined_in: RootId,
         identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self{ this, defined_in, identifier, poly_vars, fields: Vec::new() }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum EnumVariantValue {
     None,
     Integer(i64),
+}
 #[derive(Debug, Clone)]
 pub struct EnumVariantDefinition {
     pub identifier: Identifier,
     pub value: EnumVariantValue,
+}
 #[derive(Debug, Clone)]
 pub struct EnumDefinition {
     pub this: EnumDefinitionId,
     pub defined_in: RootId,
     // Symbol scanning
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Parsing
     pub variants: Vec<EnumVariantDefinition>,
+}
 impl EnumDefinition {
     pub(crate) fn new_empty(
         this: EnumDefinitionId, defined_in: RootId,
         identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self{ this, defined_in, identifier, poly_vars, variants: Vec::new() }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct UnionVariantDefinition {
     pub span: InputSpan,
     pub identifier: Identifier,
     pub value: Vec<ParserType>, // if empty, then union variant does not contain any embedded types
+}
 #[derive(Debug, Clone)]
 pub struct UnionDefinition {
     pub this: UnionDefinitionId,
     pub defined_in: RootId,
     // Phase 1: symbol scanning
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Phase 2: parsing
     pub variants: Vec<UnionVariantDefinition>,
+}
 impl UnionDefinition {
     pub(crate) fn new_empty(
         this: UnionDefinitionId, defined_in: RootId,
         identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self{ this, defined_in, identifier, poly_vars, variants: Vec::new() }
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ProcedureKind {
     Function, // with return type
     Primitive, // without return type
     Composite,
     Component,
+}
 /// Monomorphed instantiation of a procedure (or the sole instantiation of a
 /// non-polymorphic procedure).
 #[derive(Debug)]
 pub struct ProcedureDefinitionMonomorph {
     pub argument_types: Vec<TypeId>,
     pub expr_info: Vec<ExpressionInfo>
+}
 impl ProcedureDefinitionMonomorph {
     pub(crate) fn new_invalid() -> Self {
         return Self{
             argument_types: Vec::new(),
             expr_info: Vec::new(),
+        }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub struct ExpressionInfo {
     pub type_id: TypeId,
     pub variant: ExpressionInfoVariant,
+}
 impl ExpressionInfo {
     pub(crate) fn new_invalid() -> Self {
         return Self{
             type_id: TypeId::new_invalid(),
             variant: ExpressionInfoVariant::Generic,
+        }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum ExpressionInfoVariant {
     Generic,
     Procedure(TypeId, u32), // procedure TypeID and its monomorph index
     Select(i32), // index
+}
 impl ExpressionInfoVariant {
     pub(crate) fn as_select(&self) -> i32 {
         match self {
             ExpressionInfoVariant::Select(v) => *v,
             _ => unreachable!(),
+        }
+    }
     pub(crate) fn as_procedure(&self) -> (TypeId, u32) {
         match self {
             ExpressionInfoVariant::Procedure(type_id, monomorph_index) => (*type_id, *monomorph_index),
             _ => unreachable!(),
+        }
+    }
+}
 #[derive(Debug)]
 pub enum ProcedureSource {
     FuncUserDefined,
     CompUserDefined,
     // Builtin functions, available to user
     FuncGet,
     FuncPut,
     FuncFires,
     FuncCreate,
     FuncLength,
     FuncAssert,
     FuncPrint,
     // Buitlin functions, not available to user
     FuncSelectStart,
     FuncSelectRegisterCasePort,
     FuncSelectWait,
     // Builtin components, available to user
     CompRandomU32, // TODO: Remove, temporary thing
     CompTcpClient,
     CompTcpListener,
+}
 impl ProcedureSource {
     pub(crate) fn is_builtin(&self) -> bool {
         match self {
             ProcedureSource::FuncUserDefined | ProcedureSource::CompUserDefined => false,
             _ => true,
+        }
+    }
+}
 /// Generic storage for functions, primitive components and composite
 /// components.
 /// Generic storage for functions and components.
 // Note that we will have function definitions for builtin functions as well. In
 // that case the span, the identifier span and the body are all invalid.
 #[derive(Debug)]
 pub struct ProcedureDefinition {
     pub this: ProcedureDefinitionId,
     pub defined_in: RootId,
     // Symbol scanning
     pub kind: ProcedureKind,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Parser
     pub source: ProcedureSource,
     pub return_type: Option<ParserType>, // present on functions, not components
     pub parameters: Vec<VariableId>,
     pub scope: ScopeId,
     pub body: BlockStatementId,
     // Monomorphization of typed procedures
     pub monomorphs: Vec<ProcedureDefinitionMonomorph>,
+}
 impl ProcedureDefinition {
     pub(crate) fn new_empty(
         this: ProcedureDefinitionId, defined_in: RootId,
         kind: ProcedureKind, identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self {
             this, defined_in,
             kind, identifier, poly_vars,
             source: ProcedureSource::FuncUserDefined,
             return_type: None,
             parameters: Vec::new(),
             scope: ScopeId::new_invalid(),
             body: BlockStatementId::new_invalid(),
             monomorphs: Vec::new(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub enum Statement {
     Block(BlockStatement),
     EndBlock(EndBlockStatement),
     Local(LocalStatement),
     Labeled(LabeledStatement),
     If(IfStatement),
     EndIf(EndIfStatement),
     While(WhileStatement),
     EndWhile(EndWhileStatement),
     Break(BreakStatement),
     Continue(ContinueStatement),
     Synchronous(SynchronousStatement),
     EndSynchronous(EndSynchronousStatement),
     Fork(ForkStatement),
     EndFork(EndForkStatement),
     Select(SelectStatement),
     EndSelect(EndSelectStatement),
     Return(ReturnStatement),
     Goto(GotoStatement),
     New(NewStatement),
     Expression(ExpressionStatement),
+}
 impl Statement {
     pub fn as_new(&self) -> &NewStatement {
         match self {
             Statement::New(result) => result,
             _ => panic!("Unable to cast `Statement` to `NewStatement`"),
+        }
+    }
     pub fn span(&self) -> InputSpan {
         match self {
             Statement::Block(v) => v.span,
             Statement::Local(v) => v.span(),
             Statement::Labeled(v) => v.label.span,
             Statement::If(v) => v.span,
             Statement::While(v) => v.span,
             Statement::Break(v) => v.span,
             Statement::Continue(v) => v.span,
             Statement::Synchronous(v) => v.span,
             Statement::Fork(v) => v.span,
             Statement::Select(v) => v.span,
             Statement::Return(v) => v.span,
             Statement::Goto(v) => v.span,
             Statement::New(v) => v.span,
             Statement::Expression(v) => v.span,
             Statement::EndBlock(_)
             | Statement::EndIf(_)
             | Statement::EndWhile(_)
             | Statement::EndSynchronous(_)
             | Statement::EndFork(_)
             | Statement::EndSelect(_) => unreachable!(),
+        }
+    }
     pub fn link_next(&mut self, next: StatementId) {
         match self {
             Statement::Block(stmt) => stmt.next = next,
             Statement::EndBlock(stmt) => stmt.next = next,
             Statement::Local(stmt) => match stmt {
                 LocalStatement::Channel(stmt) => stmt.next = next,
                 LocalStatement::Memory(stmt) => stmt.next = next,
             },
             Statement::EndIf(stmt) => stmt.next = next,
             Statement::EndWhile(stmt) => stmt.next = next,
             Statement::EndSynchronous(stmt) => stmt.next = next,
             Statement::EndFork(stmt) => stmt.next = next,
             Statement::EndSelect(stmt) => stmt.next = next,
             Statement::New(stmt) => stmt.next = next,
             Statement::Expression(stmt) => stmt.next = next,
             Statement::Return(_)
             | Statement::Break(_)
             | Statement::Continue(_)
             | Statement::Synchronous(_)
             | Statement::Fork(_)
             | Statement::Select(_)
             | Statement::Goto(_)
             | Statement::While(_)
             | Statement::Labeled(_)
             | Statement::If(_) => unreachable!(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct BlockStatement {
     pub this: BlockStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the complete block
     pub statements: Vec<StatementId>,
     pub end_block: EndBlockStatementId,
     // Phase 2: linker
     pub scope: ScopeId,
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct EndBlockStatement {
     pub this: EndBlockStatementId,
     // Parser
     pub start_block: BlockStatementId,
     // Validation/Linking
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub enum LocalStatement {
     Memory(MemoryStatement),
     Channel(ChannelStatement),
+}
 impl LocalStatement {
     pub fn this(&self) -> LocalStatementId {
         match self {
             LocalStatement::Memory(stmt) => stmt.this.upcast(),
             LocalStatement::Channel(stmt) => stmt.this.upcast(),
+        }
+    }
     pub fn span(&self) -> InputSpan {
         match self {
             LocalStatement::Channel(v) => v.span,
             LocalStatement::Memory(v) => v.span,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct MemoryStatement {
     pub this: MemoryStatementId,
     // Phase 1: parser
     pub span: InputSpan,
     pub variable: VariableId,
     pub initial_expr: AssignmentExpressionId,
     // Phase 2: linker
     pub next: StatementId,
+}
 /// ChannelStatement is the declaration of an input and output port associated
 /// with the same channel. Note that the polarity of the ports are from the
 /// point of view of the component. So an output port is something that a
 /// component uses to send data over (i.e. it is the "input end" of the
 /// channel), and vice versa.
 #[derive(Debug, Clone)]
 pub struct ChannelStatement {
     pub this: ChannelStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "channel" keyword
     pub from: VariableId, // output
     pub to: VariableId,   // input
     // Phase 2: linker
     pub relative_pos_in_parent: i32,
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct LabeledStatement {
     pub this: LabeledStatementId,
     // Phase 1: parser
     pub label: Identifier,
     pub body: StatementId,
     // Phase 2: linker
     pub relative_pos_in_parent: i32,
     pub in_sync: SynchronousStatementId, // may be invalid
+}
 #[derive(Debug, Clone)]
 pub struct IfStatement {
     pub this: IfStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "if" keyword
     pub test: ExpressionId,
     pub true_case: IfStatementCase,
     pub false_case: Option<IfStatementCase>,
     pub end_if: EndIfStatementId,
+}
 #[derive(Debug, Clone, Copy)]
 pub struct IfStatementCase {
     pub body: StatementId,
     pub scope: ScopeId,
+}
 #[derive(Debug, Clone)]
 pub struct EndIfStatement {
     pub this: EndIfStatementId,
     pub start_if: IfStatementId,
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct WhileStatement {
     pub this: WhileStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "while" keyword
     pub test: ExpressionId,
     pub scope: ScopeId,
     pub body: StatementId,
     pub end_while: EndWhileStatementId,
     pub in_sync: SynchronousStatementId, // may be invalid
+}
 #[derive(Debug, Clone)]
 pub struct EndWhileStatement {
     pub this: EndWhileStatementId,
     pub start_while: WhileStatementId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct BreakStatement {
     pub this: BreakStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "break" keyword
     pub label: Option<Identifier>,
     // Phase 2: linker
     pub target: EndWhileStatementId, // invalid if not yet set
+}
 #[derive(Debug, Clone)]
 pub struct ContinueStatement {
     pub this: ContinueStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "continue" keyword
     pub label: Option<Identifier>,
     // Phase 2: linker
     pub target: WhileStatementId, // invalid if not yet set
+}
 #[derive(Debug, Clone)]
 pub struct SynchronousStatement {
     pub this: SynchronousStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "sync" keyword
     pub scope: ScopeId,
     pub body: StatementId,
     pub end_sync: EndSynchronousStatementId,
+}
 #[derive(Debug, Clone)]
 pub struct EndSynchronousStatement {
     pub this: EndSynchronousStatementId,
     pub start_sync: SynchronousStatementId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct ForkStatement {
     pub this: ForkStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "fork" keyword
     pub left_body: StatementId,
     pub right_body: Option<StatementId>,
     pub end_fork: EndForkStatementId,
+}
 #[derive(Debug, Clone)]
 pub struct EndForkStatement {
     pub this: EndForkStatementId,
     pub start_fork: ForkStatementId,
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct SelectStatement {
     pub this: SelectStatementId,
     pub span: InputSpan, // of the "select" keyword
     pub cases: Vec<SelectCase>,
     pub end_select: EndSelectStatementId,
     pub relative_pos_in_parent: i32,
     pub next: StatementId, // note: the select statement will be transformed into other AST elements, this `next` jumps to those replacement statements
+}
 #[derive(Debug, Clone)]
 pub struct SelectCase {
     // The guard statement of a `select` is either a MemoryStatement or an
     // ExpressionStatement. Nothing else is allowed by the initial parsing
     pub guard: StatementId,
     pub body: StatementId,
     pub scope: ScopeId,
     // Phase 2: Validation and Linking
     pub involved_ports: Vec<(CallExpressionId, ExpressionId)>, // call to `get` and its port argument
+}
 #[derive(Debug, Clone)]
 pub struct EndSelectStatement {
     pub this: EndSelectStatementId,
     pub start_select: SelectStatementId,
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct ReturnStatement {
     pub this: ReturnStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "return" keyword
     pub expressions: Vec<ExpressionId>,
+}
 #[derive(Debug, Clone)]
 pub struct GotoStatement {
     pub this: GotoStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "goto" keyword
     pub label: Identifier,
     // Phase 2: linker
     pub target: LabeledStatementId, // invalid if not yet set
+}
 #[derive(Debug, Clone)]
 pub struct NewStatement {
     pub this: NewStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "new" keyword
     pub expression: CallExpressionId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct ExpressionStatement {
     pub this: ExpressionStatementId,
     // Phase 1: parser
     pub span: InputSpan,
     pub expression: ExpressionId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum ExpressionParent {
     None, // only set during initial parsing
     Memory(MemoryStatementId),
     If(IfStatementId),
     While(WhileStatementId),
     Return(ReturnStatementId),
     New(NewStatementId),
     ExpressionStmt(ExpressionStatementId),
     Expression(ExpressionId, u32) // index within expression (e.g LHS or RHS of expression, or index in array literal, etc.)
+}
 impl ExpressionParent {
     pub fn is_new(&self) -> bool {
         match self {
             ExpressionParent::New(_) => true,
             _ => false,
+        }
+    }
     pub fn as_expression(&self) -> ExpressionId {
         match self {
             ExpressionParent::Expression(id, _) => *id,
             _ => panic!("called as_expression() on {:?}", self),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub enum Expression {
     Assignment(AssignmentExpression),
     Binding(BindingExpression),
     Conditional(ConditionalExpression),
     Binary(BinaryExpression),
     Unary(UnaryExpression),
     Indexing(IndexingExpression),
     Slicing(SlicingExpression),
     Select(SelectExpression),
     Literal(LiteralExpression),
     Cast(CastExpression),
     Call(CallExpression),
     Variable(VariableExpression),
+}
 impl Expression {
     pub fn as_variable(&self) -> &VariableExpression {
         match self {
             Expression::Variable(result) => result,
             _ => panic!("Unable to cast `Expression` to `VariableExpression`"),
+        }
+    }
     /// Returns operator span, function name, a binding's "let" span, etc. An
     /// indicator for the kind of expression that is being applied.
     pub fn operation_span(&self) -> InputSpan {
         match self {
             Expression::Assignment(expr) => expr.operator_span,
             Expression::Binding(expr) => expr.operator_span,
             Expression::Conditional(expr) => expr.operator_span,
             Expression::Binary(expr) => expr.operator_span,
             Expression::Unary(expr) => expr.operator_span,
             Expression::Indexing(expr) => expr.operator_span,
             Expression::Slicing(expr) => expr.slicing_span,
             Expression::Select(expr) => expr.operator_span,
             Expression::Literal(expr) => expr.span,
             Expression::Cast(expr) => expr.cast_span,
             Expression::Call(expr) => expr.func_span,
             Expression::Variable(expr) => expr.identifier.span,
+        }
+    }
     /// Returns the span covering the entire expression (i.e. including the
     /// spans of the arguments as well).
     pub fn full_span(&self) -> InputSpan {
         match self {
             Expression::Assignment(expr) => expr.full_span,
             Expression::Binding(expr) => expr.full_span,
             Expression::Conditional(expr) => expr.full_span,
             Expression::Binary(expr) => expr.full_span,
             Expression::Unary(expr) => expr.full_span,
             Expression::Indexing(expr) => expr.full_span,
             Expression::Slicing(expr) => expr.full_span,
             Expression::Select(expr) => expr.full_span,
             Expression::Literal(expr) => expr.span,
             Expression::Cast(expr) => expr.full_span,
             Expression::Call(expr) => expr.full_span,
             Expression::Variable(expr) => expr.identifier.span,
+        }
+    }
     pub fn parent(&self) -> &ExpressionParent {
         match self {
             Expression::Assignment(expr) => &expr.parent,
             Expression::Binding(expr) => &expr.parent,
             Expression::Conditional(expr) => &expr.parent,
             Expression::Binary(expr) => &expr.parent,
             Expression::Unary(expr) => &expr.parent,
             Expression::Indexing(expr) => &expr.parent,
             Expression::Slicing(expr) => &expr.parent,
             Expression::Select(expr) => &expr.parent,
             Expression::Literal(expr) => &expr.parent,
             Expression::Cast(expr) => &expr.parent,
             Expression::Call(expr) => &expr.parent,
             Expression::Variable(expr) => &expr.parent,
+        }
+    }
     pub fn parent_mut(&mut self) -> &mut ExpressionParent {
         match self {
             Expression::Assignment(expr) => &mut expr.parent,
             Expression::Binding(expr) => &mut expr.parent,
             Expression::Conditional(expr) => &mut expr.parent,
             Expression::Binary(expr) => &mut expr.parent,
             Expression::Unary(expr) => &mut expr.parent,
             Expression::Indexing(expr) => &mut expr.parent,
             Expression::Slicing(expr) => &mut expr.parent,
             Expression::Select(expr) => &mut expr.parent,
             Expression::Literal(expr) => &mut expr.parent,
             Expression::Cast(expr) => &mut expr.parent,
             Expression::Call(expr) => &mut expr.parent,
             Expression::Variable(expr) => &mut expr.parent,
+        }
+    }
     pub fn parent_expr_id(&self) -> Option<ExpressionId> {
         if let ExpressionParent::Expression(id, _) = self.parent() {
             Some(*id)
         } else {
             None
+        }
+    }
     pub fn type_index(&self) -> i32 {
         match self {
             Expression::Assignment(expr) => expr.type_index,
             Expression::Binding(expr) => expr.type_index,
             Expression::Conditional(expr) => expr.type_index,
             Expression::Binary(expr) => expr.type_index,
             Expression::Unary(expr) => expr.type_index,
             Expression::Indexing(expr) => expr.type_index,
             Expression::Slicing(expr) => expr.type_index,
             Expression::Select(expr) => expr.type_index,
             Expression::Literal(expr) => expr.type_index,
             Expression::Cast(expr) => expr.type_index,
             Expression::Call(expr) => expr.type_index,
             Expression::Variable(expr) => expr.type_index,
+        }
+    }
     pub fn type_index_mut(&mut self) -> &mut i32 {
         match self {
             Expression::Assignment(expr) => &mut expr.type_index,
             Expression::Binding(expr) => &mut expr.type_index,
             Expression::Conditional(expr) => &mut expr.type_index,
             Expression::Binary(expr) => &mut expr.type_index,
             Expression::Unary(expr) => &mut expr.type_index,
             Expression::Indexing(expr) => &mut expr.type_index,
             Expression::Slicing(expr) => &mut expr.type_index,
             Expression::Select(expr) => &mut expr.type_index,
             Expression::Literal(expr) => &mut expr.type_index,
             Expression::Cast(expr) => &mut expr.type_index,
             Expression::Call(expr) => &mut expr.type_index,
             Expression::Variable(expr) => &mut expr.type_index,
+        }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum AssignmentOperator {
     Set,
     Concatenated,
     Multiplied,
     Divided,
     Remained,
     Added,
     Subtracted,
     ShiftedLeft,
     ShiftedRight,
     BitwiseAnded,
     BitwiseXored,
     BitwiseOred,
+}
 #[derive(Debug, Clone)]
 pub struct AssignmentExpression {
     pub this: AssignmentExpressionId,
     // Parsing
     pub operator_span: InputSpan,
     pub full_span: InputSpan,
     pub left: ExpressionId,
     pub operation: AssignmentOperator,
     pub right: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
     pub type_index: i32,
+}
 #[derive(Debug, Clone)]
 pub struct BindingExpression {
     pub this: BindingExpressionId,
     // Parsing
     pub operator_span: InputSpan,
     pub full_span: InputSpan,
     pub bound_to: ExpressionId,
     pub bound_from: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
     pub type_index: i32,
+}
 #[derive(Debug, Clone)]
 pub struct ConditionalExpression {
     pub this: ConditionalExpressionId,
     // Parsing
     pub operator_span: InputSpan,
     pub full_span: InputSpan,
     pub test: ExpressionId,
     pub true_expression: ExpressionId,
     pub false_expression: ExpressionId,
     // Validator/Linking
     pub parent: ExpressionParent,
     // Typing
     pub type_index: i32,
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum BinaryOperator {
     Concatenate,
     LogicalOr,
     LogicalAnd,
     BitwiseOr,
     BitwiseXor,
     BitwiseAnd,
     Equality,
     Inequality,
     LessThan,
     GreaterThan,
     LessThanEqual,
     GreaterThanEqual,
     ShiftLeft,
     ShiftRight,
     Add,
     Subtract,
     Multiply,
     Divide,
     Remainder,
+}
 #[derive(Debug, Clone)]
 pub struct BinaryExpression {
     pub this: BinaryExpressionId,
     // Parsing
     pub operator_span: InputSpan,
     pub full_span: InputSpan,
     pub left: ExpressionId,
     pub operation: BinaryOperator,
     pub right: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
     pub type_index: i32,
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum UnaryOperator {
     Positive,
     Negative,
     BitwiseNot,
     LogicalNot,
+}
 #[derive(Debug, Clone)]
 pub struct UnaryExpression {
     pub this: UnaryExpressionId,
     // Parsing
     pub operator_span: InputSpan,
     pub full_span: InputSpan,
     pub operation: UnaryOperator,
     pub expression: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
     pub type_index: i32,
+}
 #[derive(Debug, Clone)]
 pub struct IndexingExpression {
     pub this: IndexingExpressionId,
     // Parsing
     pub operator_span: InputSpan,
     pub full_span: InputSpan,
     pub subject: ExpressionId,
     pub index: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
     pub type_index: i32,
+}
 #[derive(Debug, Clone)]
 pub struct SlicingExpression {
     pub this: SlicingExpressionId,
     // Parsing
     pub slicing_span: InputSpan, // from '[' to ']'
     pub full_span: InputSpan, // includes subject
     pub subject: ExpressionId,
     pub from_index: ExpressionId,
     pub to_index: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
     pub type_index: i32,
+}
 #[derive(Debug, Clone)]
 pub enum SelectKind {
     StructField(Identifier),
     TupleMember(u64), // u64 is overkill, but space is taken up by `StructField` variant anyway
+}
 #[derive(Debug, Clone)]
 pub struct SelectExpression {
     pub this: SelectExpressionId,
     // Parsing
     pub operator_span: InputSpan, // of the '.'
     pub full_span: InputSpan, // includes subject and field
     pub subject: ExpressionId,
     pub kind: SelectKind,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
     pub type_index: i32,
+}
 #[derive(Debug, Clone)]
 pub struct CastExpression {
     pub this: CastExpressionId,
     // Parsing
     pub cast_span: InputSpan, // of the "cast" keyword,
     pub full_span: InputSpan, // includes the cast subject
     pub to_type: ParserType,
     pub subject: ExpressionId,
     // Validator/linker
     pub parent: ExpressionParent,
     // Typing
     pub type_index: i32,
+}
 #[derive(Debug, Clone)]
 pub struct CallExpression {
     pub this: CallExpressionId,
     // Parsing
     pub func_span: InputSpan, // of the function name
     pub full_span: InputSpan, // includes the arguments and parentheses
     pub parser_type: ParserType, // of the function call, not the return type
     pub method: Method,
     pub arguments: Vec<ExpressionId>,
     pub procedure: ProcedureDefinitionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
     pub type_index: i32,
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Method {
     // Builtin function, accessible by programmer
     Get,
     Put,
     Fires,
     Create,
     Length,
     Assert,
     Print,
     // Builtin function, not accessible by programmer
     SelectStart, // SelectStart(total_num_cases, total_num_ports)
     SelectRegisterCasePort, // SelectRegisterCasePort(case_index, port_index, port_id)
     SelectWait, // SelectWait() -> u32
     // Builtin component,
     ComponentRandomU32,
     ComponentTcpClient,
     ComponentTcpListener,
     // User-defined
     UserFunction,
     UserComponent,
+}
 impl Method {
     pub(crate) fn is_public_builtin(&self) -> bool {
         use Method::*;
         match self {
             Get | Put | Fires | Create | Length | Assert | Print => true,
             ComponentRandomU32 | ComponentTcpClient => true,
+            ComponentRandomU32 | ComponentTcpClient | ComponentTcpListener => true,
             _ => false,
+        }
+    }
     pub(crate) fn is_user_defined(&self) -> bool {
         use Method::*;
         match self {
             UserFunction | UserComponent => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct LiteralExpression {
     pub this: LiteralExpressionId,
     // Parsing
     pub span: InputSpan,
     pub value: Literal,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
     pub type_index: i32,
+}
 #[derive(Debug, Clone)]
 pub enum Literal {
     Null, // message
     True,
     False,
     Character(char),
     Bytestring(Vec<u8>),
     String(StringRef<'static>),
     Integer(LiteralInteger),
     Struct(LiteralStruct),
     Enum(LiteralEnum),
     Union(LiteralUnion),
     Array(Vec<ExpressionId>),
     Tuple(Vec<ExpressionId>),
+}
 impl Literal {
     pub(crate) fn as_struct(&self) -> &LiteralStruct {
         if let Literal::Struct(literal) = self{
             literal
         } else {
             unreachable!("Attempted to obtain {:?} as Literal::Struct", self)
+        }
+    }
     pub(crate) fn as_enum(&self) -> &LiteralEnum {
         if let Literal::Enum(literal) = self {
             literal
         } else {
             unreachable!("Attempted to obtain {:?} as Literal::Enum", self)
+        }
+    }
     pub(crate) fn as_union(&self) -> &LiteralUnion {
         if let Literal::Union(literal) = self {
             literal
         } else {
             unreachable!("Attempted to obtain {:?} as Literal::Union", self)
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct LiteralInteger {
     pub(crate) unsigned_value: u64,
     pub(crate) negated: bool, // for constant expression evaluation, TODO: @Int
+}
 #[derive(Debug, Clone)]
 pub struct LiteralStructField {
     // Phase 1: parser
     pub(crate) identifier: Identifier,
     pub(crate) value: ExpressionId,
     // Phase 2: linker
     pub(crate) field_idx: usize, // in struct definition
+}
 #[derive(Debug, Clone)]
 pub struct LiteralStruct {
     // Phase 1: parser
     pub(crate) parser_type: ParserType,
     pub(crate) fields: Vec<LiteralStructField>,
     pub(crate) definition: DefinitionId,
+}
 #[derive(Debug, Clone)]
 pub struct LiteralEnum {
     // Phase 1: parser
     pub(crate) parser_type: ParserType,
     pub(crate) variant: Identifier,
     pub(crate) definition: DefinitionId,
     // Phase 2: linker
     pub(crate) variant_idx: usize, // as present in the type table
+}
 #[derive(Debug, Clone)]
 pub struct LiteralUnion {
     // Phase 1: parser
     pub(crate) parser_type: ParserType,
     pub(crate) variant: Identifier,
     pub(crate) values: Vec<ExpressionId>,
     pub(crate) definition: DefinitionId,
     // Phase 2: linker
     pub(crate) variant_idx: usize, // as present in type table
+}
 #[derive(Debug, Clone)]
 pub struct VariableExpression {
     pub this: VariableExpressionId,
     // Parsing
     pub identifier: Identifier,
     // Validator/Linker
     pub declaration: Option<VariableId>,
     pub used_as_binding_target: bool,
     pub parent: ExpressionParent,
     // Typing
     pub type_index: i32,
+}
@@ \ No newline at end of file @@

src/protocol/eval/executor.rs

➞

Show inline comments

@@ @@ -389,769 +389,769 @@ impl Prompt { @@
+                                    }
                                     (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 = &heap[cur_frame.definition].monomorphs[cur_frame.monomorph_index];
                             let field_idx = mono_data.expr_info[expr.type_index as usize].variant.as_select() 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 = match expr.kind {
                                         SelectKind::StructField(_) => subject.as_struct(),
                                         SelectKind::TupleMember(_) => subject.as_tuple(),
                                     };
                                     (None, Value::Ref(ValueId::Heap(subject_heap_pos, field_idx)))
                                 },
                                 _ => {
                                     let subject_heap_pos = match expr.kind {
                                         SelectKind::StructField(_) => subject.as_struct(),
                                         SelectKind::TupleMember(_) => subject.as_tuple(),
                                     };
                                     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::Bytestring(lit_value) => {
                                     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.reserve(lit_value.len());
                                     for byte in lit_value {
                                         values.push(Value::UInt8(*byte));
+                                    }
                                     Value::Array(heap_pos)
+                                }
                                 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 mono_data = &heap[cur_frame.definition].monomorphs[cur_frame.monomorph_index];
                                     let type_id = mono_data.expr_info[expr.type_index as usize].type_id;
                                     let concrete_type = &types.get_monomorph(type_id).concrete_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)
+                                }
                                 Literal::Tuple(lit_value) => {
                                     let heap_pos = transfer_expression_values_front_into_heap(
                                         cur_frame, &mut self.store, lit_value.len()
                                     );
                                     Value::Tuple(heap_pos)
+                                }
                             };
                             cur_frame.expr_values.push_back(value);
                         },
                         Expression::Cast(expr) => {
                             let mono_data = &heap[cur_frame.definition].monomorphs[cur_frame.monomorph_index];
                             let type_id = mono_data.expr_info[expr.type_index as usize].type_id;
                             let concrete_type = &types.get_monomorph(type_id).concrete_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, concrete_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();
                                     let port_id = if let Value::Input(port_id) = value {
                                         port_id
                                     } else {
                                         unreachable!("executor calling 'get' on value {:?}", value)
                                     };
                                     match ctx.performed_get(port_id) {
                                         Some(result) => {
                                             // We have the result. Merge the `ValueGroup` with the
                                             // stack/heap storage.
                                             debug_assert_eq!(result.values.len(), 1);
                                             result.into_stack(&mut cur_frame.expr_values, &mut self.store);
                                         },
                                         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(expr_id, 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();
                                     if ctx.performed_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 {
                                         // Prepare to execute again
                                         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));
                                         let value_group = ValueGroup::from_store(&self.store, &[deref_msg_value]);
                                         return Ok(EvalContinuation::Put(expr_id, port_id, value_group));
+                                    }
                                 },
                                 Method::Fires => {
                                     let port_value = cur_frame.expr_values.pop_front().unwrap();
                                     let port_value_deref = self.store.maybe_read_ref(&port_value).clone();
                                     let port_id = port_value_deref.as_port_id();
                                     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_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::BranchInconsistent)
+                                    }
                                 },
                                 Method::Print => {
                                     // Convert the runtime-variant of a string
                                     // into an actual string.
                                     let value = cur_frame.expr_values.pop_front().unwrap();
                                     let is_literal_string = value.get_heap_pos().is_some();
                                     let value = self.store.maybe_read_ref(&value);
                                     let value_heap_pos = value.as_string();
                                     let elements = &self.store.heap_regions[value_heap_pos as usize].values;
                                     let mut message = String::with_capacity(elements.len());
                                     for element in elements {
                                         message.push(element.as_char());
+                                    }
                                     // Drop the heap-allocated value from the
                                     // store
                                     if is_literal_string {
                                         self.store.drop_heap_pos(value_heap_pos);
+                                    }
                                     println!("{}", message);
                                 },
                                 Method::SelectStart => {
                                     let num_cases = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_uint32();
                                     let num_ports = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_uint32();
                                     return Ok(EvalContinuation::SelectStart(num_cases, num_ports));
                                 },
                                 Method::SelectRegisterCasePort => {
                                     let case_index = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_uint32();
                                     let port_index = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_uint32();
                                     let port_value = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_port_id();
                                     return Ok(EvalContinuation::SelectRegisterPort(expr_id, case_index, port_index, port_value));
                                 },
                                 Method::SelectWait => {
                                     match ctx.performed_select_wait() {
                                         Some(select_index) => {
                                             cur_frame.expr_values.push_back(Value::UInt32(select_index));
                                         },
                                         None => {
                                             cur_frame.expr_stack.push_back(ExprInstruction::EvalExpr(expr.this.upcast()));
                                             return Ok(EvalContinuation::SelectWait)
                                         },
+                                    }
                                 },
                                 Method::ComponentRandomU32 | Method::ComponentTcpClient => {
+                                Method::ComponentRandomU32 | Method::ComponentTcpClient | Method::ComponentTcpListener => {
                                     debug_assert_eq!(heap[expr.procedure].parameters.len(), cur_frame.expr_values.len());
                                     debug_assert_eq!(heap[cur_frame.position].as_new().expression, expr.this);
                                 },
                                 Method::UserComponent => {
                                     // This is actually handled by the evaluation
                                     // of the statement.
                                     debug_assert_eq!(heap[expr.procedure].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 = &heap[cur_frame.definition].monomorphs[cur_frame.monomorph_index];
                                     let (type_id, monomorph_index) = mono_data.expr_info[expr.type_index as usize].variant.as_procedure();
                                     // Push the new frame and reserve its stack size
                                     let new_frame = Frame::new(heap, expr.procedure, type_id, monomorph_index);
                                     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];
                 let scope = &heap[block.scope];
                 self.store.clear_stack(scope.first_unique_id_in_scope as usize);
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Memory(stmt) => {
                         dbg_code!({
                             let variable = &heap[stmt.variable];
                             debug_assert!(match self.store.read_ref(ValueId::Stack(variable.unique_id_in_scope as u32)) {
                                 Value::Unassigned => false,
                                 _ => true,
                             });
                         });
                         cur_frame.position = stmt.next;
                         Ok(EvalContinuation::Stepping)
                     },
                     LocalStatement::Channel(stmt) => {
                         // Need to create a new channel by requesting it from
                         // the runtime.
                         match ctx.created_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)
+                            }
+                        }
+                    }
+                }
             },
             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_case.body;
                 } else if let Some(false_body) = stmt.false_case {
                     cur_frame.position = false_body.body;
                 } 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;
                 let if_stmt = &heap[stmt.start_if];
                 debug_assert_eq!(
                     heap[if_stmt.true_case.scope].first_unique_id_in_scope,
                     heap[if_stmt.false_case.unwrap_or(if_stmt.true_case).scope].first_unique_id_in_scope,
                 );
                 let scope = &heap[if_stmt.true_case.scope];
                 self.store.clear_stack(scope.first_unique_id_in_scope as usize);
                 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;
                 } else {
                     cur_frame.position = stmt.end_while.upcast();
+                }
                 Ok(EvalContinuation::Stepping)
             },
             Statement::EndWhile(stmt) => {
                 cur_frame.position = stmt.next;
                 let start_while = &heap[stmt.start_while];
                 let scope = &heap[start_while.scope];
                 self.store.clear_stack(scope.first_unique_id_in_scope as usize);
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Break(stmt) => {
                 cur_frame.position = stmt.target.upcast();
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Continue(stmt) => {
                 cur_frame.position = stmt.target.upcast();
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Synchronous(stmt) => {
                 cur_frame.position = stmt.body;
                 Ok(EvalContinuation::SyncBlockStart)
             },
             Statement::EndSynchronous(stmt) => {
                 cur_frame.position = stmt.next;
                 let start_synchronous = &heap[stmt.start_sync];
                 let scope = &heap[start_synchronous.scope];
                 self.store.clear_stack(scope.first_unique_id_in_scope as usize);
                 Ok(EvalContinuation::SyncBlockEnd)
             },
             Statement::Fork(stmt) => {
                 if stmt.right_body.is_none() {
                     // No reason to fork
                     cur_frame.position = stmt.left_body;
                 } else {
                     // Need to fork
                     if let Some(go_left) = ctx.performed_fork() {
                         // Runtime has created a fork
                         if go_left {
                             cur_frame.position = stmt.left_body;
                         } else {
                             cur_frame.position = stmt.right_body.unwrap();
+                        }
                     } else {
                         // Request the runtime to create a fork of the current
                         // branch
                         return Ok(EvalContinuation::NewFork);
+                    }
+                }
                 Ok(EvalContinuation::Stepping)
             },
             Statement::EndFork(stmt) => {
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Select(stmt) => {
                 // This is a trampoline for the statements that were placed by
                 // the AST transformation pass
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::EndSelect(stmt) => {
                 cur_frame.position = stmt.next;
                 let start_select = &heap[stmt.start_select];
                 if let Some(select_case) = start_select.cases.first() {
                     let scope = &heap[select_case.scope];
                     self.store.clear_stack(scope.first_unique_id_in_scope as usize);
+                }
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Return(_stmt) => {
                 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::ComponentTerminated);
+                }
                 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.upcast();
                 Ok(EvalContinuation::Stepping)
             },
             Statement::New(stmt) => {
                 let call_expr = &heap[stmt.expression];
                 debug_assert_eq!(
                     cur_frame.expr_values.len(), heap[call_expr.procedure].parameters.len(),
                     "mismatch in expr stack size and number of arguments for new statement"
                 );
                 let mono_data = &heap[cur_frame.definition].monomorphs[cur_frame.monomorph_index];
                 let type_id = mono_data.expr_info[call_expr.type_index as usize].variant.as_procedure().0;
                 // 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.procedure, type_id, 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::Local(stmt) => {
                     if let LocalStatement::Memory(stmt) = stmt {
                         // Setup as unassigned, when we execute the memory
                         // statement (after evaluating expression), it should no
                         // longer be `Unassigned`.
                         let variable = &heap[stmt.variable];
                         self.store.write(ValueId::Stack(variable.unique_id_in_scope as u32), Value::Unassigned);
                         cur_frame.prepare_single_expression(heap, stmt.initial_expr.upcast());
+                    }
                 },
                 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
+    }
     /// Constructs an error at the current expression that lives at the top of
     /// the expression stack. Falls back to constructing an error at the current
     /// statement if there is no expression.
     pub(crate) fn new_error_at_expr(&self, modules: &[Module], heap: &Heap, error_message: String) -> EvalError {
         let last_frame = self.frames.last().unwrap();
         for instruction in last_frame.expr_stack.iter().rev() {
             if let ExprInstruction::EvalExpr(expression_id) = instruction {
                 return EvalError::new_error_at_expr(
                     self, modules, heap, *expression_id, error_message

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_writer;
 mod token_writer;
 use std::sync::Mutex;
 use crate::collections::{StringPool, StringRef};
 pub use crate::protocol::ast::*;
 use crate::protocol::eval::*;
 use crate::protocol::input_source::*;
 use crate::protocol::parser::*;
 use crate::protocol::type_table::*;
 pub use parser::type_table::TypeId;
 /// 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 {
     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 {
     pub(crate) prompt: Prompt,
+}
 #[derive(Debug)]
 pub enum ComponentCreationError {
     ModuleDoesntExist,
     DefinitionDoesntExist,
     DefinitionNotComponent,
     InvalidNumArguments,
     InvalidArgumentType(usize),
     UnownedPort,
     InSync,
+}
 impl ProtocolDescription {
     pub fn parse(buffer: &[u8]) -> Result<Self, String> {
         let source = InputSource::new(String::new(), Vec::from(buffer));
         let mut parser = Parser::new(None)?;
         parser.feed(source).expect("failed to feed source");
         if let Err(err) = parser.parse() {
             println!("ERROR:\n{}", err);
             return Err(format!("{}", err))
+        }
         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 new_component(
         &self, module_name: &[u8], identifier: &[u8], arguments: ValueGroup
     ) -> Result<Prompt, ComponentCreationError> {
         // Find the module in which the definition can be found
         let module_root = self.lookup_module_root(module_name);
         if module_root.is_none() {
             return Err(ComponentCreationError::ModuleDoesntExist);
+        }
         let module_root = module_root.unwrap();
         let root = &self.heap[module_root];
         let definition_id = root.get_definition_by_ident(&self.heap, identifier);
         if definition_id.is_none() {
             return Err(ComponentCreationError::DefinitionDoesntExist);
+        }
         let definition_id = definition_id.unwrap();
         let ast_definition = &self.heap[definition_id];
         if !ast_definition.is_procedure() {
             return Err(ComponentCreationError::DefinitionNotComponent);
+        }
         // Make sure that the types of the provided value group matches that of
         // the expected types.
         let ast_definition = ast_definition.as_procedure();
         if !ast_definition.poly_vars.is_empty() || ast_definition.kind == ProcedureKind::Function {
             return Err(ComponentCreationError::DefinitionNotComponent);
+        }
         // - check number of arguments by retrieving the one instantiated
         //   monomorph
         let concrete_type = ConcreteType{ parts: vec![ConcreteTypePart::Component(ast_definition.this, 0)] };
         let procedure_type_id = self.types.get_monomorph_type_id(&definition_id, &concrete_type.parts).unwrap();
         let procedure_monomorph_index = self.types.get_monomorph(procedure_type_id).variant.as_procedure().monomorph_index;
         let monomorph_info = &ast_definition.monomorphs[procedure_monomorph_index as usize];
         if monomorph_info.argument_types.len() != arguments.values.len() {
             return Err(ComponentCreationError::InvalidNumArguments);
+        }
         // - for each argument try to make sure the types match
         for arg_idx in 0..arguments.values.len() {
             let expected_type_id = monomorph_info.argument_types[arg_idx];
             let expected_type = &self.types.get_monomorph(expected_type_id).concrete_type;
             let provided_value = &arguments.values[arg_idx];
             if !self.verify_same_type(expected_type, 0, &arguments, provided_value) {
                 return Err(ComponentCreationError::InvalidArgumentType(arg_idx));
+            }
+        }
         // By now we're sure that all of the arguments are correct. So create
         // the connector.
         return Ok(Prompt::new(&self.types, &self.heap, ast_definition.this, procedure_type_id, arguments));
+    }
     /// A somewhat temporary method. Can be used by components to lookup type
     /// definitions by their name (to have their implementation somewhat
     /// resistant to changes in the standard library)
     pub(crate) fn find_type<'a>(&'a self, module_name: &[u8], type_name: &[u8]) -> Option<TypeInspector<'a>> {
         // Lookup type definition in module
         let root_id = self.lookup_module_root(module_name)?;
         let module = &self.heap[root_id];
         let definition_id = module.get_definition_by_ident(&self.heap, type_name)?;
         let definition = &self.heap[definition_id];
         // Make sure type is not polymorphic and is not a procedure
         if !definition.poly_vars().is_empty() {
             return None;
+        }
         if definition.is_procedure() {
             return None;
+        }
         // Lookup type in type table
         let type_parts = [ConcreteTypePart::Instance(definition_id, 0)];
         let type_id = self.types.get_monomorph_type_id(&definition_id, &type_parts)
             .expect("type ID for non-polymorphic type");
         let type_monomorph = self.types.get_monomorph(type_id);
         return Some(TypeInspector{
             heap: definition,
             type_table: type_monomorph
         });
+    }
     /// Again a somewhat temporary method. Can be used by components to look up
     /// the definition of a particular procedure. Intended use is to find the
     /// DefinitionId/TypeId of builtin components.
     pub(crate) fn find_procedure(&self, module_name: &[u8], proc_name: &[u8]) -> Option<(ProcedureDefinitionId, TypeId)> {
         // Lookup type definition in module
         let root_id = self.lookup_module_root(module_name)?;
         let module = &self.heap[root_id];
         let definition_id = module.get_definition_by_ident(&self.heap, proc_name)?;
         let definition = &self.heap[definition_id];
         // Make sure the procedure is not polymorphic
         if !definition.poly_vars().is_empty() {
             return None;
+        }
         if !definition.is_procedure() {
             return None;
+        }
         // Lookup in type table
         let definition = definition.as_procedure();
         let type_parts = [ConcreteTypePart::Component(definition.this, 0)];
         let type_id = self.types.get_monomorph_type_id(&definition.this.upcast(), &type_parts)
             .expect("type ID for non-polymorphic procedure");
         return Some((definition.this, type_id));
+    }
     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;
+    }
     fn verify_same_type(&self, expected: &ConcreteType, expected_idx: usize, arguments: &ValueGroup, argument: &Value) -> bool {
         use ConcreteTypePart as CTP;
         match &expected.parts[expected_idx] {
             CTP::Void | CTP::Message | CTP::Slice | CTP::Pointer | CTP::Function(_, _) | CTP::Component(_, _) => unreachable!(),
             CTP::Bool => if let Value::Bool(_) = argument { true } else { false },
             CTP::UInt8 => if let Value::UInt8(_) = argument { true } else { false },
             CTP::UInt16 => if let Value::UInt16(_) = argument { true } else { false },
             CTP::UInt32 => if let Value::UInt32(_) = argument { true } else { false },
             CTP::UInt64 => if let Value::UInt64(_) = argument { true } else { false },
             CTP::SInt8 => if let Value::SInt8(_) = argument { true } else { false },
             CTP::SInt16 => if let Value::SInt16(_) = argument { true } else { false },
             CTP::SInt32 => if let Value::SInt32(_) = argument { true } else { false },
             CTP::SInt64 => if let Value::SInt64(_) = argument { true } else { false },
             CTP::Character => if let Value::Char(_) = argument { true } else { false },
             CTP::String => {
                 // Match outer string type and embedded character types
                 if let Value::String(heap_pos) = argument {
                     for element in &arguments.regions[*heap_pos as usize] {
                         if let Value::Char(_) = element {} else {
                             return false;
+                        }
+                    }
                 } else {
                     return false;
+                }
                 return true;
             },
             CTP::Array => {
                 if let Value::Array(heap_pos) = argument {
                     let heap_pos = *heap_pos;
                     for element in &arguments.regions[heap_pos as usize] {
                         if !self.verify_same_type(expected, expected_idx + 1, arguments, element) {
                             return false;
+                        }
+                    }
                     return true;
                 } else {
                     return false;
+                }
             },
             CTP::Input => if let Value::Input(_) = argument { true } else { false },
             CTP::Output => if let Value::Output(_) = argument { true } else { false },
             CTP::Tuple(_) => todo!("implement full type checking on user-supplied arguments"),
             CTP::Instance(definition_id, _num_embedded) => {
                 let definition = self.types.get_base_definition(definition_id).unwrap();
                 match &definition.definition {
                     DefinedTypeVariant::Enum(definition) => {
                         if let Value::Enum(variant_value) = argument {
                             let is_valid = definition.variants.iter()
                                 .any(|v| v.value == *variant_value);
                             return is_valid;
+                        }
                     },
                     _ => todo!("implement full type checking on user-supplied arguments"),
+                }
                 return false;
             },
+        }
+    }
+}
 pub trait RunContext {
     fn performed_put(&mut self, port: PortId) -> bool;
     fn performed_get(&mut self, port: PortId) -> Option<ValueGroup>; // None if still waiting on message
     fn fires(&mut self, port: PortId) -> Option<Value>; // None if not yet branched
     fn performed_fork(&mut self) -> Option<bool>; // None if not yet forked
     fn created_channel(&mut self) -> Option<(Value, Value)>; // None if not yet prepared
     fn performed_select_wait(&mut self) -> Option<u32>; // None if not yet notified runtime of select blocker
+}
 pub struct ProtocolDescriptionBuilder {
     parser: Parser,
+}
 impl ProtocolDescriptionBuilder {
     pub fn new(std_lib_dir: Option<String>) -> Result<Self, String> {
         let mut parser = Parser::new(std_lib_dir)?;
         return Ok(Self{ parser })
+    }
     pub fn add(&mut self, filename: String, buffer: Vec<u8>) -> Result<(), ParseError> {
         let input = InputSource::new(filename, buffer);
         self.parser.feed(input)?;
         return Ok(())
+    }
     pub fn compile(mut self) -> Result<ProtocolDescription, ParseError> {
         self.parser.parse()?;
         let modules: Vec<Module> = self.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: self.parser.heap,
             types: self.parser.type_table,
             pool: Mutex::new(self.parser.string_pool),
         });
+    }
+}
 pub struct TypeInspector<'a> {
     heap: &'a Definition,
     type_table: &'a MonoType,
+}
 impl<'a> TypeInspector<'a> {
     pub fn as_union(&'a self) -> UnionTypeInspector<'a> {
         let heap = self.heap.as_union();
         let type_table = self.type_table.variant.as_union();
         return UnionTypeInspector{ heap, type_table };
+    }
     pub fn as_struct(&'a self) -> StructTypeInspector<'a> {
         let heap = self.heap.as_struct();
         let type_table = self.type_table.variant.as_struct();
         return StructTypeInspector{ heap, type_table };
+    }
+}
 pub struct UnionTypeInspector<'a> {
     heap: &'a UnionDefinition,
     type_table: &'a UnionMonomorph,
+}
 impl UnionTypeInspector<'_> {
     /// Retrieves union variant tag value.
     pub fn get_variant_tag_value(&self, variant_name: &[u8]) -> Option<i64> {
         let variant_index = self.heap.variants.iter()
             .position(|v| v.identifier.value.as_bytes() == variant_name)?;
         return Some(variant_index as i64);
+    }
+}
 pub struct StructTypeInspector<'a> {
     heap: &'a StructDefinition,
     type_table: &'a StructMonomorph,
+}
 impl StructTypeInspector<'_> {
     /// Retrieves number of struct fields
     pub fn get_num_struct_fields(&self) -> usize {
         return self.heap.fields.len();
+    }
     /// Retrieves struct field index
     pub fn get_struct_field_index(&self, field_name: &[u8]) -> Option<usize> {
         let field_index = self.heap.fields.iter()
             .position(|v| v.field.value.as_bytes() == field_name)?;
         return Some(field_index);
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/pass_definitions.rs

➞

Show inline comments

 use crate::protocol::ast::*;
 use super::symbol_table::*;
 use super::{Module, ModuleCompilationPhase, PassCtx};
 use super::tokens::*;
 use super::token_parsing::*;
 use super::pass_definitions_types::*;
 use crate::protocol::input_source::{InputSource, InputPosition, InputSpan, ParseError};
 use crate::collections::*;
 /// Parses all the tokenized definitions into actual AST nodes.
 pub(crate) struct PassDefinitions {
     // State associated with the definition currently being processed
     cur_definition: DefinitionId,
     // Itty bitty parsing machines
     type_parser: ParserTypeParser,
     // Temporary buffers of various kinds
     buffer: String,
     struct_fields: ScopedBuffer<StructFieldDefinition>,
     enum_variants: ScopedBuffer<EnumVariantDefinition>,
     union_variants: ScopedBuffer<UnionVariantDefinition>,
     variables: ScopedBuffer<VariableId>,
     expressions: ScopedBuffer<ExpressionId>,
     statements: ScopedBuffer<StatementId>,
     parser_types: ScopedBuffer<ParserType>,
+}
 impl PassDefinitions {
     pub(crate) fn new() -> Self {
         Self{
             cur_definition: DefinitionId::new_invalid(),
             type_parser: ParserTypeParser::new(),
             buffer: String::with_capacity(128),
             struct_fields: ScopedBuffer::with_capacity(128),
             enum_variants: ScopedBuffer::with_capacity(128),
             union_variants: ScopedBuffer::with_capacity(128),
             variables: ScopedBuffer::with_capacity(128),
             expressions: ScopedBuffer::with_capacity(128),
             statements: ScopedBuffer::with_capacity(128),
             parser_types: ScopedBuffer::with_capacity(128),
+        }
+    }
     pub(crate) fn parse(&mut self, modules: &mut [Module], module_idx: usize, ctx: &mut PassCtx) -> Result<(), ParseError> {
         let module = &modules[module_idx];
         debug_assert_eq!(module.phase, ModuleCompilationPhase::ImportsResolved);
         // We iterate through the entire document. If we find a marker that has
         // been handled then we skip over it. It is important that we properly
         // parse all other tokens in the document to ensure that we throw the
         // correct kind of errors.
         let num_tokens = module.tokens.tokens.len() as u32;
         let num_markers = module.tokens.markers.len();
         let mut marker_index = 0;
         let mut first_token_index = 0;
         while first_token_index < num_tokens {
             // Seek ahead to the next marker that was already handled.
             let mut last_token_index = num_tokens;
             let mut new_first_token_index = num_tokens;
             while marker_index < num_markers {
                 let marker = &module.tokens.markers[marker_index];
                 marker_index += 1;
                 if marker.handled {
                     last_token_index = marker.first_token;
                     new_first_token_index = marker.last_token;
                     break;
+                }
+            }
             self.visit_token_range(modules, module_idx, ctx, first_token_index, last_token_index)?;
             first_token_index = new_first_token_index;
+        }
         modules[module_idx].phase = ModuleCompilationPhase::DefinitionsParsed;
         Ok(())
+    }
     fn visit_token_range(
         &mut self, modules: &[Module], module_idx: usize, ctx: &mut PassCtx,
         token_range_begin: u32, token_range_end: u32,
     ) -> Result<(), ParseError> {
         let module = &modules[module_idx];
         // Detect which definition we're parsing
         let mut iter = module.tokens.iter_range(token_range_begin, Some(token_range_end));
         loop {
             let next = iter.next();
             if next.is_none() {
                 return Ok(())
+            }
             // Token was not None, so peek_ident returns None if not an ident
             let ident = peek_ident(&module.source, &mut iter);
             match ident {
                 Some(KW_STRUCT) => self.visit_struct_definition(module, &mut iter, ctx)?,
                 Some(KW_ENUM) => self.visit_enum_definition(module, &mut iter, ctx)?,
                 Some(KW_UNION) => self.visit_union_definition(module, &mut iter, ctx)?,
                 Some(KW_FUNCTION) => self.visit_function_definition(module, &mut iter, ctx)?,
-                Some(KW_PRIMITIVE) | Some(KW_COMPOSITE) => self.visit_component_definition(module, &mut iter, ctx)?,
+                Some(KW_COMPONENT) => self.visit_component_definition(module, &mut iter, ctx)?,
                 _ => return Err(ParseError::new_error_str_at_pos(
                     &module.source, iter.last_valid_pos(),
                     "unexpected symbol, expected a keyword marking the start of a definition"
                 )),
+            }
+        }
+    }
     fn visit_struct_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         consume_exact_ident(&module.source, iter, KW_STRUCT)?;
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated DefinitionId
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         // Parse struct definition
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         let mut fields_section = self.struct_fields.start_section();
         consume_comma_separated(
             TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
                 let poly_vars = ctx.heap[definition_id].poly_vars();
                 let start_pos = iter.last_valid_pos();
                 let parser_type = self.type_parser.consume_parser_type(
                     iter, &ctx.heap, source, &ctx.symbols, poly_vars, definition_id,
                     module_scope, false, false, None
                 )?;
                 let field = consume_ident_interned(source, iter, ctx)?;
                 Ok(StructFieldDefinition{
                     span: InputSpan::from_positions(start_pos, field.span.end),
                     field, parser_type
                 })
             },
             &mut fields_section, "a struct field", "a list of struct fields", None
         )?;
         // Transfer to preallocated definition
         let struct_def = ctx.heap[definition_id].as_struct_mut();
         struct_def.fields = fields_section.into_vec();
         Ok(())
+    }
     fn visit_enum_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         consume_exact_ident(&module.source, iter, KW_ENUM)?;
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated DefinitionId
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         // Parse enum definition
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         let mut enum_section = self.enum_variants.start_section();
         consume_comma_separated(
             TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
                 let identifier = consume_ident_interned(source, iter, ctx)?;
                 let value = if iter.next() == Some(TokenKind::Equal) {
                     iter.consume();
                     let (variant_number, _) = consume_integer_literal(source, iter, &mut self.buffer)?;
                     EnumVariantValue::Integer(variant_number as i64) // TODO: @int
                 } else {
                     EnumVariantValue::None
                 };
                 Ok(EnumVariantDefinition{ identifier, value })
             },
             &mut enum_section, "an enum variant", "a list of enum variants", None
         )?;
         // Transfer to definition
         let enum_def = ctx.heap[definition_id].as_enum_mut();
         enum_def.variants = enum_section.into_vec();
         Ok(())
+    }
     fn visit_union_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         consume_exact_ident(&module.source, iter, KW_UNION)?;
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated DefinitionId
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         // Parse union definition
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         let mut variants_section = self.union_variants.start_section();
         consume_comma_separated(
             TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
                 let identifier = consume_ident_interned(source, iter, ctx)?;
                 let mut close_pos = identifier.span.end;
                 let mut types_section = self.parser_types.start_section();
                 let has_embedded = maybe_consume_comma_separated(
                     TokenKind::OpenParen, TokenKind::CloseParen, source, iter, ctx,
                     |source, iter, ctx| {
                         let poly_vars = ctx.heap[definition_id].poly_vars();
                         self.type_parser.consume_parser_type(
                             iter, &ctx.heap, source, &ctx.symbols, poly_vars, definition_id,
                             module_scope, false, false, None
+                        )
                     },
                     &mut types_section, "an embedded type", Some(&mut close_pos)
                 )?;
                 let value = if has_embedded {
                     types_section.into_vec()
                 } else {
                     types_section.forget();
                     Vec::new()
                 };
                 Ok(UnionVariantDefinition{
                     span: InputSpan::from_positions(identifier.span.begin, close_pos),
                     identifier,
                     value
                 })
             },
             &mut variants_section, "a union variant", "a list of union variants", None
         )?;
         // Transfer to AST
         let union_def = ctx.heap[definition_id].as_union_mut();
         union_def.variants = variants_section.into_vec();
         Ok(())
+    }
     fn visit_function_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         // Retrieve function name
         consume_exact_ident(&module.source, iter, KW_FUNCTION)?;
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated DefinitionId
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         let allow_compiler_types = module.is_compiler_file;
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         // Parse function's argument list
         let mut parameter_section = self.variables.start_section();
         consume_parameter_list(
             &mut self.type_parser, &module.source, iter, ctx, &mut parameter_section,
             module_scope, definition_id, allow_compiler_types
         )?;
         let parameters = parameter_section.into_vec();
         // Consume return types
         consume_token(&module.source, iter, TokenKind::ArrowRight)?;
         let poly_vars = ctx.heap[definition_id].poly_vars();
         let parser_type = self.type_parser.consume_parser_type(
             iter, &ctx.heap, &module.source, &ctx.symbols, poly_vars, definition_id,
             module_scope, false, allow_compiler_types, None
         )?;
         // Consume body
         let (body_id, source) = self.consume_procedure_body(module, iter, ctx, definition_id, ProcedureKind::Function)?;
         let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::Definition(definition_id)));
         // Assign everything in the preallocated AST node
         let function = ctx.heap[definition_id].as_procedure_mut();
         function.source = source;
         function.return_type = Some(parser_type);
         function.parameters = parameters;
         function.scope = scope_id;
         function.body = body_id;
         Ok(())
+    }
     fn visit_component_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         // Consume component variant and name
         let (_variant_text, _) = consume_any_ident(&module.source, iter)?;
         debug_assert!(_variant_text == KW_PRIMITIVE || _variant_text == KW_COMPOSITE);
         let (_component_text, _) = consume_any_ident(&module.source, iter)?;
         debug_assert!(_component_text == KW_COMPONENT);
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated definition
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         let allow_compiler_types = module.is_compiler_file;
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         // Parse component's argument list
         let mut parameter_section = self.variables.start_section();
         consume_parameter_list(
             &mut self.type_parser, &module.source, iter, ctx, &mut parameter_section,
             module_scope, definition_id, allow_compiler_types
         )?;
         let parameters = parameter_section.into_vec();
         // Consume body
         let procedure_kind = ctx.heap[definition_id].as_procedure().kind;
         let (body_id, source) = self.consume_procedure_body(module, iter, ctx, definition_id, procedure_kind)?;
         let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::Definition(definition_id)));
         // Assign everything in the AST node
         let component = ctx.heap[definition_id].as_procedure_mut();
         debug_assert!(component.return_type.is_none());
         component.source = source;
         component.parameters = parameters;
         component.scope = scope_id;
         component.body = body_id;
         Ok(())
+    }
     /// Consumes a procedure's body: either a user-defined procedure, which we
     /// parse as normal, or a builtin function, where we'll make sure we expect
     /// the particular builtin.
     ///
     /// We expect that the procedure's name is already stored in the
     /// preallocated AST node.
     fn consume_procedure_body(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, definition_id: DefinitionId, kind: ProcedureKind
     ) -> Result<(BlockStatementId, ProcedureSource), ParseError> {
         if iter.next() == Some(TokenKind::OpenCurly) && iter.peek() == Some(TokenKind::Pragma) {
             // Consume the placeholder "{ #builtin }" tokens
             iter.consume(); // opening curly brace
             let (pragma, pragma_span) = consume_pragma(&module.source, iter)?;
             if pragma != b"#builtin" {
                 return Err(ParseError::new_error_str_at_span(
                     &module.source, pragma_span,
                     "expected a '#builtin' pragma, or a function body"
                 ));
+            }
             if iter.next() != Some(TokenKind::CloseCurly) {
                 // Just to keep the compiler writers in line ;)
                 panic!("compiler error: when using the #builtin pragma, wrap it in curly braces");
+            }
             iter.consume();
             // Retrieve module and procedure name
             assert!(module.name.is_some(), "compiler error: builtin procedure body in unnamed module");
             let (_, module_name) = module.name.as_ref().unwrap();
             let module_name = module_name.as_str();
             let definition = ctx.heap[definition_id].as_procedure();
             let procedure_name = definition.identifier.value.as_str();
             let source = match (module_name, procedure_name) {
                 ("std.global", "get") => ProcedureSource::FuncGet,
                 ("std.global", "put") => ProcedureSource::FuncPut,
                 ("std.global", "fires") => ProcedureSource::FuncFires,
                 ("std.global", "create") => ProcedureSource::FuncCreate,
                 ("std.global", "length") => ProcedureSource::FuncLength,
                 ("std.global", "assert") => ProcedureSource::FuncAssert,
                 ("std.global", "print") => ProcedureSource::FuncPrint,
                 ("std.random", "random_u32") => ProcedureSource::CompRandomU32,
                 ("std.internet", "tcp_client") => ProcedureSource::CompTcpClient,
                 ("std.internet", "tcp_listener") => ProcedureSource::CompTcpListener,
                 _ => panic!(
                     "compiler error: unknown builtin procedure '{}' in module '{}'",
                     procedure_name, module_name
                 ),
             };
             return Ok((BlockStatementId::new_invalid(), source));
         } else {
             let body_id = self.consume_block_statement(module, iter, ctx)?;
             let source = match kind {
                 ProcedureKind::Function =>
                     ProcedureSource::FuncUserDefined,
-                ProcedureKind::Primitive | ProcedureKind::Composite =>
+                ProcedureKind::Component =>
                     ProcedureSource::CompUserDefined,
             };
             return Ok((body_id, source))
+        }
+    }
     /// Consumes a statement and returns a boolean indicating whether it was a
     /// block or not.
     fn consume_statement(&mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx) -> Result<StatementId, ParseError> {
         let next = iter.next().expect("consume_statement has a next token");
         if next == TokenKind::OpenCurly {
             let id = self.consume_block_statement(module, iter, ctx)?;
             return Ok(id.upcast());
         } else if next == TokenKind::Ident {
             let ident = peek_ident(&module.source, iter).unwrap();
             if ident == KW_STMT_IF {
                 // Consume if statement and place end-if statement directly
                 // after it.
                 let id = self.consume_if_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_WHILE {
                 let id = self.consume_while_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_BREAK {
                 let id = self.consume_break_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_CONTINUE {
                 let id = self.consume_continue_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_SYNC {
                 let id = self.consume_synchronous_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_FORK {
                 let id = self.consume_fork_statement(module, iter, ctx)?;
                 let end_fork = ctx.heap.alloc_end_fork_statement(|this| EndForkStatement {
                     this,
                     start_fork: id,
                     next: StatementId::new_invalid(),
                 });
                 let fork_stmt = &mut ctx.heap[id];
                 fork_stmt.end_fork = end_fork;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_SELECT {
                 let id = self.consume_select_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_RETURN {
                 let id = self.consume_return_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_GOTO {
                 let id = self.consume_goto_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_NEW {
                 let id = self.consume_new_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_CHANNEL {
                 let id = self.consume_channel_statement(module, iter, ctx)?;
                 return Ok(id.upcast().upcast());
             } else if iter.peek() == Some(TokenKind::Colon) {
                 let id = self.consume_labeled_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else {
                 // Two fallback possibilities: the first one is a memory
                 // declaration, the other one is to parse it as a normal
                 // expression. This is a bit ugly.
                 if let Some(memory_stmt_id) = self.maybe_consume_memory_statement_without_semicolon(module, iter, ctx)? {
                     consume_token(&module.source, iter, TokenKind::SemiColon)?;
                     return Ok(memory_stmt_id.upcast().upcast());
                 } else {
                     let id = self.consume_expression_statement(module, iter, ctx)?;
                     return Ok(id.upcast());
+                }
+            }
         } else if next == TokenKind::OpenParen {
             // Same as above: memory statement or normal expression
             if let Some(memory_stmt_id) = self.maybe_consume_memory_statement_without_semicolon(module, iter, ctx)? {
                 consume_token(&module.source, iter, TokenKind::SemiColon)?;
                 return Ok(memory_stmt_id.upcast().upcast());
             } else {
                 let id = self.consume_expression_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
+            }
         } else {
             let id = self.consume_expression_statement(module, iter, ctx)?;
             return Ok(id.upcast());
+        }
+    }
     fn consume_block_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<BlockStatementId, ParseError> {
         let open_curly_span = consume_token(&module.source, iter, TokenKind::OpenCurly)?;
         let mut stmt_section = self.statements.start_section();
         let mut next = iter.next();
         while next != Some(TokenKind::CloseCurly) {
             if next.is_none() {
                 return Err(ParseError::new_error_str_at_pos(
                     &module.source, iter.last_valid_pos(), "expected a statement or '}'"
                 ));
+            }
             let stmt_id = self.consume_statement(module, iter, ctx)?;
             stmt_section.push(stmt_id);
             next = iter.next();
+        }
         let statements = stmt_section.into_vec();
         let mut block_span = consume_token(&module.source, iter, TokenKind::CloseCurly)?;
         block_span.begin = open_curly_span.begin;
         let block_id = ctx.heap.alloc_block_statement(|this| BlockStatement{
             this,
             span: block_span,
             statements,
             end_block: EndBlockStatementId::new_invalid(),
             scope: ScopeId::new_invalid(),
             next: StatementId::new_invalid(),
         });
         let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::Block(block_id)));
         let end_block_id = ctx.heap.alloc_end_block_statement(|this| EndBlockStatement{
             this, start_block: block_id, next: StatementId::new_invalid()
         });
         let block_stmt = &mut ctx.heap[block_id];
         block_stmt.end_block = end_block_id;
         block_stmt.scope = scope_id;
         Ok(block_id)
+    }
     fn consume_if_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<IfStatementId, ParseError> {
         let if_span = consume_exact_ident(&module.source, iter, KW_STMT_IF)?;
         consume_token(&module.source, iter, TokenKind::OpenParen)?;
         let test = self.consume_expression(module, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::CloseParen)?;
         // Consume bodies of if-statement
         let true_body = IfStatementCase{
             body: self.consume_statement(module, iter, ctx)?,
             scope: ScopeId::new_invalid(),
         };
         let false_body = if has_ident(&module.source, iter, KW_STMT_ELSE) {
             iter.consume();
             let false_body = IfStatementCase{
                 body: self.consume_statement(module, iter, ctx)?,
                 scope: ScopeId::new_invalid(),
             };
             Some(false_body)
         } else {
             None
         };
         // Construct AST elements
         let if_stmt_id = ctx.heap.alloc_if_statement(|this| IfStatement{
             this,
             span: if_span,
             test,
             true_case: true_body,
             false_case: false_body,
             end_if: EndIfStatementId::new_invalid(),
         });
         let end_if_stmt_id = ctx.heap.alloc_end_if_statement(|this| EndIfStatement{
             this,
             start_if: if_stmt_id,
             next: StatementId::new_invalid(),
         });
         let true_scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::If(if_stmt_id, true)));
         let false_scope_id = if false_body.is_some() {
             Some(ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::If(if_stmt_id, false))))
         } else {
             None
         };
         let if_stmt = &mut ctx.heap[if_stmt_id];
         if_stmt.end_if = end_if_stmt_id;
         if_stmt.true_case.scope = true_scope_id;
         if let Some(false_case) = &mut if_stmt.false_case {
             false_case.scope = false_scope_id.unwrap();
+        }
         return Ok(if_stmt_id);
+    }
     fn consume_while_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<WhileStatementId, ParseError> {
         let while_span = consume_exact_ident(&module.source, iter, KW_STMT_WHILE)?;
         consume_token(&module.source, iter, TokenKind::OpenParen)?;
         let test = self.consume_expression(module, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::CloseParen)?;
         let body = self.consume_statement(module, iter, ctx)?;
         let while_stmt_id = ctx.heap.alloc_while_statement(|this| WhileStatement{
             this,
             span: while_span,
             test,
             scope: ScopeId::new_invalid(),
             body,
             end_while: EndWhileStatementId::new_invalid(),
             in_sync: SynchronousStatementId::new_invalid(),
         });
         let end_while_stmt_id = ctx.heap.alloc_end_while_statement(|this| EndWhileStatement{
             this,
             start_while: while_stmt_id,
             next: StatementId::new_invalid(),
         });
         let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::While(while_stmt_id)));
         let while_stmt = &mut ctx.heap[while_stmt_id];
         while_stmt.scope = scope_id;
         while_stmt.end_while = end_while_stmt_id;
         Ok(while_stmt_id)
+    }
     fn consume_break_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<BreakStatementId, ParseError> {
         let break_span = consume_exact_ident(&module.source, iter, KW_STMT_BREAK)?;
         let label = if Some(TokenKind::Ident) == iter.next() {
             let label = consume_ident_interned(&module.source, iter, ctx)?;
             Some(label)
         } else {
             None
         };
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         Ok(ctx.heap.alloc_break_statement(|this| BreakStatement{
             this,
             span: break_span,
             label,
             target: EndWhileStatementId::new_invalid(),
         }))
+    }
     fn consume_continue_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ContinueStatementId, ParseError> {
         let continue_span = consume_exact_ident(&module.source, iter, KW_STMT_CONTINUE)?;
         let label=  if Some(TokenKind::Ident) == iter.next() {
             let label = consume_ident_interned(&module.source, iter, ctx)?;
             Some(label)
         } else {
             None
         };
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         Ok(ctx.heap.alloc_continue_statement(|this| ContinueStatement{
             this,
             span: continue_span,
             label,
             target: WhileStatementId::new_invalid(),
         }))
+    }
     fn consume_synchronous_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<SynchronousStatementId, ParseError> {
         let synchronous_span = consume_exact_ident(&module.source, iter, KW_STMT_SYNC)?;
         let body = self.consume_statement(module, iter, ctx)?;
         let sync_stmt_id = ctx.heap.alloc_synchronous_statement(|this| SynchronousStatement{
             this,
             span: synchronous_span,
             scope: ScopeId::new_invalid(),
             body,
             end_sync: EndSynchronousStatementId::new_invalid(),
         });
         let end_sync_stmt_id = ctx.heap.alloc_end_synchronous_statement(|this| EndSynchronousStatement{
             this,
             start_sync: sync_stmt_id,
             next: StatementId::new_invalid(),
         });
         let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::Synchronous(sync_stmt_id)));
         let sync_stmt = &mut ctx.heap[sync_stmt_id];
         sync_stmt.scope = scope_id;
         sync_stmt.end_sync = end_sync_stmt_id;
         return Ok(sync_stmt_id);
+    }
     fn consume_fork_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ForkStatementId, ParseError> {
         let fork_span = consume_exact_ident(&module.source, iter, KW_STMT_FORK)?;
         let left_body = self.consume_statement(module, iter, ctx)?;
         let right_body = if has_ident(&module.source, iter, KW_STMT_OR) {
             iter.consume();
             let right_body = self.consume_statement(module, iter, ctx)?;
             Some(right_body)
         } else {
             None
         };
         Ok(ctx.heap.alloc_fork_statement(|this| ForkStatement{
             this,
             span: fork_span,
             left_body,
             right_body,
             end_fork: EndForkStatementId::new_invalid(),
         }))
+    }
     fn consume_select_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<SelectStatementId, ParseError> {
         let select_span = consume_exact_ident(&module.source, iter, KW_STMT_SELECT)?;
         consume_token(&module.source, iter, TokenKind::OpenCurly)?;
         let mut cases = Vec::new();
         let mut next = iter.next();
         while Some(TokenKind::CloseCurly) != next {
             let guard = match self.maybe_consume_memory_statement_without_semicolon(module, iter, ctx)? {
                 Some(guard_mem_stmt) => guard_mem_stmt.upcast().upcast(),
                 None => {
                     let start_pos = iter.last_valid_pos();
                     let expr = self.consume_expression(module, iter, ctx)?;
                     let end_pos = iter.last_valid_pos();
                     let guard_expr_stmt = ctx.heap.alloc_expression_statement(|this| ExpressionStatement{
                         this,
                         span: InputSpan::from_positions(start_pos, end_pos),
                         expression: expr,
                         next: StatementId::new_invalid(),
                     });
                     guard_expr_stmt.upcast()
                 },
             };
             consume_token(&module.source, iter, TokenKind::ArrowRight)?;
             let block = self.consume_statement(module, iter, ctx)?;
             cases.push(SelectCase{
                 guard,
                 body: block,
                 scope: ScopeId::new_invalid(),
                 involved_ports: Vec::with_capacity(1)
             });
             next = iter.next();
+        }
         consume_token(&module.source, iter, TokenKind::CloseCurly)?;
         let num_cases = cases.len();
         let select_stmt_id = ctx.heap.alloc_select_statement(|this| SelectStatement{
             this,
             span: select_span,
             cases,
             end_select: EndSelectStatementId::new_invalid(),
             relative_pos_in_parent: -1,
             next: StatementId::new_invalid(),
         });
         let end_select_stmt_id = ctx.heap.alloc_end_select_statement(|this| EndSelectStatement{
             this,
             start_select: select_stmt_id,
             next: StatementId::new_invalid(),
         });
         let select_stmt = &mut ctx.heap[select_stmt_id];
         select_stmt.end_select = end_select_stmt_id;
         for case_index in 0..num_cases {
             let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::SelectCase(select_stmt_id, case_index as u32)));
             let select_stmt = &mut ctx.heap[select_stmt_id];
             let select_case = &mut select_stmt.cases[case_index];
             select_case.scope = scope_id;
+        }
         return Ok(select_stmt_id)
+    }
     fn consume_return_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
@@ @@ -1282,629 +1283,636 @@ impl PassDefinitions { @@
+        )
+    }
     fn consume_prefix_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         fn parse_prefix_token(token: Option<TokenKind>) -> Option<UnaryOperator> {
             use TokenKind as TK;
             use UnaryOperator as UO;
             match token {
                 Some(TK::Plus) => Some(UO::Positive),
                 Some(TK::Minus) => Some(UO::Negative),
                 Some(TK::Tilde) => Some(UO::BitwiseNot),
                 Some(TK::Exclamation) => Some(UO::LogicalNot),
                 _ => None
+            }
+        }
         let next = iter.next();
         if let Some(operation) = parse_prefix_token(next) {
             let operator_span = iter.next_span();
             iter.consume();
             let expression = self.consume_prefix_expression(module, iter, ctx)?;
             let full_span = InputSpan::from_positions(
                 operator_span.begin, ctx.heap[expression].full_span().end,
             );
             Ok(ctx.heap.alloc_unary_expression(|this| UnaryExpression {
                 this, operator_span, full_span, operation, expression,
                 parent: ExpressionParent::None,
                 type_index: -1,
             }).upcast())
         } else if next == Some(TokenKind::PlusPlus) {
             return Err(ParseError::new_error_str_at_span(
                 &module.source, iter.next_span(), "prefix increment is not supported in the language"
             ));
         } else if next == Some(TokenKind::MinusMinus) {
             return Err(ParseError::new_error_str_at_span(
                 &module.source, iter.next_span(), "prefix decrement is not supported in this language"
             ));
         } else {
             self.consume_postfix_expression(module, iter, ctx)
+        }
+    }
     fn consume_postfix_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         fn has_matching_postfix_token(token: Option<TokenKind>) -> bool {
             use TokenKind as TK;
             if token.is_none() { return false; }
             match token.unwrap() {
                 TK::PlusPlus | TK::MinusMinus | TK::OpenSquare | TK::Dot => true,
                 _ => false
+            }
+        }
         let mut result = self.consume_primary_expression(module, iter, ctx)?;
         let mut next = iter.next();
         while has_matching_postfix_token(next) {
             let token = next.unwrap();
             let mut operator_span = iter.next_span();
             iter.consume();
             if token == TokenKind::PlusPlus {
                 return Err(ParseError::new_error_str_at_span(
                     &module.source, operator_span, "postfix increment is not supported in this language"
                 ));
             } else if token == TokenKind::MinusMinus {
                 return Err(ParseError::new_error_str_at_span(
                     &module.source, operator_span, "prefix increment is not supported in this language"
                 ));
             } else if token == TokenKind::OpenSquare {
                 let subject = result;
                 let from_index = self.consume_expression(module, iter, ctx)?;
                 // Check if we have an indexing or slicing operation
                 next = iter.next();
                 if Some(TokenKind::DotDot) == next {
                     iter.consume();
                     let to_index = self.consume_expression(module, iter, ctx)?;
                     let end_span = consume_token(&module.source, iter, TokenKind::CloseSquare)?;
                     operator_span.end = end_span.end;
                     let full_span = InputSpan::from_positions(
                         ctx.heap[subject].full_span().begin, operator_span.end
                     );
                     result = ctx.heap.alloc_slicing_expression(|this| SlicingExpression{
                         this,
                         slicing_span: operator_span,
                         full_span, subject, from_index, to_index,
                         parent: ExpressionParent::None,
                         type_index: -1,
                     }).upcast();
                 } else if Some(TokenKind::CloseSquare) == next {
                     let end_span = consume_token(&module.source, iter, TokenKind::CloseSquare)?;
                     operator_span.end = end_span.end;
                     let full_span = InputSpan::from_positions(
                         ctx.heap[subject].full_span().begin, operator_span.end
                     );
                     result = ctx.heap.alloc_indexing_expression(|this| IndexingExpression{
                         this, operator_span, full_span, subject,
                         index: from_index,
                         parent: ExpressionParent::None,
                         type_index: -1,
                     }).upcast();
                 } else {
                     return Err(ParseError::new_error_str_at_pos(
                         &module.source, iter.last_valid_pos(), "unexpected token: expected ']' or '..'"
                     ));
+                }
             } else {
                 // Can be a select expression for struct fields, or a select
                 // for a tuple element.
                 debug_assert_eq!(token, TokenKind::Dot);
                 let subject = result;
                 let next = iter.next();
                 let (select_kind, full_span) = if Some(TokenKind::Integer) == next {
                     // Tuple member
                     let (index, index_span) = consume_integer_literal(&module.source, iter, &mut self.buffer)?;
                     let full_span = InputSpan::from_positions(
                         ctx.heap[subject].full_span().begin, index_span.end
                     );
                     (SelectKind::TupleMember(index), full_span)
                 } else if Some(TokenKind::Ident) == next {
                     // Struct field
                     let field_name = consume_ident_interned(&module.source, iter, ctx)?;
                     let full_span = InputSpan::from_positions(
                         ctx.heap[subject].full_span().begin, field_name.span.end
                     );
                     (SelectKind::StructField(field_name), full_span)
                 } else {
                     return Err(ParseError::new_error_str_at_pos(
                         &module.source, iter.last_valid_pos(), "unexpected token: expected integer or identifier"
                     ));
                 };
                 result = ctx.heap.alloc_select_expression(|this| SelectExpression{
                     this, operator_span, full_span, subject,
                     kind: select_kind,
                     parent: ExpressionParent::None,
                     type_index: -1,
                 }).upcast();
+            }
             next = iter.next();
+        }
         Ok(result)
+    }
     fn consume_primary_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         let next = iter.next();
         let result = if next == Some(TokenKind::OpenParen) {
             // Something parenthesized. This can mean several things: we have
             // a parenthesized expression or we have a tuple literal. They are
             // ambiguous when the tuple has one member. But like the tuple type
             // parsing we interpret all one-tuples as parenthesized expressions.
             //
             // Practically (to prevent unnecessary `consume_expression` calls)
             // we distinguish the zero-tuple, the parenthesized expression, and
             // the N-tuple (for N > 1).
             let open_paren_pos = iter.next_start_position();
             iter.consume();
             let result = if Some(TokenKind::CloseParen) == iter.next() {
                 // Zero-tuple
                 let (_, close_paren_pos) = iter.next_positions();
                 iter.consume();
                 let literal_id = ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                     this,
                     span: InputSpan::from_positions(open_paren_pos, close_paren_pos),
                     value: Literal::Tuple(Vec::new()),
                     parent: ExpressionParent::None,
                     type_index: -1,
                 });
                 literal_id.upcast()
             } else {
                 // Start by consuming one expression, then check for a comma
                 let expr_id = self.consume_expression(module, iter, ctx)?;
                 if Some(TokenKind::Comma) == iter.next() && Some(TokenKind::CloseParen) != iter.peek() {
                     // Must be an N-tuple
                     iter.consume(); // the comma
                     let mut scoped_section = self.expressions.start_section();
                     scoped_section.push(expr_id);
                     let mut close_paren_pos = open_paren_pos;
                     consume_comma_separated_until(
                         TokenKind::CloseParen, &module.source, iter, ctx,
                         |_source, iter, ctx| self.consume_expression(module, iter, ctx),
                         &mut scoped_section, "an expression", Some(&mut close_paren_pos)
                     )?;
                     debug_assert!(scoped_section.len() > 1); // peeked token wasn't CloseParen, must be expression
                     let literal_id = ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                         this,
                         span: InputSpan::from_positions(open_paren_pos, close_paren_pos),
                         value: Literal::Tuple(scoped_section.into_vec()),
                         parent: ExpressionParent::None,
                         type_index: -1,
                     });
                     literal_id.upcast()
                 } else {
                     // Assume we're dealing with a normal expression
                     consume_token(&module.source, iter, TokenKind::CloseParen)?;
                     expr_id
+                }
             };
             result
         } else if next == Some(TokenKind::OpenCurly) {
             // Array literal
             let (start_pos, mut end_pos) = iter.next_positions();
             let mut scoped_section = self.expressions.start_section();
             consume_comma_separated(
                 TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
                 |_source, iter, ctx| self.consume_expression(module, iter, ctx),
                 &mut scoped_section, "an expression", "a list of expressions", Some(&mut end_pos)
             )?;
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this,
                 span: InputSpan::from_positions(start_pos, end_pos),
                 value: Literal::Array(scoped_section.into_vec()),
                 parent: ExpressionParent::None,
                 type_index: -1,
             }).upcast()
         } else if next == Some(TokenKind::Integer) {
             let (literal, span) = consume_integer_literal(&module.source, iter, &mut self.buffer)?;
             ctx.heap.alloc_literal_expression(|this| LiteralExpression {
                 this,
                 span,
                 value: Literal::Integer(LiteralInteger { unsigned_value: literal, negated: false }),
                 parent: ExpressionParent::None,
                 type_index: -1,
             }).upcast()
         } else if next == Some(TokenKind::Bytestring) {
             let span = consume_bytestring_literal(&module.source, iter, &mut self.buffer)?;
             let mut bytes = Vec::with_capacity(self.buffer.len());
             for byte in self.buffer.as_bytes().iter().copied() {
                 bytes.push(byte);
+            }
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this, span,
                 value: Literal::Bytestring(bytes),
                 parent: ExpressionParent::None,
                 type_index: -1
             }).upcast()
         } else if next == Some(TokenKind::String) {
             let span = consume_string_literal(&module.source, iter, &mut self.buffer)?;
             let interned = ctx.pool.intern(self.buffer.as_bytes());
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this, span,
                 value: Literal::String(interned),
                 parent: ExpressionParent::None,
                 type_index: -1,
             }).upcast()
         } else if next == Some(TokenKind::Character) {
             let (character, span) = consume_character_literal(&module.source, iter)?;
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this, span,
                 value: Literal::Character(character),
                 parent: ExpressionParent::None,
                 type_index: -1,
             }).upcast()
         } else if next == Some(TokenKind::Ident) {
             // May be a variable, a type instantiation or a function call. If we
             // have a single identifier that we cannot find in the type table
             // then we're going to assume that we're dealing with a variable.
             let ident_span = iter.next_span();
             let ident_text = module.source.section_at_span(ident_span);
             let symbol = ctx.symbols.get_symbol_by_name(SymbolScope::Module(module.root_id), ident_text);
             if symbol.is_some() {
                 // The first bit looked like a symbol, so we're going to follow
                 // that all the way through, assume we arrive at some kind of
                 // function call or type instantiation
                 use ParserTypeVariant as PTV;
                 let symbol_scope = SymbolScope::Definition(self.cur_definition);
                 let poly_vars = ctx.heap[self.cur_definition].poly_vars();
                 let parser_type = self.type_parser.consume_parser_type(
                     iter, &ctx.heap, &module.source, &ctx.symbols, poly_vars, self.cur_definition,
                     symbol_scope, true, false, None
                 )?;
                 debug_assert!(!parser_type.elements.is_empty());
                 match parser_type.elements[0].variant {
                     PTV::Definition(target_definition_id, _) => {
                         let definition = &ctx.heap[target_definition_id];
                         match definition {
                             Definition::Struct(_) => {
                                 // Struct literal
                                 let mut last_token = iter.last_valid_pos();
                                 let mut struct_fields = Vec::new();
                                 consume_comma_separated(
                                     TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
                                     |source, iter, ctx| {
                                         let identifier = consume_ident_interned(source, iter, ctx)?;
                                         consume_token(source, iter, TokenKind::Colon)?;
                                         let value = self.consume_expression(module, iter, ctx)?;
                                         Ok(LiteralStructField{ identifier, value, field_idx: 0 })
                                     },
                                     &mut struct_fields, "a struct field", "a list of struct fields", Some(&mut last_token)
                                 )?;
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, last_token),
                                     value: Literal::Struct(LiteralStruct{
                                         parser_type,
                                         fields: struct_fields,
                                         definition: target_definition_id,
                                     }),
                                     parent: ExpressionParent::None,
                                     type_index: -1,
                                 }).upcast()
                             },
                             Definition::Enum(_) => {
                                 // Enum literal: consume the variant
                                 consume_token(&module.source, iter, TokenKind::ColonColon)?;
                                 let variant = consume_ident_interned(&module.source, iter, ctx)?;
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, variant.span.end),
                                     value: Literal::Enum(LiteralEnum{
                                         parser_type,
                                         variant,
                                         definition: target_definition_id,
                                         variant_idx: 0
                                     }),
                                     parent: ExpressionParent::None,
                                     type_index: -1,
                                 }).upcast()
                             },
                             Definition::Union(_) => {
                                 // Union literal: consume the variant
                                 consume_token(&module.source, iter, TokenKind::ColonColon)?;
                                 let variant = consume_ident_interned(&module.source, iter, ctx)?;
                                 // Consume any possible embedded values
                                 let mut end_pos = variant.span.end;
                                 let values = if Some(TokenKind::OpenParen) == iter.next() {
                                     self.consume_expression_list(module, iter, ctx, Some(&mut end_pos))?
                                 } else {
                                     Vec::new()
                                 };
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, end_pos),
                                     value: Literal::Union(LiteralUnion{
                                         parser_type, variant, values,
                                         definition: target_definition_id,
                                         variant_idx: 0,
                                     }),
                                     parent: ExpressionParent::None,
                                     type_index: -1,
                                 }).upcast()
                             },
                             Definition::Procedure(proc_def) => {
                                 // Check whether it is a builtin function
                                 // TODO: Once we start generating bytecode this is unnecessary
                                 let procedure_id = proc_def.this;
                                 let method = match proc_def.source {
                                     ProcedureSource::FuncUserDefined => Method::UserFunction,
                                     ProcedureSource::CompUserDefined => Method::UserComponent,
                                     // Bit of a hack, at this point the source is not yet known, except if it is a
                                     // builtin. So we check for the "kind"
                                     ProcedureSource::FuncUserDefined | ProcedureSource::CompUserDefined => {
                                         match proc_def.kind {
                                             ProcedureKind::Function => Method::UserFunction,
                                             ProcedureKind::Component => Method::UserComponent,
+                                        }
                                     },
                                     ProcedureSource::FuncGet => Method::Get,
                                     ProcedureSource::FuncPut => Method::Put,
                                     ProcedureSource::FuncFires => Method::Fires,
                                     ProcedureSource::FuncCreate => Method::Create,
                                     ProcedureSource::FuncLength => Method::Length,
                                     ProcedureSource::FuncAssert => Method::Assert,
                                     ProcedureSource::FuncPrint => Method::Print,
                                     ProcedureSource::CompRandomU32 => Method::ComponentRandomU32,
                                     ProcedureSource::CompTcpClient => Method::ComponentTcpClient,
                                     ProcedureSource::CompTcpListener => Method::ComponentTcpListener,
                                     _ => todo!("other procedure sources"),
                                 };
                                 // Function call: consume the arguments
                                 let func_span = parser_type.full_span;
                                 let mut full_span = func_span;
                                 let arguments = self.consume_expression_list(
                                     module, iter, ctx, Some(&mut full_span.end)
                                 )?;
                                 ctx.heap.alloc_call_expression(|this| CallExpression{
                                     this, func_span, full_span, parser_type, method, arguments,
                                     procedure: procedure_id,
                                     parent: ExpressionParent::None,
                                     type_index: -1,
                                 }).upcast()
+                            }
+                        }
                     },
                     _ => {
                         return Err(ParseError::new_error_str_at_span(
                             &module.source, parser_type.full_span, "unexpected type in expression"
                         ))
+                    }
+                }
             } else {
                 // Check for builtin keywords or builtin functions
                 if ident_text == KW_LIT_NULL || ident_text == KW_LIT_TRUE || ident_text == KW_LIT_FALSE {
                     iter.consume();
                     // Parse builtin literal
                     let value = match ident_text {
                         KW_LIT_NULL => Literal::Null,
                         KW_LIT_TRUE => Literal::True,
                         KW_LIT_FALSE => Literal::False,
                         _ => unreachable!(),
                     };
                     ctx.heap.alloc_literal_expression(|this| LiteralExpression {
                         this,
                         span: ident_span,
                         value,
                         parent: ExpressionParent::None,
                         type_index: -1,
                     }).upcast()
                 } else if ident_text == KW_LET {
                     // Binding expression
                     let operator_span = iter.next_span();
                     iter.consume();
                     let bound_to = self.consume_prefix_expression(module, iter, ctx)?;
                     consume_token(&module.source, iter, TokenKind::Equal)?;
                     let bound_from = self.consume_prefix_expression(module, iter, ctx)?;
                     let full_span = InputSpan::from_positions(
                         operator_span.begin, ctx.heap[bound_from].full_span().end,
                     );
                     ctx.heap.alloc_binding_expression(|this| BindingExpression{
                         this, operator_span, full_span, bound_to, bound_from,
                         parent: ExpressionParent::None,
                         type_index: -1,
                     }).upcast()
                 } else if ident_text == KW_CAST {
                     // Casting expression
                     iter.consume();
                     let to_type = if Some(TokenKind::OpenAngle) == iter.next() {
                         let angle_start_pos = iter.next_start_position();
                         iter.consume();
                         let definition_id = self.cur_definition;
                         let poly_vars = ctx.heap[definition_id].poly_vars();
                         self.type_parser.consume_parser_type(
                             iter, &ctx.heap, &module.source, &ctx.symbols,
                             poly_vars, definition_id, SymbolScope::Module(module.root_id),
                             true, false, Some(angle_start_pos)
                         )?
                     } else {
                         // Automatic casting with inferred target type
                         ParserType{
                             elements: vec![ParserTypeElement{
                                 element_span: ident_span,
                                 variant: ParserTypeVariant::Inferred,
                             }],
                             full_span: ident_span
+                        }
                     };
                     consume_token(&module.source, iter, TokenKind::OpenParen)?;
                     let subject = self.consume_expression(module, iter, ctx)?;
                     let mut full_span = iter.next_span();
                     full_span.begin = to_type.full_span.begin;
                     consume_token(&module.source, iter, TokenKind::CloseParen)?;
                     ctx.heap.alloc_cast_expression(|this| CastExpression{
                         this,
                         cast_span: to_type.full_span,
                         full_span, to_type, subject,
                         parent: ExpressionParent::None,
                         type_index: -1,
                     }).upcast()
                 } else {
                     // Not a builtin literal, but also not a known type. So we
                     // assume it is a variable expression. Although if we do,
                     // then if a programmer mistyped a struct/function name the
                     // error messages will be rather cryptic. For polymorphic
                     // arguments we can't really do anything at all (because it
                     // uses the '<' token). In the other cases we try to provide
                     // a better error message.
                     iter.consume();
                     let next = iter.next();
                     if Some(TokenKind::ColonColon) == next {
                         return Err(ParseError::new_error_str_at_span(&module.source, ident_span, "unknown identifier"));
                     } else if Some(TokenKind::OpenParen) == next {
                         return Err(ParseError::new_error_str_at_span(
                             &module.source, ident_span,
                             "unknown identifier, did you mistype a union variant's, component's, or function's name?"
                         ));
                     } else if Some(TokenKind::OpenCurly) == next {
                         return Err(ParseError::new_error_str_at_span(
                             &module.source, ident_span,
                             "unknown identifier, did you mistype a struct type's name?"
                         ))
+                    }
                     let ident_text = ctx.pool.intern(ident_text);
                     let identifier = Identifier { span: ident_span, value: ident_text };
                     ctx.heap.alloc_variable_expression(|this| VariableExpression {
                         this,
                         identifier,
                         declaration: None,
                         used_as_binding_target: false,
                         parent: ExpressionParent::None,
                         type_index: -1,
                     }).upcast()
+                }
+            }
         } else {
             return Err(ParseError::new_error_str_at_pos(
                 &module.source, iter.last_valid_pos(), "expected an expression"
             ));
         };
         Ok(result)
+    }
     //--------------------------------------------------------------------------
     // Expression Utilities
     //--------------------------------------------------------------------------
     #[inline]
     fn consume_generic_binary_expression<
         M: Fn(Option<TokenKind>) -> Option<BinaryOperator>,
         F: Fn(&mut PassDefinitions, &Module, &mut TokenIter, &mut PassCtx) -> Result<ExpressionId, ParseError>
     >(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, match_fn: M, higher_precedence_fn: F
     ) -> Result<ExpressionId, ParseError> {
         let mut result = higher_precedence_fn(self, module, iter, ctx)?;
         while let Some(operation) = match_fn(iter.next()) {
             let operator_span = iter.next_span();
             iter.consume();
             let left = result;
             let right = higher_precedence_fn(self, module, iter, ctx)?;
             let full_span = InputSpan::from_positions(
                 ctx.heap[left].full_span().begin,
                 ctx.heap[right].full_span().end,
             );
             result = ctx.heap.alloc_binary_expression(|this| BinaryExpression{
                 this, operator_span, full_span, left, operation, right,
                 parent: ExpressionParent::None,
                 type_index: -1,
             }).upcast();
+        }
         Ok(result)
+    }
     #[inline]
     fn consume_expression_list(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, end_pos: Option<&mut InputPosition>
     ) -> Result<Vec<ExpressionId>, ParseError> {
         let mut section = self.expressions.start_section();
         consume_comma_separated(
             TokenKind::OpenParen, TokenKind::CloseParen, &module.source, iter, ctx,
             |_source, iter, ctx| self.consume_expression(module, iter, ctx),
             &mut section, "an expression", "a list of expressions", end_pos
         )?;
         Ok(section.into_vec())
+    }
+}
 /// Consumes polymorphic variables and throws them on the floor.
 fn consume_polymorphic_vars_spilled(source: &InputSource, iter: &mut TokenIter, _ctx: &mut PassCtx) -> Result<(), ParseError> {
     maybe_consume_comma_separated_spilled(
         TokenKind::OpenAngle, TokenKind::CloseAngle, source, iter, _ctx,
         |source, iter, _ctx| {
             consume_ident(source, iter)?;
             Ok(())
         }, "a polymorphic variable"
     )?;
     Ok(())
+}
 /// Consumes the parameter list to functions/components
 fn consume_parameter_list(
     parser: &mut ParserTypeParser, source: &InputSource, iter: &mut TokenIter,
     ctx: &mut PassCtx, target: &mut ScopedSection<VariableId>,
     scope: SymbolScope, definition_id: DefinitionId, allow_compiler_types: bool
 ) -> Result<(), ParseError> {
     consume_comma_separated(
         TokenKind::OpenParen, TokenKind::CloseParen, source, iter, ctx,
         |source, iter, ctx| {
             let poly_vars = ctx.heap[definition_id].poly_vars(); // Rust being rust, multiple lookups
             let parser_type = parser.consume_parser_type(
                 iter, &ctx.heap, source, &ctx.symbols, poly_vars, definition_id,
                 scope, false, allow_compiler_types, None
             )?;
             let identifier = consume_ident_interned(source, iter, ctx)?;
             let parameter_id = ctx.heap.alloc_variable(|this| Variable{
                 this,
                 kind: VariableKind::Parameter,
                 parser_type,
                 identifier,
                 relative_pos_in_parent: 0,
                 unique_id_in_scope: -1,
             });
             Ok(parameter_id)
         },
         target, "a parameter", "a parameter list", None
+    )
+}
@@ \ No newline at end of file @@

src/protocol/parser/pass_symbols.rs

➞

Show inline comments

 use crate::protocol::ast::*;
 use super::symbol_table::*;
 use crate::protocol::input_source::{ParseError, InputSpan};
 use super::tokens::*;
 use super::token_parsing::*;
 use super::{Module, ModuleCompilationPhase, PassCtx};
 /// Scans the module and finds all module-level type definitions. These will be
 /// added to the symbol table such that during AST-construction we know which
 /// identifiers point to types. Will also parse all pragmas to determine module
 /// names.
 pub(crate) struct PassSymbols {
     symbols: Vec<Symbol>,
     pragmas: Vec<PragmaId>,
     imports: Vec<ImportId>,
     definitions: Vec<DefinitionId>,
     buffer: String,
     has_pragma_version: bool,
     has_pragma_module: bool,
+}
 impl PassSymbols {
     pub(crate) fn new() -> Self {
         Self{
             symbols: Vec::with_capacity(128),
             pragmas: Vec::with_capacity(8),
             imports: Vec::with_capacity(32),
             definitions: Vec::with_capacity(128),
             buffer: String::with_capacity(128),
             has_pragma_version: false,
             has_pragma_module: false,
+        }
+    }
     fn reset(&mut self) {
         self.symbols.clear();
         self.pragmas.clear();
         self.imports.clear();
         self.definitions.clear();
         self.has_pragma_version = false;
         self.has_pragma_module = false;
+    }
     pub(crate) fn parse(&mut self, modules: &mut [Module], module_idx: usize, ctx: &mut PassCtx) -> Result<(), ParseError> {
         self.reset();
         let module = &mut modules[module_idx];
         let add_to_global_namespace = module.add_to_global_namespace;
         debug_assert_eq!(module.phase, ModuleCompilationPhase::Tokenized);
         debug_assert!(module.root_id.is_invalid()); // not set yet
         // Preallocate root in the heap
         let root_id = ctx.heap.alloc_protocol_description(|this| {
             Root{
                 this,
                 pragmas: Vec::new(),
                 imports: Vec::new(),
                 definitions: Vec::new(),
+            }
         });
         module.root_id = root_id;
         // Use pragma token markers to detects symbol definitions and pragmas
         let num_markers = module.tokens.markers.len();
         for marker_index in 0..num_markers {
             let module = &modules[module_idx];
             let marker = &module.tokens.markers[marker_index];
             // Parse if it is a definition or a pragma
             match marker.kind {
                 TokenMarkerKind::Pragma => {
                     self.visit_pragma_marker(modules, module_idx, ctx, marker_index)?;
                 },
                 TokenMarkerKind::Definition => {
                     self.visit_definition_marker(modules, module_idx, ctx, marker_index)?;
+                }
                 TokenMarkerKind::Import => {}, // we don't care yet
+            }
+        }
         // Add the module's symbol scope and the symbols we just parsed
         let module_scope = SymbolScope::Module(root_id);
         ctx.symbols.insert_scope(Some(SymbolScope::Global), module_scope);
         for symbol in self.symbols.drain(..) {
             ctx.symbols.insert_scope(Some(module_scope), SymbolScope::Definition(symbol.variant.as_definition().definition_id));
             if let Err((new_symbol, old_symbol)) = ctx.symbols.insert_symbol(module_scope, symbol) {
                 return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, &old_symbol))
+            }
+        }
         if add_to_global_namespace {
             debug_assert!(self.symbols.is_empty());
             ctx.symbols.get_all_symbols_defined_in_scope(module_scope, &mut self.symbols);
             for symbol in self.symbols.drain(..) {
                 ctx.symbols.insert_symbol_in_global_scope(symbol);
+            }
+        }
         // Modify the preallocated root
         let root = &mut ctx.heap[root_id];
         root.pragmas.extend(self.pragmas.drain(..));
         root.definitions.extend(self.definitions.drain(..));
         // Modify module
         let module = &mut modules[module_idx];
         module.phase = ModuleCompilationPhase::SymbolsScanned;
         Ok(())
+    }
     fn visit_pragma_marker(&mut self, modules: &mut [Module], module_idx: usize, ctx: &mut PassCtx, marker_index: usize) -> Result<(), ParseError> {
         let module = &mut modules[module_idx];
         let marker = &module.tokens.markers[marker_index];
         let mut iter = module.tokens.iter_range(marker.first_token, None);
         // Consume pragma name
         let (pragma_section, mut pragma_span) = consume_pragma(&module.source, &mut iter)?;
         // Consume pragma values
         if pragma_section == b"#module" {
             // Check if name is defined twice within the same file
             if self.has_pragma_module {
                 return Err(ParseError::new_error_str_at_span(&module.source, pragma_span, "module name is defined twice"));
+            }
             // Consume the domain-name, then record end of pragma
             let (module_name, module_span) = consume_domain_ident(&module.source, &mut iter)?;
             let marker_last_token = iter.token_index();
             // Add to heap and symbol table
             pragma_span.end = module_span.end;
             let module_name = ctx.pool.intern(module_name);
             let pragma_id = ctx.heap.alloc_pragma(|this| Pragma::Module(PragmaModule{
                 this,
                 span: pragma_span,
                 value: Identifier{ span: module_span, value: module_name.clone() },
             }));
             self.pragmas.push(pragma_id);
             if let Err(other_module_root_id) = ctx.symbols.insert_module(module_name.clone(), module.root_id) {
                 // Naming conflict
                 let this_module = &modules[module_idx];
                 let other_module = seek_module(modules, other_module_root_id).unwrap();
                 let other_module_pragma_id = other_module.name.as_ref().map(|v| (*v).0).unwrap();
                 let other_pragma = ctx.heap[other_module_pragma_id].as_module();
                 return Err(ParseError::new_error_str_at_span(
                     &this_module.source, pragma_span, "conflict in module name"
                 ).with_info_str_at_span(
                     &other_module.source, other_pragma.span, "other module is defined here"
                 ));
+            }
             let marker = &mut module.tokens.markers[marker_index];
             marker.last_token = marker_last_token;
             marker.handled = true;
             module.name = Some((pragma_id, module_name));
             self.has_pragma_module = true;
         } else if pragma_section == b"#version" {
             // Check if version is defined twice within the same file
             if self.has_pragma_version {
                 return Err(ParseError::new_error_str_at_span(&module.source, pragma_span, "module version is defined twice"));
+            }
             // Consume the version pragma
             let (version, version_span) = consume_integer_literal(&module.source, &mut iter, &mut self.buffer)?;
             let marker_last_token = iter.token_index();
             pragma_span.end = version_span.end;
             let pragma_id = ctx.heap.alloc_pragma(|this| Pragma::Version(PragmaVersion{
                 this,
                 span: pragma_span,
                 version,
             }));
             self.pragmas.push(pragma_id);
             let marker = &mut module.tokens.markers[marker_index];
             marker.last_token = marker_last_token;
             marker.handled = true;
             module.version = Some((pragma_id, version as i64));
             self.has_pragma_version = true;
         } // else: custom pragma used for something else, will be handled later (or rejected with an error)
         Ok(())
+    }
     fn visit_definition_marker(&mut self, modules: &[Module], module_idx: usize, ctx: &mut PassCtx, marker_index: usize) -> Result<(), ParseError> {
         let module = &modules[module_idx];
         let marker = &module.tokens.markers[marker_index];
         let mut iter = module.tokens.iter_range(marker.first_token, None);
         // First ident must be type of symbol
         let (kw_text, _) = consume_any_ident(&module.source, &mut iter).unwrap();
         // Retrieve identifier of definition
         let identifier = consume_ident_interned(&module.source, &mut iter, ctx)?;
         let mut poly_vars = Vec::new();
         maybe_consume_comma_separated(
             TokenKind::OpenAngle, TokenKind::CloseAngle, &module.source, &mut iter, ctx,
             |source, iter, ctx| consume_ident_interned(source, iter, ctx),
             &mut poly_vars, "a polymorphic variable", None
         )?;
         let ident_text = identifier.value.clone(); // because we need it later
         let ident_span = identifier.span.clone();
         // Reserve space in AST for definition and add it to the symbol table
         let definition_class;
         let ast_definition_id;
         match kw_text {
             KW_STRUCT => {
                 let struct_def_id = ctx.heap.alloc_struct_definition(|this| {
                     StructDefinition::new_empty(this, module.root_id, identifier, poly_vars)
                 });
                 definition_class = DefinitionClass::Struct;
                 ast_definition_id = struct_def_id.upcast();
             },
             KW_ENUM => {
                 let enum_def_id = ctx.heap.alloc_enum_definition(|this| {
                     EnumDefinition::new_empty(this, module.root_id, identifier, poly_vars)
                 });
                 definition_class = DefinitionClass::Enum;
                 ast_definition_id = enum_def_id.upcast();
             },
             KW_UNION => {
                 let union_def_id = ctx.heap.alloc_union_definition(|this| {
                     UnionDefinition::new_empty(this, module.root_id, identifier, poly_vars)
                 });
                 definition_class = DefinitionClass::Union;
                 ast_definition_id = union_def_id.upcast()
             },
             KW_FUNCTION => {
                 let proc_def_id = ctx.heap.alloc_procedure_definition(|this| {
                     ProcedureDefinition::new_empty(this, module.root_id, ProcedureKind::Function, identifier, poly_vars)
                 });
                 definition_class = DefinitionClass::Function;
                 ast_definition_id = proc_def_id.upcast();
             },
             KW_PRIMITIVE | KW_COMPOSITE => {
                 let procedure_kind = if kw_text == KW_PRIMITIVE {
                     ProcedureKind::Primitive
                 } else {
                     ProcedureKind::Composite
                 };
             KW_COMPONENT => {
                 let proc_def_id = ctx.heap.alloc_procedure_definition(|this| {
-                    ProcedureDefinition::new_empty(this, module.root_id, procedure_kind, identifier, poly_vars)
+                    ProcedureDefinition::new_empty(this, module.root_id, ProcedureKind::Component, identifier, poly_vars)
                 });
                 definition_class = DefinitionClass::Component;
                 ast_definition_id = proc_def_id.upcast();
             },
             _ => unreachable!("encountered keyword '{}' in definition range", String::from_utf8_lossy(kw_text)),
+        }
         let symbol = Symbol{
             name: ident_text,
             variant: SymbolVariant::Definition(SymbolDefinition{
                 defined_in_module: module.root_id,
                 defined_in_scope: SymbolScope::Module(module.root_id),
                 identifier_span: ident_span,
                 imported_at: None,
                 class: definition_class,
                 definition_id: ast_definition_id,
             }),
         };
         self.symbols.push(symbol);
         self.definitions.push(ast_definition_id);
         Ok(())
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/pass_tokenizer.rs

➞

Show inline comments

@@ @@ -242,445 +242,444 @@ impl PassTokenizer { @@
             } else {
                 token_kind = TokenKind::OpenAngle;
+            }
         } else if first_char == b'=' {
             source.consume();
             if let Some(b'=') = source.next() {
                 source.consume();
                 token_kind = TokenKind::EqualEqual;
             } else {
                 token_kind = TokenKind::Equal;
+            }
         } else if first_char == b'>' {
             source.consume();
             let next = source.next();
             if Some(b'>') == next {
                 source.consume();
                 if Some(b'=') == source.next() {
                     source.consume();
                     token_kind = TokenKind::ShiftRightEquals;
                 } else {
                     token_kind = TokenKind::ShiftRight;
+                }
             } else if Some(b'=') == next {
                 source.consume();
                 token_kind = TokenKind::GreaterEquals;
             } else {
                 token_kind = TokenKind::CloseAngle;
+            }
         } else if first_char == b'?' {
             source.consume();
             token_kind = TokenKind::Question;
         } else if first_char == b'@' {
             source.consume();
             if let Some(b'=') = source.next() {
                 source.consume();
                 token_kind = TokenKind::AtEquals;
             } else {
                 token_kind = TokenKind::At;
+            }
         } else if first_char == b'[' {
             source.consume();
             token_kind = TokenKind::OpenSquare;
         } else if first_char == b']' {
             source.consume();
             token_kind = TokenKind::CloseSquare;
         } else if first_char == b'^' {
             source.consume();
             if let Some(b'=') = source.next() {
                 source.consume();
                 token_kind = TokenKind::CaretEquals;
             } else {
                 token_kind = TokenKind::Caret;
+            }
         } else if first_char == b'{' {
             source.consume();
             token_kind = TokenKind::OpenCurly;
         } else if first_char == b'|' {
             source.consume();
             let next = source.next();
             if Some(b'|') == next {
                 source.consume();
                 token_kind = TokenKind::OrOr;
             } else if Some(b'=') == next {
                 source.consume();
                 token_kind = TokenKind::OrEquals;
             } else {
                 token_kind = TokenKind::Or;
+            }
         } else if first_char == b'}' {
             source.consume();
             token_kind = TokenKind::CloseCurly;
         } else if first_char == b'~' {
             source.consume();
             token_kind = TokenKind::Tilde;
         } else {
             self.check_ascii(source)?;
             return Ok(None);
+        }
         target.tokens.push(Token::new(token_kind, pos));
         Ok(Some((token_kind, pos)))
+    }
     fn consume_char_literal(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {
         let begin_pos = source.pos();
         // Consume the leading quote
         debug_assert!(source.next().unwrap() == b'\'');
         source.consume();
         let mut prev_char = b'\'';
         while let Some(c) = source.next() {
             if !c.is_ascii() {
                 return Err(ParseError::new_error_str_at_pos(source, source.pos(), "non-ASCII character in char literal"));
+            }
             source.consume();
             // Make sure ending quote was not escaped
             if c == b'\'' && prev_char != b'\\' {
                 prev_char = c;
                 break;
+            }
             prev_char = c;
+        }
         if prev_char != b'\'' {
             // Unterminated character literal, reached end of file.
             return Err(ParseError::new_error_str_at_pos(source, begin_pos, "encountered unterminated character literal"));
+        }
         let end_pos = source.pos();
         target.tokens.push(Token::new(TokenKind::Character, begin_pos));
         target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
         Ok(())
+    }
     fn consume_bytestring_literal(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {
         let begin_pos = source.pos();
         debug_assert!(source.next().unwrap() == b'b');
         source.consume();
         let end_pos = self.consume_ascii_string(begin_pos, source)?;
         target.tokens.push(Token::new(TokenKind::Bytestring, begin_pos));
         target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
         Ok(())
+    }
     fn consume_string_literal(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {
         let begin_pos = source.pos();
         let end_pos = self.consume_ascii_string(begin_pos, source)?;
         target.tokens.push(Token::new(TokenKind::String, begin_pos));
         target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
         Ok(())
+    }
     fn consume_pragma_or_pound(&mut self, first_char: u8, source: &mut InputSource, target: &mut TokenBuffer) -> Result<bool, ParseError> {
         let start_pos = source.pos();
         debug_assert_eq!(first_char, b'#');
         source.consume();
         let next = source.next();
         if next.is_none() || !is_identifier_start(next.unwrap()) {
             // Just a pound sign
             target.tokens.push(Token::new(TokenKind::Pound, start_pos));
             Ok(false)
         } else {
             // Pound sign followed by identifier
             source.consume();
             while let Some(c) = source.next() {
                 if !is_identifier_remaining(c) {
                     break;
+                }
                 source.consume();
+            }
             self.check_ascii(source)?;
             let end_pos = source.pos();
             target.tokens.push(Token::new(TokenKind::Pragma, start_pos));
             target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
             Ok(true)
+        }
+    }
     fn consume_line_comment(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {
         let begin_pos = source.pos();
         // Consume the leading "//"
         debug_assert!(source.next().unwrap() == b'/' && source.lookahead(1).unwrap() == b'/');
         source.consume();
         source.consume();
         let mut prev_char = b'/';
         let mut cur_char = b'/';
         while let Some(c) = source.next() {
             prev_char = cur_char;
             cur_char = c;
             if c == b'\n' {
                 // End of line, note that the newline is not consumed
                 break;
+            }
             source.consume();
+        }
         let mut end_pos = source.pos();
         debug_assert_eq!(begin_pos.line, end_pos.line);
         // Modify offset to not include the newline characters
         if cur_char == b'\n' {
             if prev_char == b'\r' {
                 end_pos.offset -= 1;
+            }
             // Consume final newline
             source.consume();
         } else {
             // End of comment was due to EOF
             debug_assert!(source.next().is_none())
+        }
         target.tokens.push(Token::new(TokenKind::LineComment, begin_pos));
         target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
         Ok(())
+    }
     fn consume_block_comment(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {
         let begin_pos = source.pos();
         // Consume the leading "/*"
         debug_assert!(source.next().unwrap() == b'/' && source.lookahead(1).unwrap() == b'*');
         source.consume();
         source.consume();
         // Explicitly do not put prev_char at "*", because then "/*/" would
         // represent a valid and closed block comment
         let mut prev_char = b' ';
         let mut is_closed = false;
         while let Some(c) = source.next() {
             source.consume();
             if prev_char == b'*' && c == b'/' {
                 // End of block comment
                 is_closed = true;
                 break;
+            }
             prev_char = c;
+        }
         if !is_closed {
             return Err(ParseError::new_error_str_at_pos(
                 source, source.pos(), "encountered unterminated block comment")
             );
+        }
         let end_pos = source.pos();
         target.tokens.push(Token::new(TokenKind::BlockComment, begin_pos));
         target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
         Ok(())
+    }
     fn consume_identifier<'a>(&mut self, source: &'a mut InputSource, target: &mut TokenBuffer) -> Result<&'a [u8], ParseError> {
         let begin_pos = source.pos();
         debug_assert!(is_identifier_start(source.next().unwrap()));
         source.consume();
         // Keep reading until no more identifier
         while let Some(c) = source.next() {
             if !is_identifier_remaining(c) {
                 break;
+            }
             source.consume();
+        }
         self.check_ascii(source)?;
         let end_pos = source.pos();
         target.tokens.push(Token::new(TokenKind::Ident, begin_pos));
         target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
         Ok(source.section_at_pos(begin_pos, end_pos))
+    }
     fn consume_number(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {
         let begin_pos = source.pos();
         debug_assert!(is_integer_literal_start(source.next().unwrap()));
         source.consume();
         // Keep reading until it doesn't look like a number anymore
         while let Some(c) = source.next() {
             if !maybe_number_remaining(c) {
                 break;
+            }
             source.consume();
+        }
         self.check_ascii(source)?;
         let end_pos = source.pos();
         target.tokens.push(Token::new(TokenKind::Integer, begin_pos));
         target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
         Ok(())
+    }
     // Consumes the ascii string (including leading and trailing quotation
     // marks) and returns the input position *after* the last quotation mark (or
     // an error, if something went wrong).
     fn consume_ascii_string(&self, begin_pos: InputPosition, source: &mut InputSource) -> Result<InputPosition, ParseError> {
         debug_assert!(source.next().unwrap() == b'"');
         source.consume();
         let mut prev_char = b'"';
         while let Some(c) = source.next() {
             if !c.is_ascii() {
                 return Err(ParseError::new_error_str_at_pos(source, source.pos(), "non-ASCII character in string literal"));
+            }
             source.consume();
             if c == b'"' && prev_char != b'\\' {
                 // Unescaped string terminator
                 prev_char = c;
                 break;
+            }
             if prev_char == b'\\' && c == b'\\' {
                 // Escaped backslash, set prev_char to bogus to not conflict
                 // with escaped-" and unterminated string literal detection.
                 prev_char = b'\0';
             } else {
                 prev_char = c;
+            }
+        }
         if prev_char != b'"' {
             // Unterminated string literal
             return Err(ParseError::new_error_str_at_pos(source, begin_pos, "encountered unterminated string literal"));
+        }
         let end_pos = source.pos();
         return Ok(end_pos)
+    }
     // Consumes whitespace and returns whether or not the whitespace contained
     // a newline.
     fn consume_whitespace(&self, source: &mut InputSource) -> bool {
         debug_assert!(is_whitespace(source.next().unwrap()));
         let mut has_newline = false;
         while let Some(c) = source.next() {
             if !is_whitespace(c) {
                 break;
+            }
             if c == b'\n' {
                 has_newline = true;
+            }
             source.consume();
+        }
         has_newline
+    }
     fn emit_marker(&mut self, target: &mut TokenBuffer, kind: TokenMarkerKind, first_token: u32) {
         debug_assert!(
             target.markers
                 .last().map(|v| v.first_token < first_token)
                 .unwrap_or(true)
         );
         target.markers.push(TokenMarker{
             kind,
             curly_depth: self.curly_stack.len() as u32,
             first_token,
             last_token: u32::MAX,
             handled: false,
         });
+    }
     fn check_ascii(&self, source: &InputSource) -> Result<(), ParseError> {
         match source.next() {
             Some(c) if !c.is_ascii() => {
                 Err(ParseError::new_error_str_at_pos(source, source.pos(), "encountered a non-ASCII character"))
             },
             _else => {
                 Ok(())
             },
+        }
+    }
+}
 // Helpers for characters
 fn demarks_symbol(ident: &[u8]) -> bool {
     return
         ident == KW_STRUCT ||
             ident == KW_ENUM ||
             ident == KW_UNION ||
             ident == KW_FUNCTION ||
             ident == KW_PRIMITIVE ||
             ident == KW_COMPOSITE
             ident == KW_COMPONENT
+}
 #[inline]
 fn demarks_import(ident: &[u8]) -> bool {
     return ident == KW_IMPORT;
+}
 #[inline]
 fn is_whitespace(c: u8) -> bool {
     c.is_ascii_whitespace()
+}
 #[inline]
 fn is_char_literal_start(c: u8) -> bool {
     return c == b'\'';
+}
 #[inline]
 fn is_bytestring_literal_start(c: u8, source: &InputSource) -> bool {
     return c == b'b' && source.lookahead(1) == Some(b'"');
+}
 #[inline]
 fn is_string_literal_start(c: u8) -> bool {
     return c == b'"';
+}
 #[inline]
 fn is_pragma_start_or_pound(c: u8) -> bool {
     return c == b'#';
+}
 fn is_identifier_start(c: u8) -> bool {
     return
         (c >= b'a' && c <= b'z') ||
             (c >= b'A' && c <= b'Z') ||
             c == b'_'
+}
 fn is_identifier_remaining(c: u8) -> bool {
     return
         (c >= b'0' && c <= b'9') ||
             (c >= b'a' && c <= b'z') ||
             (c >= b'A' && c <= b'Z') ||
             c == b'_'
+}
 #[inline]
 fn is_integer_literal_start(c: u8) -> bool {
     return c >= b'0' && c <= b'9';
+}
 fn maybe_number_remaining(c: u8) -> bool {
     // Note: hex range includes the possible binary indicator 'b' and 'B';
     return
         (c == b'o' || c == b'O' || c == b'x' || c == b'X') ||
             (c >= b'0' && c <= b'9') || (c >= b'A' && c <= b'F') || (c >= b'a' && c <= b'f') ||
             c == b'_';
+}

src/protocol/parser/pass_validation_linking.rs

➞

Show inline comments

@@ @@ -19,1556 +19,1544 @@ @@
  * child will look at this "parent expression" field to determine its parent.
+ *
  * Setting the `next` statement: the AST is a tree, but during execution we walk
  * a linear path through all statements. So where appropriate a statement may
  * set the "previous statement" field of the pass to itself. When visiting the
  * subsequent statement it will check this "previous statement", and if set, it
  * will link this previous statement up to itself. Not every statement has a
  * previous statement. Hence there are two patterns that occur: assigning the
  * `next` value, then clearing the "previous statement" field. And assigning the
  * `next` value, and then putting the current statement's ID in the "previous
  * statement" field. Because it is so common, this file contain two macros that
  * perform that operation.
+ *
  * To make storing types for polymorphic procedures simpler and more efficient,
  * we assign to each expression in the procedure a unique ID. This is what the
  * "next expression index" field achieves. Each expression simply takes the
  * current value, and then increments this counter.
  */
 use crate::collections::{ScopedBuffer};
 use crate::protocol::ast::*;
 use crate::protocol::input_source::*;
 use crate::protocol::parser::symbol_table::*;
 use crate::protocol::parser::type_table::*;
 use super::visitor::{
     BUFFER_INIT_CAP_SMALL,
     BUFFER_INIT_CAP_LARGE,
     Ctx,
     Visitor,
     VisitorResult
 };
 use crate::protocol::parser::ModuleCompilationPhase;
 struct ControlFlowStatement {
     in_sync: SynchronousStatementId,
     in_while: WhileStatementId,
     in_scope: ScopeId,
     statement: StatementId, // of 'break', 'continue' or 'goto'
+}
 /// This particular visitor will go through the entire AST in a recursive manner
 /// and check if all statements and expressions are legal (e.g. no "return"
 /// statements in component definitions), and will link certain AST nodes to
 /// their appropriate targets (e.g. goto statements, or function calls).
 ///
 /// This visitor will not perform control-flow analysis (e.g. making sure that
 /// each function actually returns) and will also not perform type checking. So
 /// the linking of function calls and component instantiations will be checked
 /// and linked to the appropriate definitions, but the return types and/or
 /// arguments will not be checked for validity.
 ///
 /// The main idea is, because we're visiting nodes in a tree, to do as much as
 /// we can while we have the memory in cache.
 pub(crate) struct PassValidationLinking {
     // Traversal state, all valid IDs if inside a certain AST element. Otherwise
     // `id.is_invalid()` returns true.
     in_sync: SynchronousStatementId,
     in_while: WhileStatementId, // to resolve labeled continue/break
     in_select_guard: SelectStatementId, // for detection/rejection of builtin calls
     in_select_arm: u32,
     in_test_expr: StatementId, // wrapping if/while stmt id
     in_binding_expr: BindingExpressionId, // to resolve variable expressions
     in_binding_expr_lhs: bool,
     // Traversal state, current scope (which can be used to find the parent
     // scope) and the definition variant we are considering.
     cur_scope: ScopeId,
     proc_id: ProcedureDefinitionId,
     proc_kind: ProcedureKind,
     // "Trailing" traversal state, set be child/prev stmt/expr used by next one
     prev_stmt: StatementId,
     expr_parent: ExpressionParent,
     // Set by parent to indicate that child expression must be assignable. The
     // child will throw an error if it is not assignable. The stored span is
     // used for the error's position
     must_be_assignable: Option<InputSpan>,
     // Keeping track of relative positions and unique IDs.
     relative_pos_in_parent: i32, // of statements: to determine when variables are visible
     // Control flow statements that require label resolving
     control_flow_stmts: Vec<ControlFlowStatement>,
     // Various temporary buffers for traversal. Essentially working around
     // Rust's borrowing rules since it cannot understand we're modifying AST
     // members but not the AST container.
     variable_buffer: ScopedBuffer<VariableId>,
     definition_buffer: ScopedBuffer<DefinitionId>,
     statement_buffer: ScopedBuffer<StatementId>,
     expression_buffer: ScopedBuffer<ExpressionId>,
     scope_buffer: ScopedBuffer<ScopeId>,
+}
 impl PassValidationLinking {
     pub(crate) fn new() -> Self {
         Self{
             in_sync: SynchronousStatementId::new_invalid(),
             in_while: WhileStatementId::new_invalid(),
             in_select_guard: SelectStatementId::new_invalid(),
             in_select_arm: 0,
             in_test_expr: StatementId::new_invalid(),
             in_binding_expr: BindingExpressionId::new_invalid(),
             in_binding_expr_lhs: false,
             cur_scope: ScopeId::new_invalid(),
             prev_stmt: StatementId::new_invalid(),
             expr_parent: ExpressionParent::None,
             proc_id: ProcedureDefinitionId::new_invalid(),
             proc_kind: ProcedureKind::Function,
             must_be_assignable: None,
             relative_pos_in_parent: 0,
             control_flow_stmts: Vec::with_capacity(BUFFER_INIT_CAP_SMALL),
             variable_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),
             definition_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),
             statement_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_LARGE),
             expression_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_LARGE),
             scope_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),
+        }
+    }
     fn reset_state(&mut self) {
         self.in_sync = SynchronousStatementId::new_invalid();
         self.in_while = WhileStatementId::new_invalid();
         self.in_select_guard = SelectStatementId::new_invalid();
         self.in_test_expr = StatementId::new_invalid();
         self.in_binding_expr = BindingExpressionId::new_invalid();
         self.in_binding_expr_lhs = false;
         self.cur_scope = ScopeId::new_invalid();
         self.proc_id = ProcedureDefinitionId::new_invalid();
         self.proc_kind = ProcedureKind::Function;
         self.prev_stmt = StatementId::new_invalid();
         self.expr_parent = ExpressionParent::None;
         self.must_be_assignable = None;
         self.relative_pos_in_parent = 0;
         self.control_flow_stmts.clear();
+    }
+}
 macro_rules! assign_then_erase_next_stmt {
     ($self:ident, $ctx:ident, $stmt_id:expr) => {
         if !$self.prev_stmt.is_invalid() {
             $ctx.heap[$self.prev_stmt].link_next($stmt_id);
             $self.prev_stmt = StatementId::new_invalid();
+        }
+    }
+}
 macro_rules! assign_and_replace_next_stmt {
     ($self:ident, $ctx:ident, $stmt_id:expr) => {
         if !$self.prev_stmt.is_invalid() {
             $ctx.heap[$self.prev_stmt].link_next($stmt_id);
+        }
         $self.prev_stmt = $stmt_id;
+    }
+}
 impl Visitor for PassValidationLinking {
     fn visit_module(&mut self, ctx: &mut Ctx) -> VisitorResult {
         debug_assert_eq!(ctx.module().phase, ModuleCompilationPhase::TypesAddedToTable);
         let root = &ctx.heap[ctx.module().root_id];
         let section = self.definition_buffer.start_section_initialized(&root.definitions);
         for definition_id in section.iter_copied() {
             self.visit_definition(ctx, definition_id)?;
+        }
         section.forget();
         ctx.module_mut().phase = ModuleCompilationPhase::ValidatedAndLinked;
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Definition visitors
     //--------------------------------------------------------------------------
     fn visit_procedure_definition(&mut self, ctx: &mut Ctx, id: ProcedureDefinitionId) -> VisitorResult {
         self.reset_state();
         let definition = &ctx.heap[id];
         self.proc_id = id;
         self.proc_kind = definition.kind;
         self.expr_parent = ExpressionParent::None;
         // Visit parameters
         let scope_id = definition.scope;
         let old_scope = self.push_scope(ctx, true, scope_id);
         let definition = &ctx.heap[id];
         let body_id = definition.body;
         let definition_is_builtin = definition.source.is_builtin();
         let section = self.variable_buffer.start_section_initialized(&definition.parameters);
         for variable_idx in 0..section.len() {
             let variable_id = section[variable_idx];
             self.checked_at_single_scope_add_local(ctx, self.cur_scope, -1, variable_id)?;
+        }
         section.forget();
         // Visit statements in function body, if present at all
         if !definition_is_builtin {
             self.visit_block_stmt(ctx, body_id)?;
+        }
         self.pop_scope(old_scope);
         self.resolve_pending_control_flow_targets(ctx)?;
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Statement visitors
     //--------------------------------------------------------------------------
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         // Get end of block
         let block_stmt = &ctx.heap[id];
         let end_block_id = block_stmt.end_block;
         let scope_id = block_stmt.scope;
         // Traverse statements in block
         let statement_section = self.statement_buffer.start_section_initialized(&block_stmt.statements);
         let old_scope = self.push_scope(ctx, false, scope_id);
         assign_and_replace_next_stmt!(self, ctx, id.upcast());
         for stmt_idx in 0..statement_section.len() {
             self.relative_pos_in_parent = stmt_idx as i32;
             self.visit_stmt(ctx, statement_section[stmt_idx])?;
+        }
         statement_section.forget();
         assign_and_replace_next_stmt!(self, ctx, end_block_id.upcast());
         self.pop_scope(old_scope);
         Ok(())
+    }
     fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {
         let stmt = &ctx.heap[id];
         let expr_id = stmt.initial_expr;
         let variable_id = stmt.variable;
         self.checked_add_local(ctx, self.cur_scope, self.relative_pos_in_parent, variable_id)?;
         assign_and_replace_next_stmt!(self, ctx, id.upcast().upcast());
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         self.expr_parent = ExpressionParent::Memory(id);
         self.visit_assignment_expr(ctx, expr_id)?;
         self.expr_parent = ExpressionParent::None;
         Ok(())
+    }
     fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {
         let stmt = &ctx.heap[id];
         let from_id = stmt.from;
         let to_id = stmt.to;
         self.checked_add_local(ctx, self.cur_scope, self.relative_pos_in_parent, from_id)?;
         self.checked_add_local(ctx, self.cur_scope, self.relative_pos_in_parent, to_id)?;
         assign_and_replace_next_stmt!(self, ctx, id.upcast().upcast());
         Ok(())
+    }
     fn visit_labeled_stmt(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> VisitorResult {
         let stmt = &ctx.heap[id];
         let body_id = stmt.body;
         self.checked_add_label(ctx, self.relative_pos_in_parent, self.in_sync, id)?;
         self.visit_stmt(ctx, body_id)?;
         Ok(())
+    }
     fn visit_if_stmt(&mut self, ctx: &mut Ctx, id: IfStatementId) -> VisitorResult {
         let if_stmt = &ctx.heap[id];
         let end_if_id = if_stmt.end_if;
         let test_expr_id = if_stmt.test;
         let true_case = if_stmt.true_case;
         let false_case = if_stmt.false_case;
         // Visit test expression
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         debug_assert!(self.in_test_expr.is_invalid());
         self.in_test_expr = id.upcast();
         self.expr_parent = ExpressionParent::If(id);
         self.visit_expr(ctx, test_expr_id)?;
         self.in_test_expr = StatementId::new_invalid();
         self.expr_parent = ExpressionParent::None;
         // Visit true and false branch. Executor chooses next statement based on
         // test expression, not on if-statement itself. Hence the if statement
         // does not have a static subsequent statement.
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         let old_scope = self.push_scope(ctx, false, true_case.scope);
         self.visit_stmt(ctx, true_case.body)?;
         self.pop_scope(old_scope);
         assign_then_erase_next_stmt!(self, ctx, end_if_id.upcast());
         if let Some(false_case) = false_case {
             let old_scope = self.push_scope(ctx, false, false_case.scope);
             self.visit_stmt(ctx, false_case.body)?;
             self.pop_scope(old_scope);
             assign_then_erase_next_stmt!(self, ctx, end_if_id.upcast());
+        }
         self.prev_stmt = end_if_id.upcast();
         Ok(())
+    }
     fn visit_while_stmt(&mut self, ctx: &mut Ctx, id: WhileStatementId) -> VisitorResult {
         let stmt = &ctx.heap[id];
         let end_while_id = stmt.end_while;
         let test_expr_id = stmt.test;
         let body_stmt_id = stmt.body;
         let scope_id = stmt.scope;
         let old_while = self.in_while;
         self.in_while = id;
         // Visit test expression
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         debug_assert!(self.in_test_expr.is_invalid());
         self.in_test_expr = id.upcast();
         self.expr_parent = ExpressionParent::While(id);
         self.visit_expr(ctx, test_expr_id)?;
         self.in_test_expr = StatementId::new_invalid();
         // Link up to body statement
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         self.expr_parent = ExpressionParent::None;
         let old_scope = self.push_scope(ctx, false, scope_id);
         self.visit_stmt(ctx, body_stmt_id)?;
         self.pop_scope(old_scope);
         self.in_while = old_while;
         // Link final entry in while's block statement back to the while. The
         // executor will go to the end-while statement if the test expression
         // is false, so put that in as the new previous stmt
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         self.prev_stmt = end_while_id.upcast();
         Ok(())
+    }
     fn visit_break_stmt(&mut self, ctx: &mut Ctx, id: BreakStatementId) -> VisitorResult {
         self.control_flow_stmts.push(ControlFlowStatement{
             in_sync: self.in_sync,
             in_while: self.in_while,
             in_scope: self.cur_scope,
             statement: id.upcast()
         });
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         Ok(())
+    }
     fn visit_continue_stmt(&mut self, ctx: &mut Ctx, id: ContinueStatementId) -> VisitorResult {
         self.control_flow_stmts.push(ControlFlowStatement{
             in_sync: self.in_sync,
             in_while: self.in_while,
             in_scope: self.cur_scope,
             statement: id.upcast()
         });
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         Ok(())
+    }
     fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {
         // Check for validity of synchronous statement
         let sync_stmt = &ctx.heap[id];
         let end_sync_id = sync_stmt.end_sync;
         let cur_sync_span = sync_stmt.span;
         let scope_id = sync_stmt.scope;
         if !self.in_sync.is_invalid() {
             // Nested synchronous statement
             let old_sync_span = ctx.heap[self.in_sync].span;
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, cur_sync_span, "Illegal nested synchronous statement"
             ).with_info_str_at_span(
                 &ctx.module().source, old_sync_span, "It is nested in this synchronous statement"
             ));
+        }
-        if self.proc_kind != ProcedureKind::Primitive {
+        if self.proc_kind != ProcedureKind::Component {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, cur_sync_span,
-                "synchronous statements may only be used in primitive components"
                 "synchronous statements may only be used in components"
             ));
+        }
         // Synchronous statement implicitly moves to its block
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         // Visit block statement. Note that we explicitly push the scope here
         // (and the `visit_block_stmt` will also push, but without effect) to
         // ensure the scope contains the sync ID.
         let sync_body = ctx.heap[id].body;
         debug_assert!(self.in_sync.is_invalid());
         self.in_sync = id;
         let old_scope = self.push_scope(ctx, false, scope_id);
         self.visit_stmt(ctx, sync_body)?;
         self.pop_scope(old_scope);
         assign_and_replace_next_stmt!(self, ctx, end_sync_id.upcast());
         self.in_sync = SynchronousStatementId::new_invalid();
         Ok(())
+    }
     fn visit_fork_stmt(&mut self, ctx: &mut Ctx, id: ForkStatementId) -> VisitorResult {
         let fork_stmt = &ctx.heap[id];
         let end_fork_id = fork_stmt.end_fork;
         let left_body_id = fork_stmt.left_body;
         let right_body_id = fork_stmt.right_body;
         // Fork statements may only occur inside sync blocks
         if self.in_sync.is_invalid() {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, fork_stmt.span,
                 "Forking may only occur inside sync blocks"
             ));
+        }
         // Visit the respective bodies. Like the if statement, a fork statement
         // does not have a single static subsequent statement. It forks and then
         // each fork has a different next statement.
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         self.visit_stmt(ctx, left_body_id)?;
         assign_then_erase_next_stmt!(self, ctx, end_fork_id.upcast());
         if let Some(right_body_id) = right_body_id {
             self.visit_stmt(ctx, right_body_id)?;
             assign_then_erase_next_stmt!(self, ctx, end_fork_id.upcast());
+        }
         self.prev_stmt = end_fork_id.upcast();
         Ok(())
+    }
     fn visit_select_stmt(&mut self, ctx: &mut Ctx, id: SelectStatementId) -> VisitorResult {
         let select_stmt = &mut ctx.heap[id];
         select_stmt.relative_pos_in_parent = self.relative_pos_in_parent;
         self.relative_pos_in_parent += 1;
         let select_stmt = &ctx.heap[id];
         let end_select_id = select_stmt.end_select;
         // Select statements may only occur inside sync blocks
         if self.in_sync.is_invalid() {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, select_stmt.span,
                 "select statements may only occur inside sync blocks"
             ));
+        }
-        if self.proc_kind != ProcedureKind::Primitive {
+        if self.proc_kind != ProcedureKind::Component {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, select_stmt.span,
-                "select statements may only be used in primitive components"
                 "select statements may only be used in components"
             ));
+        }
         // Visit the various arms in the select block
         let mut case_stmt_ids = self.statement_buffer.start_section();
         let mut case_scope_ids = self.scope_buffer.start_section();
         let num_cases = select_stmt.cases.len();
         for case in &select_stmt.cases {
             // We add them in pairs, so the subsequent for-loop retrieves in pairs
             case_stmt_ids.push(case.guard);
             case_stmt_ids.push(case.body);
             case_scope_ids.push(case.scope);
+        }
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         for index in 0..num_cases {
             let base_index = 2 * index;
             let guard_id     = case_stmt_ids[base_index];
             let case_body_id = case_stmt_ids[base_index + 1];
             let case_scope_id = case_scope_ids[index];
             // The guard statement ends up belonging to the block statement
             // following the arm. The reason we parse it separately is to
             // extract all of the "get" calls.
             let old_scope = self.push_scope(ctx, false, case_scope_id);
             // Visit the guard of this arm
             debug_assert!(self.in_select_guard.is_invalid());
             self.in_select_guard = id;
             self.in_select_arm = index as u32;
             self.visit_stmt(ctx, guard_id)?;
             self.in_select_guard = SelectStatementId::new_invalid();
             // Visit the code associated with the guard
             self.relative_pos_in_parent += 1;
             self.visit_stmt(ctx, case_body_id)?;
             self.pop_scope(old_scope);
             // Link up last statement in block to EndSelect
             assign_then_erase_next_stmt!(self, ctx, end_select_id.upcast());
+        }
         self.in_select_guard = SelectStatementId::new_invalid();
         self.prev_stmt = end_select_id.upcast();
         Ok(())
+    }
     fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {
         // Check if "return" occurs within a function
         let stmt = &ctx.heap[id];
         if self.proc_kind != ProcedureKind::Function {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, stmt.span,
                 "return statements may only appear in function bodies"
             ));
+        }
         // If here then we are within a function
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         debug_assert_eq!(ctx.heap[id].expressions.len(), 1);
         self.expr_parent = ExpressionParent::Return(id);
         self.visit_expr(ctx, ctx.heap[id].expressions[0])?;
         self.expr_parent = ExpressionParent::None;
         Ok(())
+    }
     fn visit_goto_stmt(&mut self, ctx: &mut Ctx, id: GotoStatementId) -> VisitorResult {
         self.control_flow_stmts.push(ControlFlowStatement{
             in_sync: self.in_sync,
             in_while: self.in_while,
             in_scope: self.cur_scope,
             statement: id.upcast(),
         });
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         Ok(())
+    }
     fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {
         // Make sure the new statement occurs inside a composite component
         if self.proc_kind != ProcedureKind::Composite {
         // Make sure the new statement occurs inside a component
         if self.proc_kind != ProcedureKind::Component {
             let new_stmt = &ctx.heap[id];
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, new_stmt.span,
-                "instantiating components may only be done in composite components"
                 "instantiating components may only be done in components"
             ));
+        }
         // Recurse into call expression (which will check the expression parent
         // to ensure that the "new" statment instantiates a component)
         let call_expr_id = ctx.heap[id].expression;
         assign_and_replace_next_stmt!(self, ctx, id.upcast());
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         self.expr_parent = ExpressionParent::New(id);
         self.visit_call_expr(ctx, call_expr_id)?;
         self.expr_parent = ExpressionParent::None;
         Ok(())
+    }
     fn visit_expr_stmt(&mut self, ctx: &mut Ctx, id: ExpressionStatementId) -> VisitorResult {
         let expr_id = ctx.heap[id].expression;
         assign_and_replace_next_stmt!(self, ctx, id.upcast());
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         self.expr_parent = ExpressionParent::ExpressionStmt(id);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = ExpressionParent::None;
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Expression visitors
     //--------------------------------------------------------------------------
     fn visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let assignment_expr = &mut ctx.heap[id];
         // Although we call assignment an expression to simplify the compiler's
         // code (mainly typechecking), we disallow nested use in expressions
         match self.expr_parent {
             // Look at us: lying through our teeth while providing error messages.
             ExpressionParent::Memory(_) => {},
             ExpressionParent::ExpressionStmt(_) => {},
             _ => {
                 let assignment_span = assignment_expr.full_span;
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, assignment_span,
                     "assignments are statements, and cannot be used in expressions"
                 ))
             },
+        }
         let left_expr_id = assignment_expr.left;
         let right_expr_id = assignment_expr.right;
         let old_expr_parent = self.expr_parent;
         assignment_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.must_be_assignable = Some(assignment_expr.operator_span);
         self.visit_expr(ctx, left_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.must_be_assignable = None;
         self.visit_expr(ctx, right_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_binding_expr(&mut self, ctx: &mut Ctx, id: BindingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         // Check for valid context of binding expression
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, span, "cannot assign to the result from a binding expression"
             ));
+        }
         if self.in_test_expr.is_invalid() {
             let binding_expr = &ctx.heap[id];
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, binding_expr.full_span,
                 "binding expressions can only be used inside the testing expression of 'if' and 'while' statements"
             ));
+        }
         if !self.in_binding_expr.is_invalid() {
             let binding_expr = &ctx.heap[id];
             let previous_expr = &ctx.heap[self.in_binding_expr];
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, binding_expr.full_span,
                 "nested binding expressions are not allowed"
             ).with_info_str_at_span(
                 &ctx.module().source, previous_expr.operator_span,
                 "the outer binding expression is found here"
             ));
+        }
         let mut seeking_parent = self.expr_parent;
         loop {
             // Perform upward search to make sure only LogicalAnd is applied to
             // the binding expression
             let valid = match seeking_parent {
                 ExpressionParent::If(_) | ExpressionParent::While(_) => {
                     // Every parent expression (if any) were LogicalAnd.
                     break;
+                }
                 ExpressionParent::Expression(parent_id, _) => {
                     let parent_expr = &ctx.heap[parent_id];
                     match parent_expr {
                         Expression::Binary(parent_expr) => {
                             // Set new parent to continue the search. Otherwise
                             // halt and provide an error using the current
                             // parent.
                             if parent_expr.operation == BinaryOperator::LogicalAnd {
                                 seeking_parent = parent_expr.parent;
                                 true
                             } else {
                                 false
+                            }
                         },
                         _ => false,
+                    }
                 },
                 _ => unreachable!(), // nested under if/while, so always expressions as parents
             };
             if !valid {
                 let binding_expr = &ctx.heap[id];
                 let parent_expr = &ctx.heap[seeking_parent.as_expression()];
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, binding_expr.full_span,
                     "only the logical-and operator (&&) may be applied to binding expressions"
                 ).with_info_str_at_span(
                     &ctx.module().source, parent_expr.operation_span(),
                     "this was the disallowed operation applied to the result from a binding expression"
                 ));
+            }
+        }
         // Perform all of the index/parent assignment magic
         let binding_expr = &mut ctx.heap[id];
         let old_expr_parent = self.expr_parent;
         binding_expr.parent = old_expr_parent;
         self.in_binding_expr = id;
         // Perform preliminary check on children: binding expressions only make
         // sense if the left hand side is just a variable expression, or if it
         // is a literal of some sort. The typechecker will take care of the rest
         let bound_to_id = binding_expr.bound_to;
         let bound_from_id = binding_expr.bound_from;
         match &ctx.heap[bound_to_id] {
             // Variables may not be binding variables, and literals may
             // actually not contain binding variables. But in that case we just
             // perform an equality check.
             Expression::Variable(_) => {}
             Expression::Literal(_) => {},
             _ => {
                 let binding_expr = &ctx.heap[id];
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, binding_expr.operator_span,
                     "the left hand side of a binding expression may only be a variable or a literal expression"
                 ));
             },
+        }
         // Visit the children themselves
         self.in_binding_expr_lhs = true;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, bound_to_id)?;
         self.in_binding_expr_lhs = false;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, bound_from_id)?;
         self.expr_parent = old_expr_parent;
         self.in_binding_expr = BindingExpressionId::new_invalid();
         Ok(())
+    }
     fn visit_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let conditional_expr = &mut ctx.heap[id];
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, span, "cannot assign to the result from a conditional expression"
             ))
+        }
         let test_expr_id = conditional_expr.test;
         let true_expr_id = conditional_expr.true_expression;
         let false_expr_id = conditional_expr.false_expression;
         let old_expr_parent = self.expr_parent;
         conditional_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, test_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, true_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 2);
         self.visit_expr(ctx, false_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let binary_expr = &mut ctx.heap[id];
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, span, "cannot assign to the result from a binary expression"
             ))
+        }
         let left_expr_id = binary_expr.left;
         let right_expr_id = binary_expr.right;
         let old_expr_parent = self.expr_parent;
         binary_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, left_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, right_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> VisitorResult {
         let unary_expr = &mut ctx.heap[id];
         let expr_id = unary_expr.expression;
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, span, "cannot assign to the result from a unary expression"
             ))
+        }
         let old_expr_parent = self.expr_parent;
         unary_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(id.upcast(), 0);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let indexing_expr = &mut ctx.heap[id];
         let subject_expr_id = indexing_expr.subject;
         let index_expr_id = indexing_expr.index;
         let old_expr_parent = self.expr_parent;
         indexing_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, subject_expr_id)?;
         let old_assignable = self.must_be_assignable.take();
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, index_expr_id)?;
         self.must_be_assignable = old_assignable;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let slicing_expr = &mut ctx.heap[id];
         if let Some(span) = self.must_be_assignable {
             // TODO: @Slicing
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, span, "assignment to slices should be valid in the final language, but is currently not implemented"
             ));
+        }
         let subject_expr_id = slicing_expr.subject;
         let from_expr_id = slicing_expr.from_index;
         let to_expr_id = slicing_expr.to_index;
         let old_expr_parent = self.expr_parent;
         slicing_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, subject_expr_id)?;
         let old_assignable = self.must_be_assignable.take();
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, from_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 2);
         self.visit_expr(ctx, to_expr_id)?;
         self.must_be_assignable = old_assignable;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> VisitorResult {
         let select_expr = &mut ctx.heap[id];
         let expr_id = select_expr.subject;
         let old_expr_parent = self.expr_parent;
         select_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(id.upcast(), 0);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> VisitorResult {
         let literal_expr = &mut ctx.heap[id];
         let old_expr_parent = self.expr_parent;
         literal_expr.parent = old_expr_parent;
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, span, "cannot assign to a literal expression"
             ))
+        }
         match &mut literal_expr.value {
             Literal::Null | Literal::True | Literal::False |
             Literal::Character(_) | Literal::Bytestring(_) | Literal::String(_) |
             Literal::Integer(_) => {
                 // Just the parent has to be set, done above
             },
             Literal::Struct(literal) => {
                 let upcast_id = id.upcast();
                 // Retrieve type definition
                 let type_definition = ctx.types.get_base_definition(&literal.definition).unwrap();
                 let struct_definition = type_definition.definition.as_struct();
                 // Make sure all fields are specified, none are specified twice
                 // and all fields exist on the struct definition
                 let mut specified = Vec::new(); // TODO: @performance
                 specified.resize(struct_definition.fields.len(), false);
                 for field in &mut literal.fields {
                     // Find field in the struct definition
                     let field_idx = struct_definition.fields.iter().position(|v| v.identifier == field.identifier);
                     if field_idx.is_none() {
                         let field_span = field.identifier.span;
                         let literal = ctx.heap[id].value.as_struct();
                         let ast_definition = &ctx.heap[literal.definition];
                         return Err(ParseError::new_error_at_span(
                             &ctx.module().source, field_span, format!(
                                 "This field does not exist on the struct '{}'",
                                 ast_definition.identifier().value.as_str()
+                            )
                         ));
+                    }
                     field.field_idx = field_idx.unwrap();
                     // Check if specified more than once
                     if specified[field.field_idx] {
                         let field_span = field.identifier.span;
                         return Err(ParseError::new_error_str_at_span(
                             &ctx.module().source, field_span,
                             "This field is specified more than once"
                         ));
+                    }
                     specified[field.field_idx] = true;
+                }
                 if !specified.iter().all(|v| *v) {
                     // Some fields were not specified
                     let mut not_specified = String::new();
                     let mut num_not_specified = 0;
                     for (def_field_idx, is_specified) in specified.iter().enumerate() {
                         if !is_specified {
                             if !not_specified.is_empty() { not_specified.push_str(", ") }
                             let field_ident = &struct_definition.fields[def_field_idx].identifier;
                             not_specified.push_str(field_ident.value.as_str());
                             num_not_specified += 1;
+                        }
+                    }
                     debug_assert!(num_not_specified > 0);
                     let msg = if num_not_specified == 1 {
                         format!("not all fields are specified, '{}' is missing", not_specified)
                     } else {
                         format!("not all fields are specified, [{}] are missing", not_specified)
                     };
                     let literal_span = literal.parser_type.full_span;
                     return Err(ParseError::new_error_at_span(
                         &ctx.module().source, literal_span, msg
                     ));
+                }
                 // Need to traverse fields expressions in struct and evaluate
                 // the poly args
                 let mut expr_section = self.expression_buffer.start_section();
                 for field in &literal.fields {
                     expr_section.push(field.value);
+                }
                 for expr_idx in 0..expr_section.len() {
                     let expr_id = expr_section[expr_idx];
                     self.expr_parent = ExpressionParent::Expression(upcast_id, expr_idx as u32);
                     self.visit_expr(ctx, expr_id)?;
+                }
                 expr_section.forget();
             },
             Literal::Enum(literal) => {
                 // Make sure the variant exists
                 let type_definition = ctx.types.get_base_definition(&literal.definition).unwrap();
                 let enum_definition = type_definition.definition.as_enum();
                 let variant_idx = enum_definition.variants.iter().position(|v| {
                     v.identifier == literal.variant
                 });
                 if variant_idx.is_none() {
                     let literal = ctx.heap[id].value.as_enum();
                     let ast_definition = ctx.heap[literal.definition].as_enum();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module().source, literal.parser_type.full_span, format!(
                             "the variant '{}' does not exist on the enum '{}'",
                             literal.variant.value.as_str(), ast_definition.identifier.value.as_str()
+                        )
                     ));
+                }
                 literal.variant_idx = variant_idx.unwrap();
             },
             Literal::Union(literal) => {
                 // Make sure the variant exists
                 let type_definition = ctx.types.get_base_definition(&literal.definition).unwrap();
                 let union_definition = type_definition.definition.as_union();
                 let variant_idx = union_definition.variants.iter().position(|v| {
                     v.identifier == literal.variant
                 });
                 if variant_idx.is_none() {
                     let literal = ctx.heap[id].value.as_union();
                     let ast_definition = ctx.heap[literal.definition].as_union();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module().source, literal.parser_type.full_span, format!(
                             "the variant '{}' does not exist on the union '{}'",
                             literal.variant.value.as_str(), ast_definition.identifier.value.as_str()
+                        )
                     ));
+                }
                 literal.variant_idx = variant_idx.unwrap();
                 // Make sure the number of specified values matches the expected
                 // number of embedded values in the union variant.
                 let union_variant = &union_definition.variants[literal.variant_idx];
                 if union_variant.embedded.len() != literal.values.len() {
                     let literal = ctx.heap[id].value.as_union();
                     let ast_definition = ctx.heap[literal.definition].as_union();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module().source, literal.parser_type.full_span, format!(
                             "The variant '{}' of union '{}' expects {} embedded values, but {} were specified",
                             literal.variant.value.as_str(), ast_definition.identifier.value.as_str(),
                             union_variant.embedded.len(), literal.values.len()
                         ),
                     ))
+                }
                 // Traverse embedded values of union (if any) and evaluate the
                 // polymorphic arguments
                 let upcast_id = id.upcast();
                 let mut expr_section = self.expression_buffer.start_section();
                 for value in &literal.values {
                     expr_section.push(*value);
+                }
                 for expr_idx in 0..expr_section.len() {
                     let expr_id = expr_section[expr_idx];
                     self.expr_parent = ExpressionParent::Expression(upcast_id, expr_idx as u32);
                     self.visit_expr(ctx, expr_id)?;
+                }
                 expr_section.forget();
             },
             Literal::Array(literal) | Literal::Tuple(literal) => {
                 // Visit all expressions in the array
                 let upcast_id = id.upcast();
                 let expr_section = self.expression_buffer.start_section_initialized(literal);
                 for expr_idx in 0..expr_section.len() {
                     let expr_id = expr_section[expr_idx];
                     self.expr_parent = ExpressionParent::Expression(upcast_id, expr_idx as u32);
                     self.visit_expr(ctx, expr_id)?;
+                }
                 expr_section.forget();
+            }
+        }
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_cast_expr(&mut self, ctx: &mut Ctx, id: CastExpressionId) -> VisitorResult {
         let cast_expr = &mut ctx.heap[id];
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, span, "cannot assign to the result from a cast expression"
             ))
+        }
         let upcast_id = id.upcast();
         let old_expr_parent = self.expr_parent;
         cast_expr.parent = old_expr_parent;
         // Recurse into the thing that we're casting
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         let subject_id = cast_expr.subject;
         self.visit_expr(ctx, subject_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {
         let call_expr = &ctx.heap[id];
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, span, "cannot assign to the result from a call expression"
             ))
+        }
         // Check whether the method is allowed to be called within the code's
         // context (in sync, definition type, etc.)
         let mut expecting_wrapping_new_stmt = false;
         let mut expecting_primitive_def = false;
         let mut expecting_wrapping_sync_stmt = false;
         let mut expecting_no_select_stmt = false;
         match call_expr.method {
             Method::Get => {
                 expecting_primitive_def = true;
                 expecting_wrapping_sync_stmt = true;
                 if !self.in_select_guard.is_invalid() {
                     // In a select guard. Take the argument (i.e. the port we're
                     // retrieving from) and add it to the list of involved ports
                     // of the guard
                     if call_expr.arguments.len() == 1 {
                         // We're checking the number of arguments later, for now
                         // assume it is correct.
                         let argument = call_expr.arguments[0];
                         let select_stmt = &mut ctx.heap[self.in_select_guard];
                         let select_case = &mut select_stmt.cases[self.in_select_arm as usize];
                         select_case.involved_ports.push((id, argument));
+                    }
+                }
             },
             Method::Put => {
                 expecting_primitive_def = true;
                 expecting_wrapping_sync_stmt = true;
                 expecting_no_select_stmt = true;
             },
             Method::Fires => {
                 expecting_primitive_def = true;
                 expecting_wrapping_sync_stmt = true;
             },
             Method::Create => {},
             Method::Length => {},
             Method::Assert => {
                 expecting_wrapping_sync_stmt = true;
                 expecting_no_select_stmt = true;
                 if self.proc_kind == ProcedureKind::Function {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module().source, call_span,
                         "assert statement may only occur in components"
                     ));
+                }
             },
             Method::Print => {},
             Method::SelectStart
             | Method::SelectRegisterCasePort
             | Method::SelectWait => unreachable!(), // not usable by programmer directly
             Method::ComponentRandomU32
             | Method::ComponentTcpClient => {
             | Method::ComponentTcpClient
             | Method::ComponentTcpListener => {
                 expecting_wrapping_new_stmt = true;
             },
             Method::UserFunction => {}
             Method::UserComponent => {
                 expecting_wrapping_new_stmt = true;
             },
+        }
         let call_expr = &mut ctx.heap[id];
         fn get_span_and_name<'a>(ctx: &'a Ctx, id: CallExpressionId) -> (InputSpan, String) {
             let call = &ctx.heap[id];
             let span = call.func_span;
             let name = String::from_utf8_lossy(ctx.module().source.section_at_span(span)).to_string();
             return (span, name);
+        }
         if expecting_primitive_def {
             if self.proc_kind != ProcedureKind::Primitive {
                 let (call_span, func_name) = get_span_and_name(ctx, id);
                 return Err(ParseError::new_error_at_span(
                     &ctx.module().source, call_span,
                     format!("a call to '{}' may only occur in primitive component definitions", func_name)
                 ));
+            }
+        }
         if expecting_wrapping_sync_stmt {
             if self.in_sync.is_invalid() {
                 let (call_span, func_name) = get_span_and_name(ctx, id);
                 return Err(ParseError::new_error_at_span(
                     &ctx.module().source, call_span,
                     format!("a call to '{}' may only occur inside synchronous blocks", func_name)
                 ))
+            }
+        }
         if expecting_no_select_stmt {
             if !self.in_select_guard.is_invalid() {
                 let (call_span, func_name) = get_span_and_name(ctx, id);
                 return Err(ParseError::new_error_at_span(
                     &ctx.module().source, call_span,
                     format!("a call to '{}' may not occur in a select statement's guard", func_name)
                 ));
+            }
+        }
         if expecting_wrapping_new_stmt {
             if !self.expr_parent.is_new() {
                 let call_span = call_expr.func_span;
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, call_span,
                     "cannot call a component, it can only be instantiated by using 'new'"
                 ));
+            }
         } else {
             if self.expr_parent.is_new() {
                 let call_span = call_expr.func_span;
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, call_span,
                     "only components can be instantiated, this is a function"
                 ));
+            }
+        }
         // Check the number of arguments
         let call_definition = ctx.types.get_base_definition(&call_expr.procedure.upcast()).unwrap();
         let num_expected_args = match &call_definition.definition {
             DefinedTypeVariant::Procedure(definition) => definition.arguments.len(),
             _ => unreachable!(),
         };
         let num_provided_args = call_expr.arguments.len();
         if num_provided_args != num_expected_args {
             let argument_text = if num_expected_args == 1 { "argument" } else { "arguments" };
             let call_span = call_expr.full_span;
             return Err(ParseError::new_error_at_span(
                 &ctx.module().source, call_span, format!(
                     "expected {} {}, but {} were provided",
                     num_expected_args, argument_text, num_provided_args
+                )
             ));
+        }
         // Recurse into all of the arguments and set the expression's parent
         let upcast_id = id.upcast();
         let section = self.expression_buffer.start_section_initialized(&call_expr.arguments);
         let old_expr_parent = self.expr_parent;
         call_expr.parent = old_expr_parent;
         for arg_expr_idx in 0..section.len() {
             let arg_expr_id = section[arg_expr_idx];
             self.expr_parent = ExpressionParent::Expression(upcast_id, arg_expr_idx as u32);
             self.visit_expr(ctx, arg_expr_id)?;
+        }
         section.forget();
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {
         let var_expr = &ctx.heap[id];
         // Check if declaration was already resolved (this occurs for the
         // variable expr that is on the LHS of the assignment expr that is
         // associated with a variable declaration)
         let mut variable_id = var_expr.declaration;
         let mut is_binding_target = false;
         // Otherwise try to find it
         if variable_id.is_none() {
             variable_id = self.find_variable(ctx, self.relative_pos_in_parent, &var_expr.identifier);
+        }
         // Otherwise try to see if is a variable introduced by a binding expr
         let variable_id = if let Some(variable_id) = variable_id {
             variable_id
         } else {
             if self.in_binding_expr.is_invalid() || !self.in_binding_expr_lhs {
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, var_expr.identifier.span, "unresolved variable"
                 ));
+            }
             // This is a binding variable, but it may only appear in very
             // specific locations.
             let is_valid_binding = match self.expr_parent {
                 ExpressionParent::Expression(expr_id, idx) => {
                     match &ctx.heap[expr_id] {
                         Expression::Binding(_binding_expr) => {
                             // Nested binding is disallowed, and because of
                             // the check above we know we're directly at the
                             // LHS of the binding expression
                             debug_assert_eq!(_binding_expr.this, self.in_binding_expr);
                             debug_assert_eq!(idx, 0);
                             true
+                        }
                         Expression::Literal(_lit_expr) => {
                             // Only struct, unions, tuples and arrays can
                             // have subexpressions, so we're always fine
                             dbg_code!({
                                 match _lit_expr.value {
                                     Literal::Struct(_) | Literal::Union(_) | Literal::Array(_) | Literal::Tuple(_) => {},
                                     _ => unreachable!(),
+                                }
                             });
                             true
                         },
                         _ => false,
+                    }
                 },
                 _ => {
                     false
+                }
             };
             if !is_valid_binding {
                 let binding_expr = &ctx.heap[self.in_binding_expr];
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, var_expr.identifier.span,
                     "illegal location for binding variable: binding variables may only be nested under a binding expression, or a struct, union or array literal"
                 ).with_info_at_span(
                     &ctx.module().source, binding_expr.operator_span, format!(
                         "'{}' was interpreted as a binding variable because the variable is not declared and it is nested under this binding expression",
                         var_expr.identifier.value.as_str()
+                    )
                 ));
+            }
             // By now we know that this is a valid binding expression. Given
             // that a binding expression must be nested under an if/while
             // statement, we now add the variable to the scope associated with
             // that statement.
             let bound_identifier = var_expr.identifier.clone();
             let bound_variable_id = ctx.heap.alloc_variable(|this| Variable {
                 this,
                 kind: VariableKind::Binding,
                 parser_type: ParserType {
                     elements: vec![ParserTypeElement {
                         element_span: bound_identifier.span,
                         variant: ParserTypeVariant::Inferred
                     }],
                     full_span: bound_identifier.span
                 },
                 identifier: bound_identifier,
                 relative_pos_in_parent: 0,
                 unique_id_in_scope: -1,
             });
             let scope_id = match &ctx.heap[self.in_test_expr] {
                 Statement::If(stmt) => stmt.true_case.scope,
                 Statement::While(stmt) => stmt.scope,
                 _ => unreachable!(),
             };
             self.checked_at_single_scope_add_local(ctx, scope_id, -1, bound_variable_id)?; // add at -1 such that first statement can find the variable if needed
             is_binding_target = true;
             bound_variable_id
         };
         let var_expr = &mut ctx.heap[id];
         var_expr.declaration = Some(variable_id);
         var_expr.used_as_binding_target = is_binding_target;
         var_expr.parent = self.expr_parent;
         Ok(())
+    }
+}
 impl PassValidationLinking {
     //--------------------------------------------------------------------------
     // Special traversal
     //--------------------------------------------------------------------------
     /// Pushes a new scope associated with a particular statement. If that
     /// statement already has an associated scope (i.e. scope associated with
     /// sync statement or select statement's arm) then we won't do anything.
     /// In all cases the caller must call `pop_statement_scope` with the scope
     /// and relative scope position returned by this function.
     fn push_scope(&mut self, ctx: &mut Ctx, is_top_level_scope: bool, pushed_scope_id: ScopeId) -> (ScopeId, i32) {
         // Set the properties of the pushed scope (it is already created during
         // AST construction, but most values are not yet set to their correct
         // values)
         let old_scope_id = self.cur_scope;
         let scope = &mut ctx.heap[pushed_scope_id];
         if !is_top_level_scope {
             scope.parent = Some(old_scope_id);
+        }
         scope.relative_pos_in_parent = self.relative_pos_in_parent;
         let old_relative_pos = self.relative_pos_in_parent;
         self.relative_pos_in_parent = 0;
         // Link up scopes
         if !is_top_level_scope {
             let old_scope = &mut ctx.heap[old_scope_id];
             old_scope.nested.push(pushed_scope_id);
+        }
         // Set as current traversal scope, then return old scope
         self.cur_scope = pushed_scope_id;
         return (old_scope_id, old_relative_pos)
+    }
     fn pop_scope(&mut self, scope_to_restore: (ScopeId, i32)) {
         self.cur_scope = scope_to_restore.0;
         self.relative_pos_in_parent = scope_to_restore.1;
+    }
     fn resolve_pending_control_flow_targets(&mut self, ctx: &mut Ctx) -> Result<(), ParseError> {
         for entry in &self.control_flow_stmts {
             let stmt = &ctx.heap[entry.statement];
             match stmt {
                 Statement::Break(stmt) => {
                     let stmt_id = stmt.this;
                     let target_while_id = Self::resolve_break_or_continue_target(ctx, entry, stmt.span, &stmt.label)?;
                     let target_while_stmt = &ctx.heap[target_while_id];
                     let target_end_while_id = target_while_stmt.end_while;
                     debug_assert!(!target_end_while_id.is_invalid());
                     let break_stmt = &mut ctx.heap[stmt_id];
                     break_stmt.target = target_end_while_id;
                 },
                 Statement::Continue(stmt) => {
                     let stmt_id = stmt.this;
                     let target_while_id = Self::resolve_break_or_continue_target(ctx, entry, stmt.span, &stmt.label)?;
                     let continue_stmt = &mut ctx.heap[stmt_id];
                     continue_stmt.target = target_while_id;
                 },
                 Statement::Goto(stmt) => {
                     let stmt_id = stmt.this;
                     let target_id = Self::find_label(entry.in_scope, ctx, &stmt.label)?;
                     let target_stmt = &ctx.heap[target_id];
                     if entry.in_sync != target_stmt.in_sync {
                         // Nested sync not allowed. And goto can only go to
                         // outer scopes, so we must be escaping from a sync.
                         debug_assert!(target_stmt.in_sync.is_invalid());    // target not in sync
                         debug_assert!(!entry.in_sync.is_invalid()); // but the goto is in sync
                         let goto_stmt = &ctx.heap[stmt_id];
                         let sync_stmt = &ctx.heap[entry.in_sync];
                         return Err(
                             ParseError::new_error_str_at_span(&ctx.module().source, goto_stmt.span, "goto may not escape the surrounding synchronous block")
                             .with_info_str_at_span(&ctx.module().source, target_stmt.label.span, "this is the target of the goto statement")
                             .with_info_str_at_span(&ctx.module().source, sync_stmt.span, "which will jump past this statement")
                         );
+                    }
                     let goto_stmt = &mut ctx.heap[stmt_id];
                     goto_stmt.target = target_id;
                 },
                 _ => unreachable!("cannot resolve control flow target for {:?}", stmt),
+            }
+        }
         return Ok(())
+    }
     //--------------------------------------------------------------------------
     // Utilities
     //--------------------------------------------------------------------------
     /// Adds a local variable to the current scope. It will also annotate the
     /// `Local` in the AST with its relative position in the block.
     fn checked_add_local(&mut self, ctx: &mut Ctx, target_scope_id: ScopeId, target_relative_pos: i32, new_variable_id: VariableId) -> Result<(), ParseError> {
         let new_variable = &ctx.heap[new_variable_id];
         // We immediately go to the parent scope. We check the target scope
         // in the call at the end. That is also where we check for collisions
         // with symbols.
         let mut scope = &ctx.heap[target_scope_id];
         let mut cur_relative_pos = scope.relative_pos_in_parent;
         while let Some(scope_parent_id) = scope.parent {
             scope = &ctx.heap[scope_parent_id];
             // Check for collisions
             for variable_id in scope.variables.iter().copied() {
                 let existing_variable = &ctx.heap[variable_id];
                 if existing_variable.identifier == new_variable.identifier &&
                     existing_variable.this != new_variable_id &&
                     cur_relative_pos >= existing_variable.relative_pos_in_parent {
                     return Err(
                         ParseError::new_error_str_at_span(
                             &ctx.module().source, new_variable.identifier.span, "Local variable name conflicts with another variable"
                         ).with_info_str_at_span(
                             &ctx.module().source, existing_variable.identifier.span, "Previous variable is found here"
+                        )
                     );
+                }
+            }
             cur_relative_pos = scope.relative_pos_in_parent;
+        }
         // No collisions in any of the parent scope, attempt to add to scope
         self.checked_at_single_scope_add_local(ctx, target_scope_id, target_relative_pos, new_variable_id)
+    }
     /// Adds a local variable to the specified scope. Will check the specified
     /// scope for variable conflicts and the symbol table for global conflicts.
     /// Will NOT check parent scopes of the specified scope.
     fn checked_at_single_scope_add_local(
         &mut self, ctx: &mut Ctx, scope_id: ScopeId, relative_pos: i32, new_variable_id: VariableId
     ) -> Result<(), ParseError> {
         // Check the symbol table for conflicts
+        {
             let cur_scope = SymbolScope::Definition(self.proc_id.upcast());
             let ident = &ctx.heap[new_variable_id].identifier;
             if let Some(symbol) = ctx.symbols.get_symbol_by_name(cur_scope, &ident.value.as_bytes()) {
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, ident.span,
                     "local variable declaration conflicts with symbol"
                 ).with_info_str_at_span(
                     &ctx.module().source, symbol.variant.span_of_introduction(&ctx.heap), "the conflicting symbol is introduced here"
                 ));
+            }
+        }
         // Check the specified scope for conflicts
         let new_variable = &ctx.heap[new_variable_id];
         let scope = &ctx.heap[scope_id];
         for variable_id in scope.variables.iter().copied() {
             let old_variable = &ctx.heap[variable_id];
             if new_variable.this != old_variable.this &&
                 // relative_pos >= other_local.relative_pos_in_block &&
                 new_variable.identifier == old_variable.identifier {
                 // Collision
                 return Err(
                     ParseError::new_error_str_at_span(
                         &ctx.module().source, new_variable.identifier.span, "Local variable name conflicts with another variable"
                     ).with_info_str_at_span(
                         &ctx.module().source, old_variable.identifier.span, "Previous variable is found here"
+                    )
                 );
+            }
+        }
         // No collisions
         let scope = &mut ctx.heap[scope_id];
         scope.variables.push(new_variable_id);
         let variable = &mut ctx.heap[new_variable_id];
         variable.relative_pos_in_parent = relative_pos;
         Ok(())
+    }
     /// Finds a variable in the visitor's scope that must appear before the
     /// specified relative position within that block.
     fn find_variable(&self, ctx: &Ctx, mut relative_pos: i32, identifier: &Identifier) -> Option<VariableId> {
         let mut scope_id = self.cur_scope;
         loop {
             // Check if we can find the variable in the current scope
             let scope = &ctx.heap[scope_id];
             for variable_id in scope.variables.iter().copied() {
                 let variable = &ctx.heap[variable_id];
                 if variable.relative_pos_in_parent < relative_pos && identifier == &variable.identifier {
                     return Some(variable_id);
+                }

src/protocol/parser/token_parsing.rs

➞

Show inline comments

 use crate::collections::ScopedSection;
 use crate::protocol::ast::*;
 use crate::protocol::input_source::{
     InputSource as InputSource,
     InputPosition as InputPosition,
     InputSpan,
     ParseError,
 };
 use super::tokens::*;
 use super::symbol_table::*;
 use super::{Module, PassCtx};
 // Keywords
 pub(crate) const KW_LET:       &'static [u8] = b"let";
 pub(crate) const KW_AS:        &'static [u8] = b"as";
 pub(crate) const KW_STRUCT:    &'static [u8] = b"struct";
 pub(crate) const KW_ENUM:      &'static [u8] = b"enum";
 pub(crate) const KW_UNION:     &'static [u8] = b"union";
 pub(crate) const KW_FUNCTION:  &'static [u8] = b"func";
 pub(crate) const KW_PRIMITIVE: &'static [u8] = b"primitive";
 pub(crate) const KW_COMPOSITE: &'static [u8] = b"composite";
 pub(crate) const KW_COMPONENT: &'static [u8] = b"comp";
 pub(crate) const KW_IMPORT:    &'static [u8] = b"import";
 // Keywords - literals
 pub(crate) const KW_LIT_TRUE:  &'static [u8] = b"true";
 pub(crate) const KW_LIT_FALSE: &'static [u8] = b"false";
 pub(crate) const KW_LIT_NULL:  &'static [u8] = b"null";
 // Keywords - function(like)s
 pub(crate) const KW_CAST:        &'static [u8] = b"cast";
 pub(crate) const KW_FUNC_GET:    &'static [u8] = b"get";
 pub(crate) const KW_FUNC_PUT:    &'static [u8] = b"put";
 pub(crate) const KW_FUNC_FIRES:  &'static [u8] = b"fires";
 pub(crate) const KW_FUNC_CREATE: &'static [u8] = b"create";
 pub(crate) const KW_FUNC_LENGTH: &'static [u8] = b"length";
 pub(crate) const KW_FUNC_ASSERT: &'static [u8] = b"assert";
 pub(crate) const KW_FUNC_PRINT:  &'static [u8] = b"print";
 // Keywords - statements
 pub(crate) const KW_STMT_CHANNEL:  &'static [u8] = b"channel";
 pub(crate) const KW_STMT_IF:       &'static [u8] = b"if";
 pub(crate) const KW_STMT_ELSE:     &'static [u8] = b"else";
 pub(crate) const KW_STMT_WHILE:    &'static [u8] = b"while";
 pub(crate) const KW_STMT_BREAK:    &'static [u8] = b"break";
 pub(crate) const KW_STMT_CONTINUE: &'static [u8] = b"continue";
 pub(crate) const KW_STMT_GOTO:     &'static [u8] = b"goto";
 pub(crate) const KW_STMT_RETURN:   &'static [u8] = b"return";
 pub(crate) const KW_STMT_SYNC:     &'static [u8] = b"sync";
 pub(crate) const KW_STMT_FORK:     &'static [u8] = b"fork";
 pub(crate) const KW_STMT_SELECT:   &'static [u8] = b"select";
 pub(crate) const KW_STMT_OR:       &'static [u8] = b"or";
 pub(crate) const KW_STMT_NEW:      &'static [u8] = b"new";
 // Keywords - types
 // Since types are needed for returning diagnostic information to the user, the
 // string variants are put here as well.
 pub(crate) const KW_TYPE_IN_PORT_STR:  &'static str = "in";
 pub(crate) const KW_TYPE_OUT_PORT_STR: &'static str = "out";
 pub(crate) const KW_TYPE_MESSAGE_STR:  &'static str = "msg";
 pub(crate) const KW_TYPE_BOOL_STR:     &'static str = "bool";
 pub(crate) const KW_TYPE_UINT8_STR:    &'static str = "u8";
 pub(crate) const KW_TYPE_UINT16_STR:   &'static str = "u16";
 pub(crate) const KW_TYPE_UINT32_STR:   &'static str = "u32";
 pub(crate) const KW_TYPE_UINT64_STR:   &'static str = "u64";
 pub(crate) const KW_TYPE_SINT8_STR:    &'static str = "s8";
 pub(crate) const KW_TYPE_SINT16_STR:   &'static str = "s16";
 pub(crate) const KW_TYPE_SINT32_STR:   &'static str = "s32";
 pub(crate) const KW_TYPE_SINT64_STR:   &'static str = "s64";
 pub(crate) const KW_TYPE_CHAR_STR:     &'static str = "char";
 pub(crate) const KW_TYPE_STRING_STR:   &'static str = "string";
 pub(crate) const KW_TYPE_INFERRED_STR: &'static str = "auto";
 pub(crate) const KW_TYPE_IN_PORT:  &'static [u8] = KW_TYPE_IN_PORT_STR.as_bytes();
 pub(crate) const KW_TYPE_OUT_PORT: &'static [u8] = KW_TYPE_OUT_PORT_STR.as_bytes();
 pub(crate) const KW_TYPE_MESSAGE:  &'static [u8] = KW_TYPE_MESSAGE_STR.as_bytes();
 pub(crate) const KW_TYPE_BOOL:     &'static [u8] = KW_TYPE_BOOL_STR.as_bytes();
 pub(crate) const KW_TYPE_UINT8:    &'static [u8] = KW_TYPE_UINT8_STR.as_bytes();
 pub(crate) const KW_TYPE_UINT16:   &'static [u8] = KW_TYPE_UINT16_STR.as_bytes();
 pub(crate) const KW_TYPE_UINT32:   &'static [u8] = KW_TYPE_UINT32_STR.as_bytes();
 pub(crate) const KW_TYPE_UINT64:   &'static [u8] = KW_TYPE_UINT64_STR.as_bytes();
 pub(crate) const KW_TYPE_SINT8:    &'static [u8] = KW_TYPE_SINT8_STR.as_bytes();
 pub(crate) const KW_TYPE_SINT16:   &'static [u8] = KW_TYPE_SINT16_STR.as_bytes();
 pub(crate) const KW_TYPE_SINT32:   &'static [u8] = KW_TYPE_SINT32_STR.as_bytes();
 pub(crate) const KW_TYPE_SINT64:   &'static [u8] = KW_TYPE_SINT64_STR.as_bytes();
 pub(crate) const KW_TYPE_CHAR:     &'static [u8] = KW_TYPE_CHAR_STR.as_bytes();
 pub(crate) const KW_TYPE_STRING:   &'static [u8] = KW_TYPE_STRING_STR.as_bytes();
 pub(crate) const KW_TYPE_INFERRED: &'static [u8] = KW_TYPE_INFERRED_STR.as_bytes();
 // Builtin pragma types
 // Not usable by the programmer, but usable in the standard library. These hint
 // at the fact that we need a different system (e.g. function overloading)
 pub(crate) const PRAGMA_TYPE_VOID: &'static [u8] = b"#type_void";
 pub(crate) const PRAGMA_TYPE_PORTLIKE: &'static [u8] = b"#type_portlike";
 pub(crate) const PRAGMA_TYPE_INTEGERLIKE: &'static [u8] = b"#type_integerlike";
 pub(crate) const PRAGMA_TYPE_ARRAYLIKE: &'static [u8] = b"#type_arraylike";
 /// A special trait for when consuming comma-separated things such that we can
 /// push them onto a `Vec` and onto a `ScopedSection`. As we monomorph for
 /// very specific comma-separated cases I don't expect polymorph bloat.
 /// Also, I really don't like this solution.
 pub(crate) trait Extendable {
     type Value;
     fn push(&mut self, v: Self::Value);
+}
 impl<T> Extendable for Vec<T> {
     type Value = T;
     #[inline]
     fn push(&mut self, v: Self::Value) {
         (self as &mut Vec<T>).push(v);
+    }
+}
 impl<T: Sized> Extendable for ScopedSection<T> {
     type Value = T;
     #[inline]
     fn push(&mut self, v: Self::Value) {
         (self as &mut ScopedSection<T>).push(v);
+    }
+}
 /// Consumes a domain-name identifier: identifiers separated by a dot. For
 /// simplification of later parsing and span identification the domain-name may
 /// contain whitespace, but must reside on the same line.
 pub(crate) fn consume_domain_ident<'a>(
     source: &'a InputSource, iter: &mut TokenIter
 ) -> Result<(&'a [u8], InputSpan), ParseError> {
     let (_, mut span) = consume_ident(source, iter)?;
     while let Some(TokenKind::Dot) = iter.next() {
         iter.consume();
         let (_, new_span) = consume_ident(source, iter)?;
         span.end = new_span.end;
+    }
     // Not strictly necessary, but probably a reasonable restriction: this
     // simplifies parsing of module naming and imports.
     if span.begin.line != span.end.line {
         return Err(ParseError::new_error_str_at_span(source, span, "module names may not span multiple lines"));
+    }
     // If module name consists of a single identifier, then it may not match any
     // of the reserved keywords
     let section = source.section_at_pos(span.begin, span.end);
     if is_reserved_keyword(section) {
         return Err(ParseError::new_error_str_at_span(source, span, "encountered reserved keyword"));
+    }
     Ok((source.section_at_pos(span.begin, span.end), span))
+}
 /// Consumes a specific expected token. Be careful to only call this with tokens
 /// that do not have a variable length.
 pub(crate) fn consume_token(source: &InputSource, iter: &mut TokenIter, expected: TokenKind) -> Result<InputSpan, ParseError> {
     if Some(expected) != iter.next() {
         return Err(ParseError::new_error_at_pos(
             source, iter.last_valid_pos(),
             format!("expected '{}'", expected.token_chars())
         ));
+    }
     let span = iter.next_span();
     iter.consume();
     Ok(span)
+}
 /// Consumes a comma separated list until the closing delimiter is encountered.
 /// The closing delimiter is consumed as well.
 pub(crate) fn consume_comma_separated_until<T, F, E>(
     close_delim: TokenKind, source: &InputSource, iter: &mut TokenIter, ctx: &mut PassCtx,
     mut consumer_fn: F, target: &mut E, item_name_and_article: &'static str,
     close_pos: Option<&mut InputPosition>
 ) -> Result<(), ParseError>
     where F: FnMut(&InputSource, &mut TokenIter, &mut PassCtx) -> Result<T, ParseError>,
           E: Extendable<Value=T>
+{
     let mut had_comma = true;
     let mut next;
     loop {
         next = iter.next();
         if Some(close_delim) == next {
             if let Some(close_pos) = close_pos {
                 // If requested return the position of the closing delimiter
                 let (_, new_close_pos) = iter.next_positions();
                 *close_pos = new_close_pos;
+            }
             iter.consume();
             break;
         } else if !had_comma || next.is_none() {
             return Err(ParseError::new_error_at_pos(
                 source, iter.last_valid_pos(),
                 format!("expected a '{}', or {}", close_delim.token_chars(), item_name_and_article)
             ));
+        }
         let new_item = consumer_fn(source, iter, ctx)?;
         target.push(new_item);
         next = iter.next();
         had_comma = next == Some(TokenKind::Comma);
         if had_comma {
             iter.consume();
+        }
+    }
     Ok(())
+}
 /// Consumes a comma-separated list of items if the opening delimiting token is
 /// encountered. If not, then the iterator will remain at its current position.
 /// Note that the potential cases may be:
 /// - No opening delimiter encountered, then we return `false`.
 /// - Both opening and closing delimiter encountered, but no items.
 /// - Opening and closing delimiter encountered, and items were processed.
 /// - Found an opening delimiter, but processing an item failed.
 pub(crate) fn maybe_consume_comma_separated<T, F, E>(
     open_delim: TokenKind, close_delim: TokenKind, source: &InputSource, iter: &mut TokenIter, ctx: &mut PassCtx,
     consumer_fn: F, target: &mut E, item_name_and_article: &'static str,
     close_pos: Option<&mut InputPosition>
 ) -> Result<bool, ParseError>
     where F: FnMut(&InputSource, &mut TokenIter, &mut PassCtx) -> Result<T, ParseError>,
           E: Extendable<Value=T>
+{
     if Some(open_delim) != iter.next() {
         return Ok(false);
+    }
     // Opening delimiter encountered, so must parse the comma-separated list.
     iter.consume();
     consume_comma_separated_until(close_delim, source, iter, ctx, consumer_fn, target, item_name_and_article, close_pos)?;
     Ok(true)
+}
 pub(crate) fn maybe_consume_comma_separated_spilled<F: FnMut(&InputSource, &mut TokenIter, &mut PassCtx) -> Result<(), ParseError>>(
     open_delim: TokenKind, close_delim: TokenKind, source: &InputSource,
     iter: &mut TokenIter, ctx: &mut PassCtx,
     mut consumer_fn: F, item_name_and_article: &'static str
 ) -> Result<bool, ParseError> {
     let mut next = iter.next();
     if Some(open_delim) != next {
         return Ok(false);
+    }
     iter.consume();
     let mut had_comma = true;
     loop {
         next = iter.next();
         if Some(close_delim) == next {
             iter.consume();
             break;
         } else if !had_comma {
             return Err(ParseError::new_error_at_pos(
                 source, iter.last_valid_pos(),
                 format!("expected a '{}', or {}", close_delim.token_chars(), item_name_and_article)
             ));
+        }
         consumer_fn(source, iter, ctx)?;
         next = iter.next();
         had_comma = next == Some(TokenKind::Comma);
         if had_comma {
             iter.consume();
+        }
+    }
     Ok(true)
+}
 /// Consumes a comma-separated list and expected the opening and closing
 /// characters to be present. The returned array may still be empty
 pub(crate) fn consume_comma_separated<T, F, E>(
     open_delim: TokenKind, close_delim: TokenKind, source: &InputSource,
     iter: &mut TokenIter, ctx: &mut PassCtx,
     consumer_fn: F, target: &mut E, item_name_and_article: &'static str,
     list_name_and_article: &'static str, close_pos: Option<&mut InputPosition>
 ) -> Result<(), ParseError>
     where F: FnMut(&InputSource, &mut TokenIter, &mut PassCtx) -> Result<T, ParseError>,
           E: Extendable<Value=T>
+{
     let first_pos = iter.last_valid_pos();
     match maybe_consume_comma_separated(
         open_delim, close_delim, source, iter, ctx, consumer_fn, target,
         item_name_and_article, close_pos
     ) {
         Ok(true) => Ok(()),
         Ok(false) => {
             return Err(ParseError::new_error_at_pos(
                 source, first_pos,
                 format!("expected {}", list_name_and_article)
             ));
         },
         Err(err) => Err(err)
+    }
+}
 /// Consumes an integer literal, may be binary, octal, hexadecimal or decimal,
 /// and may have separating '_'-characters.
 pub(crate) fn consume_integer_literal(source: &InputSource, iter: &mut TokenIter, buffer: &mut String) -> Result<(u64, InputSpan), ParseError> {
     if Some(TokenKind::Integer) != iter.next() {
         return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected an integer literal"));
+    }
     let integer_span = iter.next_span();
     iter.consume();
     let integer_text = source.section_at_span(integer_span);
     // Determine radix and offset from prefix
     let (radix, input_offset, radix_name) =
         if integer_text.starts_with(b"0b") || integer_text.starts_with(b"0B") {
             // Binary number
             (2, 2, "binary")
         } else if integer_text.starts_with(b"0o") || integer_text.starts_with(b"0O") {
             // Octal number
             (8, 2, "octal")
         } else if integer_text.starts_with(b"0x") || integer_text.starts_with(b"0X") {
             // Hexadecimal number
             (16, 2, "hexadecimal")
         } else {
             (10, 0, "decimal")
         };
     // Take out any of the separating '_' characters
     buffer.clear();
     for char_idx in input_offset..integer_text.len() {
         let char = integer_text[char_idx];
         if char == b'_' {
             continue;
+        }
         if !((char >= b'0' && char <= b'9') || (char >= b'A' && char <= b'F') || (char >= b'a' || char <= b'f')) {
             return Err(ParseError::new_error_at_span(
                 source, integer_span,
                 format!("incorrectly formatted {} number", radix_name)
             ));
+        }
         buffer.push(char::from(char));
+    }
     // Use the cleaned up string to convert to integer
     match u64::from_str_radix(&buffer, radix) {
         Ok(number) => Ok((number, integer_span)),
         Err(_) => Err(ParseError::new_error_at_span(
             source, integer_span,
             format!("incorrectly formatted {} number", radix_name)
         )),
+    }
+}
 /// Consumes a character literal. We currently support a limited number of
 /// backslash-escaped characters
 pub(crate) fn consume_character_literal(
     source: &InputSource, iter: &mut TokenIter
 ) -> Result<(char, InputSpan), ParseError> {
     if Some(TokenKind::Character) != iter.next() {
         return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected a character literal"));
+    }
     let span = iter.next_span();
     iter.consume();
     let char_text = source.section_at_span(span);
     if !char_text.is_ascii() {
         return Err(ParseError::new_error_str_at_span(
             source, span, "expected an ASCII character literal"
         ));
+    }
     debug_assert!(char_text.len() >= 2); // always includes the bounding "'"
     match char_text.len() {
 => return Err(ParseError::new_error_str_at_span(source, span, "too little characters in character literal")),
 => {
             // We already know the text is ascii, so just throw an error if we have the escape
             // character.
             if char_text[1] == b'\\' {
                 return Err(ParseError::new_error_str_at_span(source, span, "escape character without subsequent character"));
+            }
             return Ok((char_text[1] as char, span));
         },
 => {
             if char_text[1] == b'\\' {
                 let result = parse_escaped_character(source, span, char_text[2])?;
                 return Ok((result, span))
+            }
         },
         _ => {}
+    }
     return Err(ParseError::new_error_str_at_span(source, span, "too many characters in character literal"))
+}
 /// Consumes a bytestring literal: a string interpreted as a byte array. See
 /// `consume_string_literal` for further remarks.
 pub(crate) fn consume_bytestring_literal(
     source: &InputSource, iter: &mut TokenIter, buffer: &mut String
 ) -> Result<InputSpan, ParseError> {
     // Retrieve string span, adjust to remove the leading "b" character
     if Some(TokenKind::Bytestring) != iter.next() {
         return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected a bytestring literal"));
+    }
     let span = iter.next_span();
     iter.consume();
     debug_assert_eq!(source.section_at_pos(span.begin, span.begin.with_offset(1)), b"b");
     // Parse into buffer
     let text_span = InputSpan::from_positions(span.begin.with_offset(1), span.end);
     parse_escaped_string(source, text_span, buffer)?;
     return Ok(span);
+}
 /// Consumes a string literal. We currently support a limited number of
 /// backslash-escaped characters. Note that the result is stored in the
 /// buffer.
 pub(crate) fn consume_string_literal(
     source: &InputSource, iter: &mut TokenIter, buffer: &mut String
 ) -> Result<InputSpan, ParseError> {
     // Retrieve string span from token stream
     if Some(TokenKind::String) != iter.next() {
         return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected a string literal"));
+    }
     let span = iter.next_span();
     iter.consume();
     // Parse into buffer
     parse_escaped_string(source, span, buffer)?;
     return Ok(span);
+}
 fn parse_escaped_string(source: &InputSource, text_span: InputSpan, buffer: &mut String) -> Result<(), ParseError> {
     let text = source.section_at_span(text_span);
     if !text.is_ascii() {
         return Err(ParseError::new_error_str_at_span(source, text_span, "expected an ASCII string literal"));
+    }
     debug_assert_eq!(text[0], b'"'); // here as kind of a reminder: the span includes the bounding quotation marks
     debug_assert_eq!(text[text.len() - 1], b'"');
     buffer.clear();
     buffer.reserve(text.len() - 2);
     let mut was_escape = false;
     for idx in 1..text.len() - 1 {
         let cur = text[idx];
         let is_escape = cur == b'\\';
         if was_escape {
             let to_push = parse_escaped_character(source, text_span, cur)?;
             buffer.push(to_push);
         } else if !is_escape {
             buffer.push(cur as char);
+        }
         if was_escape && is_escape {
             was_escape = false;
         } else {
             was_escape = is_escape;
+        }
+    }
     debug_assert!(!was_escape); // because otherwise we couldn't have ended the string literal
     return Ok(());
+}
 #[inline]
 fn parse_escaped_character(source: &InputSource, literal_span: InputSpan, v: u8) -> Result<char, ParseError> {
     let result = match v {
         b'r' => '\r',
         b'n' => '\n',
         b't' => '\t',
         b'0' => '\0',
         b'\\' => '\\',
         b'\'' => '\'',
         b'"' => '"',
         v => {
             let msg = if v.is_ascii_graphic() {
                 format!("unsupported escape character '{}'", v as char)
             } else {
                 format!("unsupported escape character with (unsigned) byte value {}", v)
             };
             return Err(ParseError::new_error_at_span(source, literal_span, msg))
         },
     };
     Ok(result)
+}
 pub(crate) fn consume_pragma<'a>(source: &'a InputSource, iter: &mut TokenIter) -> Result<(&'a [u8], InputSpan), ParseError> {
     if Some(TokenKind::Pragma) != iter.next() {
         return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected a pragma"));
+    }
     let pragma_span = iter.next_span();
     iter.consume();
     Ok((source.section_at_span(pragma_span), pragma_span))
+}
 pub(crate) fn has_ident(source: &InputSource, iter: &mut TokenIter, expected: &[u8]) -> bool {
     peek_ident(source, iter).map_or(false, |section| section == expected)
+}
 pub(crate) fn peek_ident<'a>(source: &'a InputSource, iter: &mut TokenIter) -> Option<&'a [u8]> {
     if Some(TokenKind::Ident) == iter.next() {
         let (start, end) = iter.next_positions();
         return Some(source.section_at_pos(start, end))
+    }
     None
+}
 /// Consumes any identifier and returns it together with its span. Does not
 /// check if the identifier is a reserved keyword.
 pub(crate) fn consume_any_ident<'a>(
     source: &'a InputSource, iter: &mut TokenIter
 ) -> Result<(&'a [u8], InputSpan), ParseError> {
     if Some(TokenKind::Ident) != iter.next() {
         return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected an identifier"));
+    }
     let (ident_start, ident_end) = iter.next_positions();
     iter.consume();
     Ok((source.section_at_pos(ident_start, ident_end), InputSpan::from_positions(ident_start, ident_end)))
+}
 /// Consumes a specific identifier. May or may not be a reserved keyword.
 pub(crate) fn consume_exact_ident(source: &InputSource, iter: &mut TokenIter, expected: &[u8]) -> Result<InputSpan, ParseError> {
     let (ident, pos) = consume_any_ident(source, iter)?;
     if ident != expected {
         debug_assert!(expected.is_ascii());
         return Err(ParseError::new_error_at_pos(
             source, iter.last_valid_pos(),
             format!("expected the text '{}'", &String::from_utf8_lossy(expected))
         ));
+    }
     Ok(pos)
+}
 /// Consumes an identifier that is not a reserved keyword and returns it
 /// together with its span.
 pub(crate) fn consume_ident<'a>(
     source: &'a InputSource, iter: &mut TokenIter
 ) -> Result<(&'a [u8], InputSpan), ParseError> {
     let (ident, span) = consume_any_ident(source, iter)?;
     if is_reserved_keyword(ident) {
         return Err(ParseError::new_error_str_at_span(source, span, "encountered reserved keyword"));
+    }
     Ok((ident, span))
+}
 /// Consumes an identifier and immediately intern it into the `StringPool`
 pub(crate) fn consume_ident_interned(
     source: &InputSource, iter: &mut TokenIter, ctx: &mut PassCtx
 ) -> Result<Identifier, ParseError> {
     let (value, span) = consume_ident(source, iter)?;
     let value = ctx.pool.intern(value);
     Ok(Identifier{ span, value })
+}
 fn is_reserved_definition_keyword(text: &[u8]) -> bool {
     match text {
-        KW_STRUCT | KW_ENUM | KW_UNION | KW_FUNCTION | KW_PRIMITIVE | KW_COMPOSITE => true,
+        KW_STRUCT | KW_ENUM | KW_UNION | KW_FUNCTION | KW_COMPONENT => true,
         _ => false,
+    }
+}
 fn is_reserved_statement_keyword(text: &[u8]) -> bool {
     match text {
         KW_IMPORT | KW_AS |
         KW_STMT_CHANNEL | KW_STMT_IF | KW_STMT_WHILE |
         KW_STMT_BREAK | KW_STMT_CONTINUE | KW_STMT_GOTO | KW_STMT_RETURN |
         KW_STMT_SYNC | KW_STMT_FORK | KW_STMT_NEW => true,
         _ => false,
+    }
+}
 fn is_reserved_expression_keyword(text: &[u8]) -> bool {
     match text {
         KW_LET | KW_CAST |
         KW_LIT_TRUE | KW_LIT_FALSE | KW_LIT_NULL |
         _ => false,
+    }
+}
 fn is_reserved_type_keyword(text: &[u8]) -> bool {
     match text {
         KW_TYPE_IN_PORT | KW_TYPE_OUT_PORT | KW_TYPE_MESSAGE | KW_TYPE_BOOL |
         KW_TYPE_UINT8 | KW_TYPE_UINT16 | KW_TYPE_UINT32 | KW_TYPE_UINT64 |
         KW_TYPE_SINT8 | KW_TYPE_SINT16 | KW_TYPE_SINT32 | KW_TYPE_SINT64 |
         KW_TYPE_CHAR | KW_TYPE_STRING |
         KW_TYPE_INFERRED => true,
         _ => false,
+    }
+}
 fn is_reserved_keyword(text: &[u8]) -> bool {
     return
         is_reserved_definition_keyword(text) ||
         is_reserved_statement_keyword(text) ||
         is_reserved_expression_keyword(text) ||
         is_reserved_type_keyword(text);
+}
 pub(crate) fn seek_module(modules: &[Module], root_id: RootId) -> Option<&Module> {
     for module in modules {
         if module.root_id == root_id {
             return Some(module)
+        }
+    }
     return None
+}
 /// Constructs a human-readable message indicating why there is a conflict of
 /// symbols.
 // Note: passing the `module_idx` is not strictly necessary, but will prevent
 // programmer mistakes during development: we get a conflict because we're
 // currently parsing a particular module.
 pub(crate) fn construct_symbol_conflict_error(
     modules: &[Module], module_idx: usize, ctx: &PassCtx, new_symbol: &Symbol, old_symbol: &Symbol
 ) -> ParseError {
     let module = &modules[module_idx];
     let get_symbol_span_and_msg = |symbol: &Symbol| -> (String, Option<InputSpan>) {
         match &symbol.variant {
             SymbolVariant::Module(module) => {
                 let import = &ctx.heap[module.introduced_at];
                 return (
                     format!("the module aliased as '{}' imported here", symbol.name.as_str()),
                     Some(import.as_module().span)
                 );
             },
             SymbolVariant::Definition(definition) => {
                 if definition.defined_in_module.is_invalid() {
                     // Must be a builtin thing
                     return (format!("the builtin '{}'", symbol.name.as_str()), None)
                 } else {
                     if let Some(import_id) = definition.imported_at {
                         let import = &ctx.heap[import_id];
                         return (
                             format!("the type '{}' imported here", symbol.name.as_str()),
                             Some(import.as_symbols().span)
                         );
                     } else if definition.defined_in_module == module.root_id {
                         // This is a symbol defined in the same module
                         return (
                             format!("the type '{}' defined here", symbol.name.as_str()),
                             Some(definition.identifier_span)
+                        )
                     } else {
                         // Not imported, not defined in the module, so must be
                         // a global
                         return (format!("the global '{}'", symbol.name.as_str()), None)
+                    }
+                }
+            }
+        }
     };
     let (new_symbol_msg, new_symbol_span) = get_symbol_span_and_msg(new_symbol);
     let (old_symbol_msg, old_symbol_span) = get_symbol_span_and_msg(old_symbol);
     let new_symbol_span = new_symbol_span.unwrap(); // because new symbols cannot be builtin
     match old_symbol_span {
         Some(old_symbol_span) => ParseError::new_error_at_span(
             &module.source, new_symbol_span, format!("symbol is defined twice: {}", new_symbol_msg)
         ).with_info_at_span(
             &module.source, old_symbol_span, format!("it conflicts with {}", old_symbol_msg)
         ),
         None => ParseError::new_error_at_span(
             &module.source, new_symbol_span,
             format!("symbol is defined twice: {} conflicts with {}", new_symbol_msg, old_symbol_msg)
+        )
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/type_table.rs

➞

Show inline comments

 /**
  * type_table.rs
+ *
  * The type table is a lookup from AST definition (which contains just what the
  * programmer typed) to a type with additional information computed (e.g. the
  * byte size and offsets of struct members). The type table should be considered
  * the authoritative source of information on types by the compiler (not the
  * AST itself!).
+ *
  * The type table operates in two modes: one is where we just look up the type,
  * check its fields for correctness and mark whether it is polymorphic or not.
  * The second one is where we compute byte sizes, alignment and offsets.
+ *
  * The basic algorithm for type resolving and computing byte sizes is to
  * recursively try to lay out each member type of a particular type. This is
  * done in a stack-like fashion, where each embedded type pushes a breadcrumb
  * unto the stack. We may discover a cycle in embedded types (we call this a
  * "type loop"). After which the type table attempts to break the type loop by
  * making specific types heap-allocated. Upon doing so we know their size
  * because their stack-size is now based on pointers. Hence breaking the type
  * loop required for computing the byte size of types.
+ *
  * The reason for these type shenanigans is because PDL is a value-based
  * language, but we would still like to be able to express recursively defined
  * types like trees or linked lists. Hence we need to insert pointers somewhere
  * to break these cycles.
+ *
  * We will insert these pointers into the variants of unions. However note that
  * we can only compute the stack size of a union until we've looked at *all*
  * variants. Hence we perform an initial pass where we detect type loops, a
  * second pass where we compute the stack sizes of everything, and a third pass
  * where we actually compute the size of the heap allocations for unions.
+ *
  * As a final bit of global documentation: non-polymorphic types will always
  * have one "monomorph" entry. This contains the non-polymorphic type's memory
  * layout.
  */
 // Programmer note: deduplication of types is currently disabled, see the
 // @Deduplication key. Tests might fail when it is re-enabled.
 use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
 use crate::protocol::ast::*;
 use crate::protocol::parser::symbol_table::SymbolScope;
 use crate::protocol::input_source::ParseError;
 use crate::protocol::parser::*;
 //------------------------------------------------------------------------------
 // Defined Types
 //------------------------------------------------------------------------------
 /// Struct wrapping around a potentially polymorphic type. If the type does not
 /// have any polymorphic arguments then it will not have any monomorphs and
 /// `is_polymorph` will be set to `false`. A type with polymorphic arguments
 /// only has `is_polymorph` set to `true` if the polymorphic arguments actually
 /// appear in the types associated types (function return argument, struct
 /// field, enum variant, etc.). Otherwise the polymorphic argument is just a
 /// marker and does not influence the bytesize of the type.
 #[allow(unused)]
 pub struct DefinedType {
     pub(crate) ast_root: RootId,
     pub(crate) ast_definition: DefinitionId,
     pub(crate) definition: DefinedTypeVariant,
     pub(crate) poly_vars: Vec<PolymorphicVariable>,
     pub(crate) is_polymorph: bool,
+}
 pub enum DefinedTypeVariant {
     Enum(EnumType),
     Union(UnionType),
     Struct(StructType),
     Procedure(ProcedureType),
+}
 impl DefinedTypeVariant {
     pub(crate) fn is_data_type(&self) -> bool {
         use DefinedTypeVariant as DTV;
         match self {
             DTV::Struct(_) | DTV::Enum(_) | DTV::Union(_) => return true,
             DTV::Procedure(_) => return false,
+        }
+    }
     pub(crate) fn as_struct(&self) -> &StructType {
         match self {
             DefinedTypeVariant::Struct(v) => v,
             _ => unreachable!()
+        }
+    }
     pub(crate) fn as_enum(&self) -> &EnumType {
         match self {
             DefinedTypeVariant::Enum(v) => v,
             _ => unreachable!()
+        }
+    }
     pub(crate) fn as_union(&self) -> &UnionType {
         match self {
             DefinedTypeVariant::Union(v) => v,
             _ => unreachable!()
+        }
+    }
+}
 pub struct PolymorphicVariable {
     pub(crate) identifier: Identifier,
     pub(crate) is_in_use: bool, // a polymorphic argument may be defined, but not used by the type definition
+}
 /// `EnumType` is the classical C/C++ enum type. It has various variants with
 /// an assigned integer value. The integer values may be user-defined,
 /// compiler-defined, or a mix of the two. If a user assigns the same enum
 /// value multiple times, we assume the user is an expert and we consider both
 /// variants to be equal to one another.
 pub struct EnumType {
     pub variants: Vec<EnumVariant>,
     pub minimum_tag_value: i64,
     pub maximum_tag_value: i64,
     pub tag_type: ConcreteType,
     pub size: usize,
     pub alignment: usize,
+}
 // TODO: Also support maximum u64 value
 pub struct EnumVariant {
     pub identifier: Identifier,
     pub value: i64,
+}
 /// `UnionType` is the algebraic datatype (or sum type, or discriminated union).
 /// A value is an element of the union, identified by its tag, and may contain
 /// a single subtype.
 /// For potentially infinite types (i.e. a tree, or a linked list) only unions
 /// can break the infinite cycle. So when we lay out these unions in memory we
 /// will reserve enough space on the stack for all union variants that do not
 /// cause "type loops" (i.e. a union `A` with a variant containing a struct
 /// `B`). And we will reserve enough space on the heap (and store a pointer in
 /// the union) for all variants which do cause type loops (i.e. a union `A`
 /// with a variant to a struct `B` that contains the union `A` again).
 pub struct UnionType {
     pub variants: Vec<UnionVariant>,
     pub tag_type: ConcreteType,
     pub tag_size: usize,
+}
 pub struct UnionVariant {
     pub identifier: Identifier,
     pub embedded: Vec<ParserType>, // zero-length does not have embedded values
     pub tag_value: i64,
+}
 /// `StructType` is a generic C-like struct type (or record type, or product
 /// type) type.
 pub struct StructType {
     pub fields: Vec<StructField>,
+}
 pub struct StructField {
     pub identifier: Identifier,
     pub parser_type: ParserType,
+}
 /// `ProcedureType` is the signature of a procedure/component
 pub struct ProcedureType {
     pub kind: ProcedureKind,
     pub return_type: Option<ParserType>,
     pub arguments: Vec<ProcedureArgument>,
+}
 pub struct ProcedureArgument {
     identifier: Identifier,
     parser_type: ParserType,
+}
 /// Represents the data associated with a single expression after type inference
 /// for a monomorph (or just the normal expression types, if dealing with a
 /// non-polymorphic function/component).
 pub struct MonomorphExpression {
     // The output type of the expression. Note that for a function it is not the
     // function's signature but its return type
     pub(crate) expr_type: ConcreteType,
     // Has multiple meanings: the field index for select expressions, the
     // monomorph index for polymorphic function calls or literals. Negative
     // values are never used, but used to catch programming errors.
     pub(crate) field_or_monomorph_idx: i32,
     pub(crate) type_id: TypeId,
+}
 //------------------------------------------------------------------------------
 // Type monomorph storage
 //------------------------------------------------------------------------------
 pub(crate) enum MonoTypeVariant {
     Builtin, // no extra data, added manually in compiler initialization code
     Enum, // no extra data
     Struct(StructMonomorph),
     Union(UnionMonomorph),
     Procedure(ProcedureMonomorph), // functions, components
     Tuple(TupleMonomorph),
+}
 impl MonoTypeVariant {
     fn as_struct_mut(&mut self) -> &mut StructMonomorph {
         match self {
             MonoTypeVariant::Struct(v) => v,
             _ => unreachable!(),
+        }
+    }
     pub(crate) fn as_union(&self) -> &UnionMonomorph {
         match self {
             MonoTypeVariant::Union(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_union_mut(&mut self) -> &mut UnionMonomorph {
         match self {
             MonoTypeVariant::Union(v) => v,
             _ => unreachable!(),
+        }
+    }
     pub(crate) fn as_struct(&self) -> &StructMonomorph {
         match self {
             MonoTypeVariant::Struct(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_tuple_mut(&mut self) -> &mut TupleMonomorph {
         match self {
             MonoTypeVariant::Tuple(v) => v,
             _ => unreachable!(),
+        }
+    }
     pub(crate) fn as_procedure(&self) -> &ProcedureMonomorph {
         match self {
             MonoTypeVariant::Procedure(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_procedure_mut(&mut self) -> &mut ProcedureMonomorph {
         match self {
             MonoTypeVariant::Procedure(v) => v,
             _ => unreachable!(),
+        }
+    }
+}
 /// Struct monomorph
 pub struct StructMonomorph {
     pub fields: Vec<StructMonomorphField>,
+}
 pub struct StructMonomorphField {
     pub type_id: TypeId,
     concrete_type: ConcreteType,
     pub size: usize,
     pub alignment: usize,
     pub offset: usize,
+}
 /// Union monomorph
 pub struct UnionMonomorph {
     pub variants: Vec<UnionMonomorphVariant>,
     pub tag_size: usize, // copied from `UnionType` upon monomorph construction.
     // note that the stack size is in the `TypeMonomorph` struct. This size and
     // alignment will include the size of the union tag.
     //
     // heap_size contains the allocated size of the union in the case it
     // is used to break a type loop. If it is 0, then it doesn't require
     // allocation and lives entirely on the stack.
     pub heap_size: usize,
     pub heap_alignment: usize,
+}
 pub struct UnionMonomorphVariant {
     pub lives_on_heap: bool,
     pub embedded: Vec<UnionMonomorphEmbedded>,
+}
 pub struct UnionMonomorphEmbedded {
     pub type_id: TypeId,
     concrete_type: ConcreteType,
     // Note that the meaning of the offset (and alignment) depend on whether or
     // not the variant lives on the stack/heap. If it lives on the stack then
     // they refer to the offset from the start of the union value (so the first
     // embedded type lives at a non-zero offset, because the union tag sits in
     // the front). If it lives on the heap then it refers to the offset from the
     // allocated memory region (so the first embedded type lives at a 0 offset).
     pub size: usize,
     pub alignment: usize,
     pub offset: usize,
+}
 /// Procedure (functions and components of all possible types) monomorph. Also
 /// stores the expression type data from the typechecking/inferencing pass.
 pub struct ProcedureMonomorph {
     pub monomorph_index: u32,
     pub builtin: bool,
+}
 /// Tuple monomorph. Again a kind of exception because one cannot define a named
 /// tuple type containing explicit polymorphic variables. But again: we need to
 /// store size/offset/alignment information, so we do it here.
 pub struct TupleMonomorph {
     pub members: Vec<TupleMonomorphMember>
+}
 pub struct TupleMonomorphMember {
     pub type_id: TypeId,
     concrete_type: ConcreteType,
     pub size: usize,
     pub alignment: usize,
     pub offset: usize,
+}
 /// Generic unique type ID. Every monomorphed type and every non-polymorphic
 /// type will have one of these associated with it.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct TypeId(i64);
 impl TypeId {
     pub(crate) fn new_invalid() -> Self {
         return Self(-1);
+    }
+}
 /// A monomorphed type (or non-polymorphic type's) memory layout and information
 /// regarding associated types (like a struct's field type).
 pub struct MonoType {
     pub type_id: TypeId,
     pub concrete_type: ConcreteType,
     pub size: usize,
     pub alignment: usize,
     pub(crate) variant: MonoTypeVariant
+}
 impl MonoType {
     #[inline]
     fn new_empty(type_id: TypeId, concrete_type: ConcreteType, variant: MonoTypeVariant) -> Self {
         return Self {
             type_id, concrete_type,
             size: 0,
             alignment: 0,
             variant,
+        }
+    }
     /// Little internal helper function as a reminder: if alignment is 0, then
     /// the size/alignment are not actually computed yet!
     #[inline]
     fn get_size_alignment(&self) -> Option<(usize, usize)> {
         if self.alignment == 0 {
             return None
         } else {
             return Some((self.size, self.alignment));
+        }
+    }
+}
 /// Special structure that acts like the lookup key for `ConcreteType` instances
 /// that have already been added to the type table before.
 #[derive(Clone)]
 struct MonoSearchKey {
     // Uses bitflags to denote when parts between search keys should match and
     // whether they should be checked. Needs to have a system like this to
     // accommodate tuples.
     parts: Vec<(u8, ConcreteTypePart)>,
     change_bit: u8,
+}
 impl MonoSearchKey {
     const KEY_IN_USE: u8 = 0x01;
     const KEY_CHANGE_BIT: u8 = 0x02;
     fn with_capacity(capacity: usize) -> Self {
         return MonoSearchKey{
             parts: Vec::with_capacity(capacity),
             change_bit: 0,
         };
+    }
     /// Sets the search key based on a single concrete type and its polymorphic
     /// variables.
     fn set(&mut self, concrete_type_parts: &[ConcreteTypePart], poly_var_in_use: &[PolymorphicVariable]) {
         self.set_top_type(concrete_type_parts[0]);
         let mut poly_var_index = 0;
         for subtype in ConcreteTypeIter::new(concrete_type_parts, 0) {
             let in_use = poly_var_in_use[poly_var_index].is_in_use;
             poly_var_index += 1;
             self.push_subtype(subtype, in_use);
+        }
         debug_assert_eq!(poly_var_index, poly_var_in_use.len());
+    }
     /// Starts setting the search key based on an initial top-level type,
     /// programmer must call `push_subtype` the appropriate number of times
     /// after calling this function
     fn set_top_type(&mut self, type_part: ConcreteTypePart) {
         self.parts.clear();
         self.parts.push((Self::KEY_IN_USE, type_part));
         self.change_bit = Self::KEY_CHANGE_BIT;
+    }
     fn push_subtype(&mut self, concrete_type: &[ConcreteTypePart], in_use: bool) {
         let flag = self.change_bit | (if in_use { Self::KEY_IN_USE } else { 0 });
         for part in concrete_type {
             self.parts.push((flag, *part));
+        }
         self.change_bit ^= Self::KEY_CHANGE_BIT;
+    }
     fn push_subtree(&mut self, concrete_type: &[ConcreteTypePart], poly_var_in_use: &[PolymorphicVariable]) {
         self.parts.push((self.change_bit | Self::KEY_IN_USE, concrete_type[0]));
         self.change_bit ^= Self::KEY_CHANGE_BIT;
         let mut poly_var_index = 0;
         for subtype in ConcreteTypeIter::new(concrete_type, 0) {
             let in_use = poly_var_in_use[poly_var_index].is_in_use;
             poly_var_index += 1;
             self.push_subtype(subtype, in_use);
+        }
         debug_assert_eq!(poly_var_index, poly_var_in_use.len());
+    }
     // Utilities for hashing and comparison
     fn find_end_index(&self, start_index: usize) -> usize {
         // Check if we're already at the end
         let mut index = start_index;
         if index >= self.parts.len() {
             return index;
+        }
         // Iterate until bit flips, or until at end
         let expected_bit = self.parts[index].0 & Self::KEY_CHANGE_BIT;
         index += 1;
         while index < self.parts.len() {
             let current_bit = self.parts[index].0 & Self::KEY_CHANGE_BIT;
             if current_bit != expected_bit {
                 return index;
+            }
             index += 1;
+        }
         return index;
+    }
+}
 impl Hash for MonoSearchKey {
     fn hash<H: Hasher>(&self, state: &mut H) {
         for index in 0..self.parts.len() {
             let (_flags, part) = self.parts[index];
             // if flags & Self::KEY_IN_USE != 0 { @Deduplication
             part.hash(state);
             // }
+        }
+    }
+}
 impl PartialEq for MonoSearchKey {
     fn eq(&self, other: &Self) -> bool {
         let mut self_index = 0;
         let mut other_index = 0;
         while self_index < self.parts.len() && other_index < other.parts.len() {
             // Retrieve part and flags
             let (_self_bits, _) = self.parts[self_index];
             let (_other_bits, _) = other.parts[other_index];
             let self_in_use = true; // (self_bits & Self::KEY_IN_USE) != 0; @Deduplication
             let other_in_use = true; // (other_bits & Self::KEY_IN_USE) != 0; @Deduplication
             // Determine ending indices
             let self_end_index = self.find_end_index(self_index);
             let other_end_index = other.find_end_index(other_index);
             if self_in_use == other_in_use {
                 if self_in_use {
                     // Both are in use, so both parts should be equal
                     let delta_self = self_end_index - self_index;
                     let delta_other = other_end_index - other_index;
                     if delta_self != delta_other {
                         // Both in use, but not of equal length, so the types
                         // cannot match
                         return false;
+                    }
                     for _ in 0..delta_self {
                         let (_, self_part) = self.parts[self_index];
                         let (_, other_part) = other.parts[other_index];
                         if self_part != other_part {
                             return false;
+                        }
                         self_index += 1;
                         other_index += 1;
+                    }
                 } else {
                     // Both not in use, so skip associated parts
                     self_index = self_end_index;
                     other_index = other_end_index;
+                }
             } else {
                 // No agreement on importance of parts. This is practically
                 // impossible
                 unreachable!();
+            }
+        }
         // Everything matched, so if we're at the end of both arrays then we're
         // certain that the two keys are equal.
         return self_index == self.parts.len() && other_index == other.parts.len();
+    }
+}
 impl Eq for MonoSearchKey{}
 //------------------------------------------------------------------------------
 // Type table
 //------------------------------------------------------------------------------
 const POLY_VARS_IN_USE: [PolymorphicVariable; 1] = [PolymorphicVariable{ identifier: Identifier::new_empty(InputSpan::new()), is_in_use: true }];
 // Programmer note: keep this struct free of dynamically allocated memory
 #[derive(Clone)]
 struct TypeLoopBreadcrumb {
     type_id: TypeId,
     next_member: u32,
     next_embedded: u32, // for unions, the index into the variant's embedded types
+}
 // Programmer note: keep this struct free of dynamically allocated memory
 #[derive(Clone)]
 struct MemoryBreadcrumb {
     type_id: TypeId,
     next_member: u32,
     next_embedded: u32,
     first_size_alignment_idx: u32,
+}
 #[derive(Debug, PartialEq, Eq)]
 enum TypeLoopResult {
     TypeExists,
     PushBreadcrumb(DefinitionId, ConcreteType),
     TypeLoop(usize), // index into vec of breadcrumbs at which the type matched
+}
 enum MemoryLayoutResult {
     TypeExists(usize, usize), // (size, alignment)
     PushBreadcrumb(MemoryBreadcrumb),
+}
 // TODO: @Optimize, initial memory-unoptimized implementation
 struct TypeLoopEntry {
     type_id: TypeId,
     is_union: bool,
+}
 struct TypeLoop {
     members: Vec<TypeLoopEntry>,
+}
 type DefinitionMap = HashMap<DefinitionId, DefinedType>;
 type MonoTypeMap = HashMap<MonoSearchKey, TypeId>;
 type MonoTypeArray = Vec<MonoType>;
 pub struct TypeTable {
     // Lookup from AST DefinitionId to a defined type. Also lookups for
     // concrete type to monomorphs
     pub(crate) definition_lookup: DefinitionMap,
     mono_type_lookup: MonoTypeMap,
     pub(crate) mono_types: MonoTypeArray,
     mono_search_key: MonoSearchKey,
     // Breadcrumbs left behind while trying to find type loops. Also used to
     // determine sizes of types when all type loops are detected.
     type_loop_breadcrumbs: Vec<TypeLoopBreadcrumb>,
     type_loops: Vec<TypeLoop>,
     // Stores all encountered types during type loop detection. Used afterwards
     // to iterate over all types in order to compute size/alignment.
     encountered_types: Vec<TypeLoopEntry>,
     // Breadcrumbs and temporary storage during memory layout computation.
     memory_layout_breadcrumbs: Vec<MemoryBreadcrumb>,
     size_alignment_stack: Vec<(usize, usize)>,
+}
 impl TypeTable {
     /// Construct a new type table without any resolved types.
     pub(crate) fn new() -> Self {
         Self{
             definition_lookup: HashMap::with_capacity(128),
             mono_type_lookup: HashMap::with_capacity(128),
             mono_types: Vec::with_capacity(128),
             mono_search_key: MonoSearchKey::with_capacity(32),
             type_loop_breadcrumbs: Vec::with_capacity(32),
             type_loops: Vec::with_capacity(8),
             encountered_types: Vec::with_capacity(32),
             memory_layout_breadcrumbs: Vec::with_capacity(32),
             size_alignment_stack: Vec::with_capacity(64),
+        }
+    }
     /// Iterates over all defined types (polymorphic and non-polymorphic) and
     /// add their types in two passes. In the first pass we will just add the
     /// base types (we will not consider monomorphs, and we will not compute

src/protocol/tests/parser_validation.rs

➞

Show inline comments

@@ @@ -215,597 +215,597 @@ fn test_correct_union_instance() { @@
         union Foo { A }
         func bar() -> Foo { return Foo::A; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple tags",
+        "
         union Foo { A, B }
         func bar() -> Foo { return Foo::B; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "single embedded",
+        "
         union Foo { A(s32) }
         func bar() -> Foo { return Foo::A(5); }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple embedded",
+        "
         union Foo { A(s32), B(s8) }
         func bar() -> Foo { return Foo::B(2); }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple values in embedded",
+        "
         union Foo { A(s32, s8) }
         func bar() -> Foo { return Foo::A(0, 2); }
+        "
     );
     Tester::new_single_source_expect_ok(
         "mixed tag/embedded",
+        "
         union OptionInt { None, Some(s32) }
         func bar() -> OptionInt { return OptionInt::Some(3); }
+        "
     );
     Tester::new_single_source_expect_ok(
         "single polymorphic var",
+        "
         union Option<T> { None, Some(T) }
         func bar() -> Option<s32> { return Option::Some(3); }"
     );
     Tester::new_single_source_expect_ok(
         "multiple polymorphic vars",
+        "
         union Result<T, E> { Ok(T), Err(E), }
         func bar() -> Result<s32, s8> { return Result::Ok(3); }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple polymorphic in one variant",
+        "
         union MaybePair<T1, T2>{ None, Some(T1, T2) }
         func bar() -> MaybePair<s8, s32> { return MaybePair::Some(1, 2); }
+        "
     );
+}
 #[test]
 fn test_incorrect_union_instance() {
     Tester::new_single_source_expect_err(
         "tag-variant name reuse",
+        "
         union Foo{ A, A }
+        "
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "A }")
         .assert_msg_has(0, "union variant is defined more than once")
         .assert_occurs_at(1, "A, ")
         .assert_msg_has(1, "other union variant");
     });
     Tester::new_single_source_expect_err(
         "embedded-variant name reuse",
+        "
         union Foo{ A(s32), A(s8) }
+        "
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "A(s8)")
         .assert_msg_has(0, "union variant is defined more than once")
         .assert_occurs_at(1, "A(s32)")
         .assert_msg_has(1, "other union variant");
     });
     Tester::new_single_source_expect_err(
         "undefined variant",
+        "
         union Silly{ Thing(s8) }
         func bar() -> Silly { return Silly::Undefined(5); }
+        "
     ).error(|e| { e
         .assert_msg_has(0, "variant 'Undefined' does not exist on the union 'Silly'");
     });
     Tester::new_single_source_expect_err(
         "using tag instead of embedded",
+        "
         union Foo{ A(s32) }
         func bar() -> Foo { return Foo::A; }
+        "
     ).error(|e| { e
         .assert_msg_has(0, "variant 'A' of union 'Foo' expects 1 embedded values, but 0 were");
     });
     Tester::new_single_source_expect_err(
         "using embedded instead of tag",
+        "
         union Foo{ A }
         func bar() -> Foo { return Foo::A(3); }
+        "
     ).error(|e| { e
         .assert_msg_has(0, "The variant 'A' of union 'Foo' expects 0");
     });
     Tester::new_single_source_expect_err(
         "wrong embedded value",
+        "
         union Foo{ A(s32) }
         func bar() -> Foo { return Foo::A(false); }
+        "
     ).error(|e| { e
         .assert_occurs_at(0, "Foo::A")
         .assert_msg_has(0, "failed to resolve")
         .assert_occurs_at(1, "false")
         .assert_msg_has(1, "has been resolved to 's32'")
         .assert_msg_has(1, "has been resolved to 'bool'");
     });
+}
 #[test]
 fn test_correct_tuple_members() {
     // Tuples with zero members
     Tester::new_single_source_expect_ok(
         "single zero-tuple",
         "struct Foo{ () bar }"
     ).for_struct("Foo", |s| { s
         .for_field("bar", |f| { f.assert_parser_type("()"); })
         .assert_size_alignment("Foo", 0, 1);
     });
     Tester::new_single_source_expect_ok(
         "triple zero-tuple",
         "struct Foo{ () bar, () baz, () qux }"
     ).for_struct("Foo", |s| { s
         .assert_size_alignment("Foo", 0, 1);
     });
     // Tuples with one member (which are elided, because due to ambiguity
     // between a one-tuple literal and a parenthesized expression, we're not
     // going to be able to construct one-tuples).
     Tester::new_single_source_expect_ok(
         "single elided one-tuple",
         "struct Foo{ (u32) bar }"
     ).for_struct("Foo", |s| { s
         .for_field("bar", |f| { f.assert_parser_type("u32"); })
         .assert_size_alignment("Foo", 4, 4);
     });
     Tester::new_single_source_expect_ok(
         "triple elided one-tuple",
         "struct Foo{ (u8) bar, (u16) baz, (u32) qux }"
     ).for_struct("Foo", |s| { s
         .assert_size_alignment("Foo", 8, 4);
     });
     // Tuples with three members
     Tester::new_single_source_expect_ok(
         "single three-tuple",
         "struct Foo{ (u8, u16, u32) bar }"
     ).for_struct("Foo", |s| { s
         .for_field("bar", |f| { f.assert_parser_type("(u8,u16,u32)"); })
         .assert_size_alignment("Foo", 8, 4);
     });
     Tester::new_single_source_expect_ok(
         "double three-tuple",
         "struct Foo{ (u8,u16,u32,) bar, (s8,s16,s32,) baz }"
     ).for_struct("Foo", |s| { s
         .for_field("bar", |f| { f.assert_parser_type("(u8,u16,u32)"); })
         .for_field("baz", |f| { f.assert_parser_type("(s8,s16,s32)"); })
         .assert_size_alignment("Foo", 16, 4);
     });
+}
 #[test]
 fn test_incorrect_tuple_member() {
     // Test not really necessary, but hey, what's a test between friends
     Tester::new_single_source_expect_err(
         "unknown tuple member",
         "struct Foo{ (u32, u32, u32, YouThirstySchmoo) field }"
     ).error(|e| { e
         .assert_num(1)
         .assert_msg_has(0, "unknown type")
         .assert_occurs_at(0, "YouThirstySchmoo");
     });
+}
 #[test]
 fn test_correct_tuple_polymorph_args() {
     Tester::new_single_source_expect_ok(
         "single tuple arg",
+        "
         union Option<T>{ Some(T), None }
         func thing() -> u32 {
             auto a = Option<()>::None;
             auto b = Option<(u32, u64)>::None;
             auto c = Option<(Option<(u8, s8)>, Option<(s8, u8)>)>::None;
             return 0;
+        }
+        "
     ).for_union("Option", |u| { u
         .assert_has_monomorph("Option<()>")
         .assert_has_monomorph("Option<(u32,u64)>")
         .assert_has_monomorph("Option<(Option<(u8,s8)>,Option<(s8,u8)>)>")
         .assert_size_alignment("Option<()>", 1, 1, 0, 0)
         .assert_size_alignment("Option<(u32,u64)>", 24, 8, 0, 0) // (u32, u64) becomes size 16, alignment 8. Hence union tag is aligned to 8
         .assert_size_alignment("Option<(Option<(u8,s8)>,Option<(s8,u8)>)>", 7, 1, 0, 0); // inner unions are size 3, alignment 1. Two of those with a tag is size 7
     });
+}
 #[test]
 fn test_incorrect_tuple_polymorph_args() {
     // Do some mismatching brackets. I don't know what else to test
     Tester::new_single_source_expect_err(
         "mismatch angle bracket",
+        "
         union Option<T>{ Some(T), None }
         func f() -> u32 {
             auto a = Option<(u32>)::None;
             return 0;
         }"
     ).error(|e| { e
         .assert_num(2)
         .assert_msg_has(0, "closing '>'").assert_occurs_at(0, ">)::None")
         .assert_msg_has(1, "match this '('").assert_occurs_at(1, "(u32>");
     });
     Tester::new_single_source_expect_err(
         "wrongly placed angle",
+        "
         union O<T>{ S(T), N }
         func f() -> u32 {
             auto a = O<(<u32>)>::None;
             return 0;
+        }
+        "
     ).error(|e| { e
         .assert_num(1)
         .assert_msg_has(0, "expected typename")
         .assert_occurs_at(0, "<u32");
     });
+}
 #[test]
 fn test_incorrect_tuple_member_access() {
     Tester::new_single_source_expect_err(
         "zero-tuple",
         "func foo() -> () { () a = (); auto b = a.0; return a; }"
     ).error(|e| { e
         .assert_num(1)
         .assert_msg_has(0, "out of bounds")
         .assert_occurs_at(0, "a.0");
     });
     // Make the type checker do some shenanigans before we can decide the tuple
     // type.
     Tester::new_single_source_expect_err(
         "sized tuple",
+        "
         func determinator<A,B>((A,B,A) v) -> B { return v.1; }
         func tester() -> u64 {
             auto v = (0,1,2);
             u32 a_u32 = 5;
             v.2 = a_u32;
             v.8 = 5;
             return determinator(v);
+        }
+        "
     ).error(|e| { e
         .assert_num(1)
         .assert_msg_has(0, "out of bounds")
         .assert_occurs_at(0, "v.8");
     });
+}
 #[test]
 fn test_polymorph_array_types() {
     Tester::new_single_source_expect_ok(
         "array of polymorph in struct",
+        "
         struct Foo<T> { T[] hello }
         struct Bar { Foo<u32>[] world }
+        "
     ).for_struct("Bar", |s| { s
         .for_field("world", |f| { f.assert_parser_type("Foo<u32>[]"); });
     });
     Tester::new_single_source_expect_ok(
         "array of port in struct",
+        "
         struct Bar { in<u32>[] inputs }
+        "
     ).for_struct("Bar", |s| { s
         .for_field("inputs", |f| { f.assert_parser_type("in<u32>[]"); });
     });
+}
 #[test]
 fn test_correct_modifying_operators() {
     // Not testing the types, just that it parses
     Tester::new_single_source_expect_ok(
         "valid uses",
+        "
         func f() -> u32 {
             auto a = 5;
             a += 2; a -= 2; a *= 2; a /= 2; a %= 2;
             a <<= 2; a >>= 2;
             a |= 2; a &= 2; a ^= 2;
             return a;
+        }
+        "
     );
+}
 #[test]
 fn test_incorrect_modifying_operators() {
     Tester::new_single_source_expect_err(
         "wrong declaration",
         "func f() -> u8 { auto a += 2; return a; }"
     ).error(|e| { e.assert_msg_has(0, "expected '='"); });
     Tester::new_single_source_expect_err(
         "inside function",
         "func f(u32 a) -> u32 { auto b = 0; auto c = f(a += 2); }"
     ).error(|e| { e.assert_msg_has(0, "assignments are statements"); });
     Tester::new_single_source_expect_err(
         "inside tuple",
         "func f(u32 a) -> u32 { auto b = (a += 2, a /= 2); return 0; }"
     ).error(|e| { e.assert_msg_has(0, "assignments are statements"); });
+}
 #[test]
 fn test_variable_introduction_in_scope() {
     Tester::new_single_source_expect_err(
         "variable use before declaration",
         "func f() -> u8 { return thing; auto thing = 5; }"
     ).error(|e| { e.assert_msg_has(0, "unresolved variable"); });
     Tester::new_single_source_expect_err(
         "variable use in declaration",
         "func f() -> u8 { auto thing = 5 + thing; return thing; }"
     ).error(|e| { e.assert_msg_has(0, "unresolved variable"); });
     Tester::new_single_source_expect_ok(
         "variable use after declaration",
         "func f() -> u8 { auto thing = 5; return thing; }"
     );
     Tester::new_single_source_expect_err(
         "variable use of closed scope",
         "func f() -> u8 { { auto thing = 5; } return thing; }"
     ).error(|e| { e.assert_msg_has(0, "unresolved variable"); });
+}
 #[test]
 fn test_correct_select_statement() {
     Tester::new_single_source_expect_ok(
         "guard variable decl",
+        "
-        primitive f() {
+        comp f() {
             channel<u32> unused -> input;
             u32 outer_value = 0;
             sync select {
                 auto in_same_guard = get(input) -> {} // decl A1
                 auto in_same_gaurd = get(input) -> {} // decl A2
                 auto in_guard_and_block = get(input) -> {} // decl B1
                 outer_value = get(input) -> { auto in_guard_and_block = outer_value; } // decl B2
+            }
+        }
+        "
     );
     Tester::new_single_source_expect_ok(
         "empty select",
-        "primitive f() { sync select {} }"
+        "comp f() { sync select {} }"
     );
     Tester::new_single_source_expect_ok(
         "mixed uses", "
-        primitive f() {
+        comp f() {
             channel unused_output -> input;
             u32 outer_value = 0;
             sync select {
                 outer_value = get(input) -> outer_value = 0;
                 auto new_value = get(input) -> {
                     outer_value = new_value;
+                }
                 get(input) + get(input) ->
                     outer_value = 8;
                 get(input) ->
                     {}
                 outer_value %= get(input) -> {
                     outer_value *= outer_value;
                     auto new_value = get(input);
                     outer_value += new_value;
+                }
+            }
+        }
+        "
     );
+}
 #[test]
 fn test_incorrect_select_statement() {
     Tester::new_single_source_expect_err(
         "outside sync",
-        "primitive f() { select {} }"
+        "comp f() { select {} }"
     ).error(|e| { e
         .assert_num(1)
         .assert_occurs_at(0, "select")
         .assert_msg_has(0, "inside sync blocks");
     });
     Tester::new_single_source_expect_err(
         "variable in previous block",
-        "primitive f() {
+        "comp f() {
             channel<u32> tx -> rx;
             u32 a = 0; // this one will be shadowed
             sync select { auto a = get(rx) -> {} }
         }"
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "a = get").assert_msg_has(0, "variable name conflicts")
         .assert_occurs_at(1, "a = 0").assert_msg_has(1, "Previous variable");
     });
     Tester::new_single_source_expect_err(
         "put inside arm",
-        "primitive f() {
+        "comp f() {
             channel<u32> a -> b;
             sync select { put(a) -> {} }
         }"
     ).error(|e| { e
         .assert_occurs_at(0, "put")
         .assert_msg_has(0, "may not occur");
     });
+}
 #[test]
 fn test_incorrect_goto_statement() {
     Tester::new_single_source_expect_err(
         "goto missing var in same scope",
         "func f() -> u32 {
             goto exit;
             auto v = 5;
             exit: return 0;
         }"
     ).error(|e| { e
         .assert_num(3)
         .assert_occurs_at(0, "exit;").assert_msg_has(0, "skips over a variable")
         .assert_occurs_at(1, "exit:").assert_msg_has(1, "jumps to this label")
         .assert_occurs_at(2, "v = 5").assert_msg_has(2, "skips over this variable");
     });
     Tester::new_single_source_expect_err(
         "goto missing var in outer scope",
         "func f() -> u32 {
             if (true) {
                 goto exit;
+            }
             auto v = 0;
             exit: return 1;
         }"
     ).error(|e| { e
         .assert_num(3)
         .assert_occurs_at(0, "exit;").assert_msg_has(0, "skips over a variable")
         .assert_occurs_at(1, "exit:").assert_msg_has(1, "jumps to this label")
         .assert_occurs_at(2, "v = 0").assert_msg_has(2, "skips over this variable");
     });
     Tester::new_single_source_expect_err(
         "goto jumping into scope",
         "func f() -> u32 {
             goto nested;
+            {
                 nested: return 0;
+            }
             return 1;
         }"
     ).error(|e| { e
         .assert_num(1)
         .assert_occurs_at(0, "nested;")
         .assert_msg_has(0, "could not find this label");
     });
     Tester::new_single_source_expect_err(
         "goto jumping outside sync",
-        "primitive f() {
+        "comp f() {
             sync { goto exit; }
             exit: u32 v = 0;
         }"
     ).error(|e| { e
         .assert_num(3)
         .assert_occurs_at(0, "goto exit;").assert_msg_has(0, "not escape the surrounding sync")
         .assert_occurs_at(1, "exit: u32 v").assert_msg_has(1, "target of the goto")
         .assert_occurs_at(2, "sync {").assert_msg_has(2, "jump past this");
     });
     Tester::new_single_source_expect_err(
         "goto jumping to select case",
-        "primitive f(in<u32> i) {
+        "comp f(in<u32> i) {
             sync select {
                 hello: auto a = get(i) -> i += 1
+            }
             goto hello;
         }"
     ).error(|e| { e
         .assert_msg_has(0, "expected '->'");
     });
     Tester::new_single_source_expect_err(
         "goto jumping into select case skipping variable",
-        "primitive f(in<u32> i) {
+        "comp f(in<u32> i) {
             goto waza;
             sync select {
                 auto a = get(i) -> {
                     waza: a += 1;
+                }
+            }
         }"
     ).error(|e| { e
         .assert_num(1)
         .assert_msg_has(0, "not find this label")
         .assert_occurs_at(0, "waza;");
     });
+}
 #[test]
 fn test_incorrect_while_statement() {
     // Just testing the error cases caught at compile-time. Other ones need
     // evaluation testing
     Tester::new_single_source_expect_err(
         "break wrong earlier loop",
         "func f() -> u32 {
             target: while (true) {}
             while (true) { break target; }
             return 0;
         }"
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "target; }").assert_msg_has(0, "not nested under the target")
         .assert_occurs_at(1, "target: while").assert_msg_has(1, "is found here");
     });
     Tester::new_single_source_expect_err(
         "break wrong later loop",
         "func f() -> u32 {
             while (true) { break target; }
             target: while (true) {}
             return 0;
         }"
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "target; }").assert_msg_has(0, "not nested under the target")
         .assert_occurs_at(1, "target: while").assert_msg_has(1, "is found here");
     });
     Tester::new_single_source_expect_err(
         "break outside of sync",
-        "primitive f() {
+        "comp f() {
             outer: while (true) { //mark
                 sync while(true) { break outer; }
+            }
         }"
     ).error(|e| { e
         .assert_num(3)
         .assert_occurs_at(0, "break outer;").assert_msg_has(0, "may not escape the surrounding")
         .assert_occurs_at(1, "while (true) { //mark").assert_msg_has(1, "escapes out of this loop")
         .assert_occurs_at(2, "sync while").assert_msg_has(2, "escape this synchronous block");
     });
+}
@@ \ No newline at end of file @@

src/runtime/tests/api_component.rs

➞

Show inline comments

 // Testing the api component.
 //
 // These tests explicitly do not use the "NUM_INSTANCES" constant because we're
 // doing some communication with the native component. Hence only expect one
 use super::*;
 #[test]
 fn test_put_and_get() {
     const CODE: &'static str = "
-    primitive handler(in<u32> request, out<u32> response, u32 loops) {
+    comp handler(in<u32> request, out<u32> response, u32 loops) {
         u32 index = 0;
         while (index < loops) {
             sync {
                 auto value = get(request);
                 put(response, value * 2);
+            }
             index += 1;
+        }
+    }
     ";
     let pd = ProtocolDescription::parse(CODE.as_bytes()).unwrap();
     let rt = Runtime::new(NUM_THREADS, pd);
     let mut api = rt.create_interface();
     let req_chan = api.create_channel().unwrap();
     let resp_chan = api.create_channel().unwrap();
     api.create_connector("", "handler", ValueGroup::new_stack(vec![
         Value::Input(PortId::new(req_chan.getter_id.index)),
         Value::Output(PortId::new(resp_chan.putter_id.index)),
         Value::UInt32(NUM_LOOPS),
     ])).unwrap();
     for loop_idx in 0..NUM_LOOPS {
         api.perform_sync_round(vec![
             ApplicationSyncAction::Put(req_chan.putter_id, ValueGroup::new_stack(vec![Value::UInt32(loop_idx)])),
             ApplicationSyncAction::Get(resp_chan.getter_id)
         ]).expect("start sync round");
         let result = api.wait().expect("finish sync round");
         assert!(result.len() == 1);
         if let Value::UInt32(gotten) = result[0].values[0] {
             assert_eq!(gotten, loop_idx * 2);
         } else {
             assert!(false);
+        }
+    }
+}
 #[test]
 fn test_getting_from_component() {
     const CODE: &'static str ="
-    primitive loop_sender(out<u32> numbers, u32 cur, u32 last) {
+    comp loop_sender(out<u32> numbers, u32 cur, u32 last) {
         while (cur < last) {
             sync {
                 put(numbers, cur);
                 cur += 1;
+            }
+        }
     }";
     let pd = ProtocolDescription::parse(CODE.as_bytes()).unwrap();
     let rt = Runtime::new(NUM_THREADS, pd);
     let mut api = rt.create_interface();
     let channel = api.create_channel().unwrap();
     api.create_connector("", "loop_sender", ValueGroup::new_stack(vec![
         Value::Output(PortId::new(channel.putter_id.index)),
         Value::UInt32(1337),
         Value::UInt32(1337 + NUM_LOOPS)
     ])).unwrap();
     for loop_idx in 0..NUM_LOOPS {
         api.perform_sync_round(vec![
             ApplicationSyncAction::Get(channel.getter_id),
         ]).expect("start sync round");
         let result = api.wait().expect("finish sync round");
         assert!(result.len() == 1 && result[0].values.len() == 1);
         if let Value::UInt32(gotten) = result[0].values[0] {
             assert_eq!(gotten, 1337 + loop_idx);
         } else {
             assert!(false);
+        }
+    }
+}
 #[test]
 fn test_putting_to_component() {
     const CODE: &'static str = "
-    primitive loop_receiver(in<u32> numbers, u32 cur, u32 last) {
+    comp loop_receiver(in<u32> numbers, u32 cur, u32 last) {
         while (cur < last) {
             sync {
                 auto number = get(numbers);
                 assert(number == cur);
                 cur += 1;
+            }
+        }
+    }
     ";
     let pd = ProtocolDescription::parse(CODE.as_bytes()).unwrap();
     let rt = Runtime::new(NUM_THREADS, pd);
     let mut api = rt.create_interface();
     let channel = api.create_channel().unwrap();
     api.create_connector("", "loop_receiver", ValueGroup::new_stack(vec![
         Value::Input(PortId::new(channel.getter_id.index)),
         Value::UInt32(42),
         Value::UInt32(42 + NUM_LOOPS)
     ])).unwrap();
     for loop_idx in 0..NUM_LOOPS {
         api.perform_sync_round(vec![
             ApplicationSyncAction::Put(channel.putter_id, ValueGroup::new_stack(vec![Value::UInt32(42 + loop_idx)])),
         ]).expect("start sync round");
         // Note: if we finish a round, then it must have succeeded :)
         api.wait().expect("finish sync round");
+    }
+}
 #[test]
 fn test_doing_nothing() {
     const CODE: &'static str = "
-    primitive getter(in<bool> input, u32 num_loops) {
+    comp getter(in<bool> input, u32 num_loops) {
         u32 index = 0;
         while (index < num_loops) {
             sync {}
             sync { auto res = get(input); assert(res); }
             index += 1;
+        }
+    }
     ";
     let pd = ProtocolDescription::parse(CODE.as_bytes()).unwrap();
     let rt = Runtime::new(NUM_THREADS, pd);
     let mut api = rt.create_interface();
     let channel = api.create_channel().unwrap();
     api.create_connector("", "getter", ValueGroup::new_stack(vec![
         Value::Input(PortId::new(channel.getter_id.index)),
         Value::UInt32(NUM_LOOPS),
     ])).unwrap();
     for _ in 0..NUM_LOOPS {
         api.perform_sync_round(vec![]).expect("start silent sync round");
         api.wait().expect("finish silent sync round");
         api.perform_sync_round(vec![
             ApplicationSyncAction::Put(channel.putter_id, ValueGroup::new_stack(vec![Value::Bool(true)]))
         ]).expect("start firing sync round");
         let res = api.wait().expect("finish firing sync round");
         assert!(res.is_empty());
+    }
+}
@@ \ No newline at end of file @@

src/runtime/tests/data_transmission.rs

➞

Show inline comments

 // basics.rs
 //
 // The most basic of testing: sending a message, receiving a message, etc.
 use super::*;
 #[test]
 fn test_doing_nothing() {
     // If this thing does not get into an infinite loop, (hence: the runtime
     // exits), then the test works
     const CODE: &'static str ="
-    primitive silent_willy(u32 loops) {
+    comp silent_willy(u32 loops) {
         u32 index = 0;
         while (index < loops) {
             sync { index += 1; }
+        }
+    }
     ";
     let _timer = TestTimer::new("doing_nothing");
     run_test_in_runtime(CODE, |api| {
         api.create_connector("", "silent_willy", ValueGroup::new_stack(vec![
             Value::UInt32(NUM_LOOPS),
         ])).expect("create component");
     });
+}
 #[test]
 fn test_single_put_and_get() {
     const CODE: &'static str = "
-    primitive putter(out<bool> sender, u32 loops) {
+    comp putter(out<bool> sender, u32 loops) {
         u32 index = 0;
         while (index < loops) {
             sync {
                 put(sender, true);
+            }
             index += 1;
+        }
+    }
-    primitive getter(in<bool> receiver, u32 loops) {
+    comp getter(in<bool> receiver, u32 loops) {
         u32 index = 0;
         while (index < loops) {
             sync {
                 auto result = get(receiver);
                 assert(result);
+            }
             index += 1;
+        }
+    }
     ";
     let _timer = TestTimer::new("single_put_and_get");
     run_test_in_runtime(CODE, |api| {
         let channel = api.create_channel().unwrap();
         api.create_connector("", "putter", ValueGroup::new_stack(vec![
             Value::Output(PortId::new(channel.putter_id.index)),
             Value::UInt32(NUM_LOOPS)
         ])).expect("create putter");
         api.create_connector("", "getter", ValueGroup::new_stack(vec![
             Value::Input(PortId::new(channel.getter_id.index)),
             Value::UInt32(NUM_LOOPS)
         ])).expect("create getter");
     });
+}
 #[test]
 fn test_combined_put_and_get() {
     const CODE: &'static str = "
-    primitive put_then_get(out<bool> output, in<bool> input, u32 num_loops) {
+    comp put_then_get(out<bool> output, in<bool> input, u32 num_loops) {
         u32 index = 0;
         while (index < num_loops) {
             sync {
                 put(output, true);
                 auto value = get(input);
                 assert(value);
                 index += 1;
+            }
+        }
+    }
-    composite constructor(u32 num_loops) {
+    comp constructor(u32 num_loops) {
         channel output_a -> input_a;
         channel output_b -> input_b;
         new put_then_get(output_a, input_b, num_loops);
         new put_then_get(output_b, input_a, num_loops);
+    }
     ";
     run_test_in_runtime(CODE, |api| {
         api.create_connector("", "constructor", ValueGroup::new_stack(vec![
             Value::UInt32(NUM_LOOPS),
         ])).expect("create connector");
     })
+}
 #[test]
 fn test_multi_put_and_get() {
     const CODE: &'static str = "
-    primitive putter_static(out<u8> vals, u32 num_loops) {
+    comp putter_static(out<u8> vals, u32 num_loops) {
         u32 index = 0;
         while (index < num_loops) {
             sync {
                 put(vals, 0b00000001);
                 put(vals, 0b00000100);
                 put(vals, 0b00010000);
                 put(vals, 0b01000000);
+            }
             index += 1;
+        }
+    }
-    primitive getter_dynamic(in<u8> vals, u32 num_loops) {
+    comp getter_dynamic(in<u8> vals, u32 num_loops) {
         u32 loop_index = 0;
         while (loop_index < num_loops) {
             sync {
                 u32 recv_index = 0;
                 u8 expected = 1;
                 while (recv_index < 4) {
                     auto gotten = get(vals);
                     assert(gotten == expected);
                     expected <<= 2;
                     recv_index += 1;
+                }
+            }
             loop_index += 1;
+        }
+    }
     ";
     let _timer = TestTimer::new("multi_put_and_get");
     run_test_in_runtime(CODE, |api| {
         let channel = api.create_channel().unwrap();
         api.create_connector("", "putter_static", ValueGroup::new_stack(vec![
             Value::Output(PortId::new(channel.putter_id.index)),
             Value::UInt32(NUM_LOOPS),
         ])).unwrap();
         api.create_connector("", "getter_dynamic", ValueGroup::new_stack(vec![
             Value::Input(PortId::new(channel.getter_id.index)),
             Value::UInt32(NUM_LOOPS),
         ])).unwrap();
     })
+}
@@ \ No newline at end of file @@

src/runtime/tests/network_shapes.rs

➞

Show inline comments

 // Testing particular graph shapes
 use super::*;
 #[test]
 fn test_star_shaped_request() {
     const CODE: &'static str = "
-    primitive edge(in<u32> input, out<u32> output, u32 loops) {
+    comp edge(in<u32> input, out<u32> output, u32 loops) {
         u32 index = 0;
         while (index < loops) {
             sync {
                 auto req = get(input);
                 put(output, req * 2);
+            }
             index += 1;
+        }
+    }
-    primitive center(out<u32>[] requests, in<u32>[] responses, u32 loops) {
+    comp center(out<u32>[] requests, in<u32>[] responses, u32 loops) {
         u32 loop_index = 0;
         auto num_edges = length(requests);
         while (loop_index < loops) {
             // print(\"starting loop\");
             sync {
                 u32 edge_index = 0;
                 u32 sum = 0;
                 while (edge_index < num_edges) {
                     put(requests[edge_index], edge_index);
                     auto response = get(responses[edge_index]);
                     sum += response;
                     edge_index += 1;
+                }
                 assert(sum == num_edges * (num_edges - 1));
+            }
             // print(\"ending loop\");
             loop_index += 1;
+        }
+    }
-    composite constructor(u32 num_edges, u32 num_loops) {
+    comp constructor(u32 num_edges, u32 num_loops) {
         auto requests = {};
         auto responses = {};
         u32 edge_index = 0;
         while (edge_index < num_edges) {
             channel req_put -> req_get;
             channel resp_put -> resp_get;
             new edge(req_get, resp_put, num_loops);
             requests @= { req_put };
             responses @= { resp_get };
             edge_index += 1;
+        }
         new center(requests, responses, num_loops);
+    }
     ";
     let _timer = TestTimer::new("star_shaped_request");
     run_test_in_runtime(CODE, |api| {
         api.create_connector("", "constructor", ValueGroup::new_stack(vec![
             Value::UInt32(5),
             Value::UInt32(NUM_LOOPS),
         ])).expect("create connector");
     });
+}
 #[test]
 fn test_conga_line_request() {
     const CODE: &'static str = "
-    primitive start(out<u32> req, in<u32> resp, u32 num_nodes, u32 num_loops) {
+    comp start(out<u32> req, in<u32> resp, u32 num_nodes, u32 num_loops) {
         u32 loop_index = 0;
         u32 initial_value = 1337;
         while (loop_index < num_loops) {
             sync {
                 put(req, initial_value);
                 auto result = get(resp);
                 assert(result == initial_value + num_nodes * 2);
+            }
             loop_index += 1;
+        }
+    }
-    primitive middle(
+    comp middle(
         in<u32> req_in, out<u32> req_forward,
         in<u32> resp_in, out<u32> resp_forward,
         u32 num_loops
     ) {
         u32 loop_index = 0;
         while (loop_index < num_loops) {
             sync {
                 auto req = get(req_in);
                 put(req_forward, req + 1);
                 auto resp = get(resp_in);
                 put(resp_forward, resp + 1);
+            }
             loop_index += 1;
+        }
+    }
-    primitive end(in<u32> req_in, out<u32> resp_out, u32 num_loops) {
+    comp end(in<u32> req_in, out<u32> resp_out, u32 num_loops) {
         u32 loop_index = 0;
         while (loop_index < num_loops) {
             sync {
                 auto req = get(req_in);
                 put(resp_out, req);
+            }
             loop_index += 1;
+        }
+    }
-    composite constructor(u32 num_nodes, u32 num_loops) {
+    comp constructor(u32 num_nodes, u32 num_loops) {
         channel initial_req -> req_in;
         channel resp_out -> final_resp;
         new start(initial_req, final_resp, num_nodes, num_loops);
         in<u32> last_req_in = req_in;
         out<u32> last_resp_out = resp_out;
         u32 node = 0;
         while (node < num_nodes) {
             channel new_req_fw -> new_req_in;
             channel new_resp_out -> new_resp_in;
             new middle(last_req_in, new_req_fw, new_resp_in, last_resp_out, num_loops);
             last_req_in = new_req_in;
             last_resp_out = new_resp_out;
             node += 1;
+        }
         new end(last_req_in, last_resp_out, num_loops);
+    }
     ";
     let _timer = TestTimer::new("conga_line_request");
     run_test_in_runtime(CODE, |api| {
         api.create_connector("", "constructor", ValueGroup::new_stack(vec![
             Value::UInt32(1),
             Value::UInt32(NUM_LOOPS)
         ])).expect("create connector");
     });
+}
@@ \ No newline at end of file @@

src/runtime/tests/speculation.rs

➞

Show inline comments

 // Testing speculation - Basic forms
 use super::*;
 #[test]
 fn test_maybe_do_nothing() {
     // Three variants in which the behaviour in which nothing is performed is
     // somehow not allowed. Note that we "check" by seeing if the test finishes.
     // Only the branches in which ports fire increment the loop index
     const CODE: &'static str = "
-    primitive only_puts(out<bool> output, u32 num_loops) {
+    comp only_puts(out<bool> output, u32 num_loops) {
         u32 index = 0;
         while (index < num_loops) {
             sync { put(output, true); }
             index += 1;
+        }
+    }
-    primitive might_put(out<bool> output, u32 num_loops) {
+    comp might_put(out<bool> output, u32 num_loops) {
         u32 index = 0;
         while (index < num_loops) {
             sync {
                 fork { put(output, true); index += 1; }
                 or   {}
+            }
+        }
+    }
-    primitive only_gets(in<bool> input, u32 num_loops) {
+    comp only_gets(in<bool> input, u32 num_loops) {
         u32 index = 0;
         while (index < num_loops) {
             sync { auto res = get(input); assert(res); }
             index += 1;
+        }
+    }
-    primitive might_get(in<bool> input, u32 num_loops) {
+    comp might_get(in<bool> input, u32 num_loops) {
         u32 index = 0;
         while (index < num_loops) {
             sync fork { auto res = get(input); assert(res); index += 1; } or {}
+        }
+    }
     ";
     // Construct all variants which should work and wait until the runtime exits
     run_test_in_runtime(CODE, |api| {
         // only putting -> maybe getting
         let channel = api.create_channel().unwrap();
         api.create_connector("", "only_puts", ValueGroup::new_stack(vec![
             Value::Output(PortId::new(channel.putter_id.index)),
             Value::UInt32(NUM_LOOPS),
         ])).unwrap();
         api.create_connector("", "might_get", ValueGroup::new_stack(vec![
             Value::Input(PortId::new(channel.getter_id.index)),
             Value::UInt32(NUM_LOOPS),
         ])).unwrap();
         // maybe putting -> only getting
         let channel = api.create_channel().unwrap();
         api.create_connector("", "might_put", ValueGroup::new_stack(vec![
             Value::Output(PortId::new(channel.putter_id.index)),
             Value::UInt32(NUM_LOOPS),
         ])).unwrap();
         api.create_connector("", "only_gets", ValueGroup::new_stack(vec![
             Value::Input(PortId::new(channel.getter_id.index)),
             Value::UInt32(NUM_LOOPS),
         ])).unwrap();
     })
+}
@@ \ No newline at end of file @@

src/runtime/tests/sync_failure.rs

➞

Show inline comments

 // sync_failure.rs
 //
 // Various tests to ensure that failing components fail in a consistent way.
 use super::*;
 #[test]
 fn test_local_sync_failure() {
     // If the component exits cleanly, then the runtime exits cleanly, and the
     // test will finish
     const CODE: &'static str = "
-    primitive immediate_failure_inside_sync() {
+    comp immediate_failure_inside_sync() {
         u32[] only_allows_index_0 = { 1 };
         while (true) sync { // note the infinite loop
             auto value = only_allows_index_0[1];
+        }
+    }
-    primitive immediate_failure_outside_sync() {
+    comp immediate_failure_outside_sync() {
         u32[] only_allows_index_0 = { 1 };
         auto never_gonna_get = only_allows_index_0[1];
         while (true) sync {}
+    }
     ";
     // let thing = TestTimer::new("local_sync_failure");
     run_test_in_runtime(CODE, |api| {
         api.create_connector("", "immediate_failure_outside_sync", ValueGroup::new_stack(Vec::new()))
             .expect("create component");
         api.create_connector("", "immediate_failure_inside_sync", ValueGroup::new_stack(Vec::new()))
             .expect("create component");
     })
+}
 const SHARED_SYNC_CODE: &'static str = "
 enum Location { BeforeSync, AfterPut, AfterGet, AfterSync, Never }
-primitive failing_at_location(in<bool> input, out<bool> output, Location loc) {
+comp failing_at_location(in<bool> input, out<bool> output, Location loc) {
     u32[] failure_array = {};
     while (true) {
         if (loc == Location::BeforeSync) failure_array[0];
         sync {
             put(output, true);
             if (loc == Location::AfterPut) failure_array[0];
             auto received = get(input);
             assert(received);
             if (loc == Location::AfterGet) failure_array[0];
+        }
         if (loc == Location::AfterSync) failure_array[0];
+    }
+}
-composite constructor_pair_a(Location loc) {
+comp constructor_pair_a(Location loc) {
     channel output_a -> input_a;
     channel output_b -> input_b;
     new failing_at_location(input_b, output_a, loc);
     new failing_at_location(input_a, output_b, Location::Never);
+}
-composite constructor_pair_b(Location loc) {
+comp constructor_pair_b(Location loc) {
     channel output_a -> input_a;
     channel output_b -> input_b;
     new failing_at_location(input_b, output_a, Location::Never);
     new failing_at_location(input_a, output_b, loc);
+}
-composite constructor_ring(u32 ring_size, u32 fail_a, Location loc_a, u32 fail_b, Location loc_b) {
+comp constructor_ring(u32 ring_size, u32 fail_a, Location loc_a, u32 fail_b, Location loc_b) {
     channel output_first -> input_old;
     channel output_cur -> input_new;
     u32 ring_index = 0;
     while (ring_index < ring_size) {
         auto cur_loc = Location::Never;
         if (ring_index == fail_a) cur_loc = loc_a;
         if (ring_index == fail_b) cur_loc = loc_b;
         new failing_at_location(input_old, output_cur, cur_loc);
         if (ring_index == ring_size - 2) {
             // Don't create a new channel, join up the last one
             output_cur = output_first;
             input_old = input_new;
         } else if (ring_index != ring_size - 1) {
             channel output_fresh -> input_fresh;
             input_old = input_new;
             output_cur = output_fresh;
             input_new = input_fresh;
+        }
         ring_index += 1;
+    }
+}
 ";
 #[test]
 fn test_shared_sync_failure_pair_variant_a() {
     // One fails, the other one should somehow detect it and fail as well. This
     // variant constructs the failing component first.
     run_test_in_runtime(SHARED_SYNC_CODE, |api| {
         for variant in 0..4 { // all `Location` enum variants, except `Never`.
             // Create the channels
             api.create_connector("", "constructor_pair_a", ValueGroup::new_stack(vec![
                 Value::Enum(variant)
             ])).expect("create connector");
+        }
     })
+}
 #[test]
 fn test_shared_sync_failure_pair_variant_b() {
     // One fails, the other one should somehow detect it and fail as well. This
     // variant constructs the successful component first.
     run_test_in_runtime(SHARED_SYNC_CODE, |api| {
         for variant in 0..4 {
             api.create_connector("", "constructor_pair_b", ValueGroup::new_stack(vec![
                 Value::Enum(variant)
             ])).expect("create connector");
+        }
     })
+}
 #[test]
 fn test_shared_sync_failure_ring_variant_a() {
     // Only one component in the ring should fail
     const RING_SIZE: u32 = 4;
     run_test_in_runtime(SHARED_SYNC_CODE, |api| {
         for variant in 0..4 {
             api.create_connector("", "constructor_ring", ValueGroup::new_stack(vec![
                 Value::UInt32(RING_SIZE),
                 Value::UInt32(RING_SIZE / 2), Value::Enum(variant), // fail "halfway" the ring
                 Value::UInt32(RING_SIZE), Value::Enum(0), // never occurs, index is equal to ring size
             ])).expect("create connector");
+        }
     })
+}
@@ \ No newline at end of file @@

src/runtime2/component/component.rs

➞

Show inline comments

 /*
  * Default toolkit for creating components. Contains handlers for initiating and
  * responding to various events.
  */
 use std::fmt::{Display as FmtDisplay, Result as FmtResult, Formatter};
 use crate::protocol::eval::{Prompt, EvalError, ValueGroup, Value, ValueId, PortId as EvalPortId};
 use crate::protocol::*;
 use crate::runtime2::*;
 use crate::runtime2::communication::*;
 use super::{CompCtx, CompPDL, CompId};
 use super::component_context::*;
 use super::component_random::*;
 use super::component_internet::*;
 use super::control_layer::*;
 use super::consensus::*;
 pub enum CompScheduling {
     Immediate,
     Requeue,
     Sleep,
     Exit,
+}
 /// Potential error emitted by a component
 pub enum CompError {
     /// Error originating from the code executor. Hence has an associated
     /// source location.
     Executor(EvalError),
     /// Error originating from a component, but not necessarily associated with
     /// a location in the source.
     Component(String), // TODO: Maybe a different embedded value in the future?
     /// Pure runtime error. Not necessarily originating from the component
     /// itself. Should be treated as a very severe runtime-compromising error.
     Runtime(RtError),
+}
 impl FmtDisplay for CompError {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         match self {
             CompError::Executor(v) => v.fmt(f),
             CompError::Component(v) => v.fmt(f),
             CompError::Runtime(v) => v.fmt(f),
+        }
+    }
+}
 /// Generic representation of a component (as viewed by a scheduler).
 pub(crate) trait Component {
     /// Called upon the creation of the component. Note that the scheduler
     /// context is officially running another component (the component that is
     /// creating the new component).
     fn on_creation(&mut self, comp_id: CompId, sched_ctx: &SchedulerCtx);
     /// Called when a component crashes or wishes to exit. So is not called
     /// right before destruction, other components may still hold a handle to
     /// the component and send it messages!
     fn on_shutdown(&mut self, sched_ctx: &SchedulerCtx);
     /// Called if the component is created by another component and the messages
     /// are being transferred between the two.
     fn adopt_message(&mut self, comp_ctx: &mut CompCtx, message: DataMessage);
     /// Called if the component receives a new message. The component is
     /// responsible for deciding where that messages goes.
     fn handle_message(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx, message: Message);
     /// Called if the component's routine should be executed. The return value
     /// can be used to indicate when the routine should be run again.
     fn run(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx) -> CompScheduling;
+}
 /// Representation of the generic operating mode of a component. Although not
 /// every state may be used by every kind of (builtin) component, this allows
 /// writing standard handlers for particular events in a component's lifetime.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub(crate) enum CompMode {
     NonSync, // not in sync mode
     Sync, // in sync mode, can interact with other components
     SyncEnd, // awaiting a solution, i.e. encountered the end of the sync block
     BlockedGet, // blocked because we need to receive a message on a particular port
     BlockedPut, // component is blocked because the port is blocked
     BlockedSelect, // waiting on message to complete the select statement
     PutPortsBlockedTransferredPorts, // sending a message with ports, those sent ports are (partly) blocked
     PutPortsBlockedAwaitingAcks, // sent out PPC message for blocking transferred ports, now awaiting Acks
     PutPortsBlockedSendingPort, // sending a message with ports, message sent through a still-blocked port
     NewComponentBlocked, // waiting until ports are in the appropriate state to create a new component
     StartExit, // temporary state: if encountered then we start the shutdown process.
     BusyExit, // temporary state: waiting for Acks for all the closed ports, potentially waiting for sync round to finish
     Exit, // exiting: shutdown process started, now waiting until the reference count drops to 0
+}
 impl CompMode {
     pub(crate) fn is_in_sync_block(&self) -> bool {
         use CompMode::*;
         match self {
             Sync | SyncEnd | BlockedGet | BlockedPut | BlockedSelect |
                 PutPortsBlockedTransferredPorts |
                 PutPortsBlockedAwaitingAcks |
                 PutPortsBlockedSendingPort => true,
             NonSync | NewComponentBlocked | StartExit | BusyExit | Exit => false,
+        }
+    }
     pub(crate) fn is_busy_exiting(&self) -> bool {
         use CompMode::*;
         match self {
             NonSync | Sync | SyncEnd | BlockedGet | BlockedPut | BlockedSelect |
             PutPortsBlockedTransferredPorts |
             PutPortsBlockedAwaitingAcks |
             PutPortsBlockedSendingPort |
                 NewComponentBlocked => false,
             StartExit | BusyExit => true,
             Exit => false,
+        }
+    }
+}
 #[derive(Debug)]
 pub(crate) enum ExitReason {
     Termination, // regular termination of component
     ErrorInSync,
     ErrorNonSync,
+}
 impl ExitReason {
     pub(crate) fn is_in_sync(&self) -> bool {
         use ExitReason::*;
         match self {
             Termination | ErrorNonSync => false,
             ErrorInSync => true,
+        }
+    }
     pub(crate) fn is_error(&self) -> bool {
         use ExitReason::*;
         match self {
             Termination => false,
             ErrorInSync | ErrorNonSync => true,
+        }
+    }
+}
 /// Component execution state: the execution mode along with some descriptive
 /// fields. Fields are public for ergonomic reasons, use member functions when
 /// appropriate.
 pub(crate) struct CompExecState {
     pub mode: CompMode,
     pub mode_port: PortId, // valid if blocked on a port (put/get)
     pub mode_value: ValueGroup, // valid if blocked on a put
     pub mode_component: (ProcedureDefinitionId, TypeId),
     pub exit_reason: ExitReason, // valid if in StartExit/BusyExit/Exit mode
+}
 impl CompExecState {
     pub(crate) fn new() -> Self {
         return Self{
             mode: CompMode::NonSync,
             mode_port: PortId::new_invalid(),
             mode_value: ValueGroup::default(),
             mode_component: (ProcedureDefinitionId::new_invalid(), TypeId::new_invalid()),
             exit_reason: ExitReason::Termination,
+        }
+    }
     pub(crate) fn set_as_start_exit(&mut self, reason: ExitReason) {
         self.mode = CompMode::StartExit;
         self.exit_reason = reason;
+    }
     pub(crate) fn set_as_blocked_get(&mut self, port: PortId) {
         self.mode = CompMode::BlockedGet;
         self.mode_port = port;
         debug_assert!(self.mode_value.values.is_empty());
+    }
     pub(crate) fn set_as_create_component_blocked(
         &mut self, proc_id: ProcedureDefinitionId, type_id: TypeId,
         arguments: ValueGroup
     ) {
         self.mode = CompMode::NewComponentBlocked;
         self.mode_value = arguments;
         self.mode_component = (proc_id, type_id);
+    }
     pub(crate) fn is_blocked_on_get(&self, port: PortId) -> bool {
         return
             self.mode == CompMode::BlockedGet &&
             self.mode_port == port;
+    }
     pub(crate) fn set_as_blocked_put_without_ports(&mut self, port: PortId, value: ValueGroup) {
         self.mode = CompMode::BlockedPut;
         self.mode_port = port;
         self.mode_value = value;
+    }
     pub(crate) fn set_as_blocked_put_with_ports(&mut self, port: PortId, value: ValueGroup) {
         self.mode = CompMode::PutPortsBlockedTransferredPorts;
         self.mode_port = port;
         self.mode_value = value;
+    }
     pub(crate) fn is_blocked_on_put_without_ports(&self, port: PortId) -> bool {
         return
             self.mode == CompMode::BlockedPut &&
             self.mode_port == port;
+    }
     pub(crate) fn is_blocked_on_create_component(&self) -> bool {
         return self.mode == CompMode::NewComponentBlocked;
+    }
+}
 // TODO: Replace when implementing port sending. Should probably be incorporated
 //  into CompCtx (and rename CompCtx into CompComms)
 pub(crate) type InboxMain = Vec<Option<DataMessage>>;
 pub(crate) type InboxMainRef = [Option<DataMessage>];
 pub(crate) type InboxBackup = Vec<DataMessage>;
 /// Creates a new component based on its definition. Meaning that if it is a
 /// user-defined component then we set up the PDL code state. Otherwise we
 /// construct a custom component. This does NOT take care of port and message
 /// management.
 pub(crate) fn create_component(
     protocol: &ProtocolDescription,
     definition_id: ProcedureDefinitionId, type_id: TypeId,
     arguments: ValueGroup, num_ports: usize
 ) -> Box<dyn Component> {
     let definition = &protocol.heap[definition_id];
-    debug_assert!(definition.kind == ProcedureKind::Primitive || definition.kind == ProcedureKind::Composite);
+    debug_assert_eq!(definition.kind, ProcedureKind::Component);
     if definition.source.is_builtin() {
         // Builtin component
         let component: Box<dyn Component> = match definition.source {
             ProcedureSource::CompRandomU32 => Box::new(ComponentRandomU32::new(arguments)),
             ProcedureSource::CompTcpClient => Box::new(ComponentTcpClient::new(arguments)),
             ProcedureSource::CompTcpListener => Box::new(ComponentTcpListener::new(arguments)),
             _ => unreachable!(),
         };
         return component;
     } else {
         // User-defined component
         let prompt = Prompt::new(
             &protocol.types, &protocol.heap,
             definition_id, type_id, arguments
         );
         let component = CompPDL::new(prompt, num_ports);
         return Box::new(component);
+    }
+}
 // -----------------------------------------------------------------------------
 // Generic component messaging utilities (for sending and receiving)
 // -----------------------------------------------------------------------------
 /// Default handling of sending a data message. In case the port is blocked then
 /// the `ExecState` will become blocked as well. Note that
 /// `default_handle_control_message` will ensure that the port becomes
 /// unblocked if so instructed by the receiving component. The returned
 /// scheduling value must be used.
 #[must_use]
 pub(crate) fn default_send_data_message(
     exec_state: &mut CompExecState, transmitting_port_id: PortId,
     port_instruction: PortInstruction, value: ValueGroup,
     sched_ctx: &SchedulerCtx, consensus: &mut Consensus,
     control: &mut ControlLayer, comp_ctx: &mut CompCtx
 ) -> Result<CompScheduling, (PortInstruction, String)> {
     debug_assert_eq!(exec_state.mode, CompMode::Sync);
     let port_handle = comp_ctx.get_port_handle(transmitting_port_id);
     let port_info = comp_ctx.get_port_mut(port_handle);
     port_info.last_instruction = port_instruction;
     let port_info = comp_ctx.get_port(port_handle);
     debug_assert_eq!(port_info.kind, PortKind::Putter);
     let mut ports = Vec::new();
     find_ports_in_value_group(&value, &mut ports);
     if port_info.state.is_closed() {
         // Note: normally peer is eventually consistent, but if it has shut down
         // then we can be sure it is consistent (I think?)
         return Err((
             port_info.last_instruction,
             format!("Cannot send on this port, as the peer (id:{}) has shut down", port_info.peer_comp_id.0)
         ))
     } else if !ports.is_empty() {
         start_send_message_with_ports(
             transmitting_port_id, port_instruction, value, exec_state,
             comp_ctx, sched_ctx, control
         )?;
         return Ok(CompScheduling::Sleep);
     } else if port_info.state.is_blocked() {
         // Port is blocked, so we cannot send
         exec_state.set_as_blocked_put_without_ports(transmitting_port_id, value);
         return Ok(CompScheduling::Sleep);
     } else {
         // Port is not blocked and no ports to transfer: send to the peer
         let peer_handle = comp_ctx.get_peer_handle(port_info.peer_comp_id);
         let peer_info = comp_ctx.get_peer(peer_handle);
         let annotated_message = consensus.annotate_data_message(comp_ctx, port_info, value);
         peer_info.handle.send_message_logged(sched_ctx, Message::Data(annotated_message), true);
         return Ok(CompScheduling::Immediate);
+    }
+}
 pub(crate) enum IncomingData {
     PlacedInSlot,
     SlotFull(DataMessage),
+}
 /// Default handling of receiving a data message. In case there is no room for
 /// the message it is returned from this function. Note that this function is
 /// different from PDL code performing a `get` on a port; this is the case where
 /// the message first arrives at the component.
 // NOTE: This is supposed to be a somewhat temporary implementation. It would be
 //  nicest if the sending component can figure out it cannot send any more data.
 #[must_use]
 pub(crate) fn default_handle_incoming_data_message(
     exec_state: &mut CompExecState, inbox_main: &mut InboxMain,
     comp_ctx: &mut CompCtx, incoming_message: DataMessage,
     sched_ctx: &SchedulerCtx, control: &mut ControlLayer
 ) -> IncomingData {
     let port_handle = comp_ctx.get_port_handle(incoming_message.data_header.target_port);
     let port_index = comp_ctx.get_port_index(port_handle);
     comp_ctx.get_port_mut(port_handle).received_message_for_sync = true;
     let port_value_slot = &mut inbox_main[port_index];
     let target_port_id = incoming_message.data_header.target_port;
     if port_value_slot.is_none() {
         // We can put the value in the slot
         *port_value_slot = Some(incoming_message);
         // Check if we're blocked on receiving this message.
         dbg_code!({
             // Our port cannot have been blocked itself, because we're able to
             // directly insert the message into its slot.
             assert!(!comp_ctx.get_port(port_handle).state.is_blocked());
         });
         if exec_state.is_blocked_on_get(target_port_id) {
             // Return to normal operation
             exec_state.mode = CompMode::Sync;
             exec_state.mode_port = PortId::new_invalid();
             debug_assert!(exec_state.mode_value.values.is_empty());
+        }
         return IncomingData::PlacedInSlot
     } else {
         // Slot is already full, so if the port was previously opened, it will
         // now become closed
         let port_info = comp_ctx.get_port_mut(port_handle);
         if port_info.state.is_open() {
             port_info.state.set(PortStateFlag::BlockedDueToFullBuffers);
             let (peer_handle, message) =
                 control.initiate_port_blocking(comp_ctx, port_handle);
             let peer = comp_ctx.get_peer(peer_handle);
             peer.handle.send_message_logged(sched_ctx, Message::Control(message), true);
+        }
         return IncomingData::SlotFull(incoming_message)
+    }
+}
 pub(crate) enum GetResult {
     Received(DataMessage),
     NoMessage,
     Error((PortInstruction, String)),
+}
 /// Default attempt at trying to receive from a port (i.e. through a `get`, or
 /// the equivalent operation for a builtin component). `target_port` is the port
 /// we're trying to receive from, and the `target_port_instruction` is the
 /// instruction we're attempting on this port.
 pub(crate) fn default_attempt_get(
     exec_state: &mut CompExecState, target_port: PortId, target_port_instruction: PortInstruction,
     inbox_main: &mut InboxMain, inbox_backup: &mut InboxBackup, sched_ctx: &SchedulerCtx,
     comp_ctx: &mut CompCtx, control: &mut ControlLayer, consensus: &mut Consensus
 ) -> GetResult {
     let port_handle = comp_ctx.get_port_handle(target_port);
     let port_index = comp_ctx.get_port_index(port_handle);
     let port_info = comp_ctx.get_port_mut(port_handle);
     port_info.last_instruction = target_port_instruction;
     if port_info.state.is_closed() {
         let peer_id = port_info.peer_comp_id;
         return GetResult::Error((
             target_port_instruction,
             format!("Cannot get from this port, as the peer component (id:{}) closed the port", peer_id.0)
         ));
+    }
     if let Some(message) = &inbox_main[port_index] {
         if consensus.try_receive_data_message(sched_ctx, comp_ctx, message) {
             // We're allowed to receive this message
             let mut message = inbox_main[port_index].take().unwrap();
             debug_assert_eq!(target_port, message.data_header.target_port);
             // Note: we can still run into an unrecoverable error when actually
             // receiving this message
             match default_handle_received_data_message(
                 target_port, target_port_instruction,
                 &mut message, inbox_main, inbox_backup,
                 comp_ctx, sched_ctx, control, consensus
             ) {
                 Ok(()) => return GetResult::Received(message),
                 Err(location_and_message) => return GetResult::Error(location_and_message)
+            }
         } else {
             // We're not allowed to receive this message. This means that the
             // receiver is attempting to receive something out of order with
             // respect to the sender.
             return GetResult::Error((target_port_instruction, String::from(
                 "Cannot get from this port, as this causes a deadlock. This happens if you `get` in a different order as another component `put`s"
             )));
+        }
     } else {
         // We don't have a message waiting for us and the port is not blocked.
         // So enter the BlockedGet state
         exec_state.set_as_blocked_get(target_port);
         return GetResult::NoMessage;
+    }
+}
 /// Default handling that has been received through a `get`. Will check if any
 /// more messages are waiting, and if the corresponding port was blocked because
 /// of full buffers (hence, will use the control layer to make sure the peer
 /// will become unblocked).
 pub(crate) fn default_handle_received_data_message(
     targeted_port: PortId, _port_instruction: PortInstruction, message: &mut DataMessage,
     inbox_main: &mut InboxMain, inbox_backup: &mut InboxBackup,
     comp_ctx: &mut CompCtx, sched_ctx: &SchedulerCtx, control: &mut ControlLayer,
     consensus: &mut Consensus
 ) -> Result<(), (PortInstruction, String)> {
     let port_handle = comp_ctx.get_port_handle(targeted_port);
     let port_index = comp_ctx.get_port_index(port_handle);
     debug_assert!(inbox_main[port_index].is_none()); // because we've just received from it
     // If we received any ports, add them to the port tracking and inbox struct.
     // Then notify the peers that they can continue sending to this port, but
     // now at a new address.
     for received_port in &mut message.ports {
         // Transfer messages to main/backup inbox
         let _new_inbox_index = inbox_main.len();
         if !received_port.messages.is_empty() {
             inbox_main.push(Some(received_port.messages.remove(0)));
             inbox_backup.extend(received_port.messages.drain(..));
         } else {
             inbox_main.push(None);
+        }
         // Create a new port locally
         let mut new_port_state = received_port.state;
         new_port_state.set(PortStateFlag::Received);
         let new_port_handle = comp_ctx.add_port(
             received_port.peer_comp, received_port.peer_port,
             received_port.kind, new_port_state
         );
         debug_assert_eq!(_new_inbox_index, comp_ctx.get_port_index(new_port_handle));
         comp_ctx.change_port_peer(sched_ctx, new_port_handle, Some(received_port.peer_comp));
         let new_port = comp_ctx.get_port(new_port_handle);
         // Add the port tho the consensus
-        consensus.notify_received_port(_new_inbox_index, new_port_handle, comp_ctx);
+        consensus.notify_of_new_port(_new_inbox_index, new_port_handle, comp_ctx);
         // Replace all references to the port in the received message
         for message_location in received_port.locations.iter().copied() {
             let value = message.content.get_value_mut(message_location);
             match value {
                 Value::Input(_) => {
                     debug_assert_eq!(new_port.kind, PortKind::Getter);
                     *value = Value::Input(port_id_to_eval(new_port.self_id));
                 },
                 Value::Output(_) => {
                     debug_assert_eq!(new_port.kind, PortKind::Putter);
                     *value = Value::Output(port_id_to_eval(new_port.self_id));
                 },
                 _ => unreachable!(),
+            }
+        }
         // Let the peer know that the port can now be used
         let peer_handle = comp_ctx.get_peer_handle(new_port.peer_comp_id);
         let peer_info = comp_ctx.get_peer(peer_handle);
         peer_info.handle.send_message_logged(sched_ctx, Message::Control(ControlMessage{
             id: ControlId::new_invalid(),
             sender_comp_id: comp_ctx.id,
             target_port_id: Some(new_port.peer_port_id),
             content: ControlMessageContent::PortPeerChangedUnblock(new_port.self_id, comp_ctx.id)
         }), true);
+    }
     // Modify last-known location where port instruction was retrieved
     let port_info = comp_ctx.get_port(port_handle);
     debug_assert_ne!(port_info.last_instruction, PortInstruction::None); // set by caller
     debug_assert!(port_info.state.is_open()); // checked by caller
     // Check if there are any more messages in the backup buffer
     for message_index in 0..inbox_backup.len() {
         let message = &inbox_backup[message_index];
         if message.data_header.target_port == targeted_port {
             // One more message, place it in the slot
             let message = inbox_backup.remove(message_index);
             debug_assert!(comp_ctx.get_port(port_handle).state.is_blocked()); // since we're removing another message from the backup
             inbox_main[port_index] = Some(message);
             return Ok(());
+        }
+    }
     // Did not have any more messages, so if we were blocked, then we need to
     // unblock the port now (and inform the peer of this unblocking)
     if port_info.state.is_set(PortStateFlag::BlockedDueToFullBuffers) {
         let port_info = comp_ctx.get_port_mut(port_handle);
         port_info.state.clear(PortStateFlag::BlockedDueToFullBuffers);
         let (peer_handle, message) = control.cancel_port_blocking(comp_ctx, port_handle);
         let peer_info = comp_ctx.get_peer(peer_handle);
         peer_info.handle.send_message_logged(sched_ctx, Message::Control(message), true);
+    }
     return Ok(());
+}
 /// Handles control messages in the default way. Note that this function may
 /// take a lot of actions in the name of the caller: pending messages may be
 /// sent, ports may become blocked/unblocked, etc. So the execution
 /// (`CompExecState`), control (`ControlLayer`) and consensus (`Consensus`)
 /// state may all change.
 pub(crate) fn default_handle_control_message(
     exec_state: &mut CompExecState, control: &mut ControlLayer, consensus: &mut Consensus,
     message: ControlMessage, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx,
     inbox_main: &mut InboxMain, inbox_backup: &mut InboxBackup
 ) -> Result<(), (PortInstruction, String)> {
     match message.content {
         ControlMessageContent::Ack => {
             default_handle_ack(exec_state, control, message.id, sched_ctx, comp_ctx, consensus, inbox_main, inbox_backup)?;
         },
         ControlMessageContent::BlockPort => {
             // One of our messages was accepted, but the port should be
             // blocked.
             let port_to_block = message.target_port_id.unwrap();
             let port_handle = comp_ctx.get_port_handle(port_to_block);
             let port_info = comp_ctx.get_port_mut(port_handle);
             debug_assert_eq!(port_info.kind, PortKind::Putter);
             port_info.state.set(PortStateFlag::BlockedDueToFullBuffers);
         },
         ControlMessageContent::ClosePort(content) => {
             // Request to close the port. We immediately comply and remove
             // the component handle as well
             let port_to_close = message.target_port_id.unwrap();
             let port_handle = comp_ctx.get_port_handle(port_to_close);
             // We're closing the port, so we will always update the peer of the
             // port (in case of error messages)
             let port_info = comp_ctx.get_port_mut(port_handle);
             port_info.peer_comp_id = message.sender_comp_id;
             port_info.close_at_sync_end = true; // might be redundant (we might set it closed now)
             let peer_comp_id = port_info.peer_comp_id;
             let peer_handle = comp_ctx.get_peer_handle(peer_comp_id);
             // One exception to sending an `Ack` is if we just closed the
             // port ourselves, meaning that the `ClosePort` messages got
             // sent to one another.
             if let Some(control_id) = control.has_close_port_entry(port_handle, comp_ctx) {
                 // The two components (sender and this component) are closing
                 // the channel at the same time. So we don't care about the
                 // content of the `ClosePort` message.
                 default_handle_ack(exec_state, control, control_id, sched_ctx, comp_ctx, consensus, inbox_main, inbox_backup)?;
             } else {
                 // Respond to the message
                 let port_info = comp_ctx.get_port(port_handle);
                 let last_instruction = port_info.last_instruction;
                 let port_has_had_message = port_info.received_message_for_sync;
                 default_send_ack(message.id, peer_handle, sched_ctx, comp_ctx);
                 comp_ctx.change_port_peer(sched_ctx, port_handle, None);
                 // Handle any possible error conditions (which boil down to: the
                 // port has been used, but the peer has died). If not in sync
                 // mode then we close the port immediately.
                 // Note that `port_was_used` does not mean that any messages
                 // were actually received. It might also mean that e.g. the
                 // component attempted a `get`, but there were no messages, so
                 // now it is in the `BlockedGet` state.
                 let port_was_used = last_instruction != PortInstruction::None;
                 if exec_state.mode.is_in_sync_block() {
                     let closed_during_sync_round = content.closed_in_sync_round && port_was_used;
                     let closed_before_sync_round = !content.closed_in_sync_round && !port_has_had_message && port_was_used;
                     if closed_during_sync_round || closed_before_sync_round {
                         return Err((
                             last_instruction,
                             format!("Peer component (id:{}) shut down, so communication cannot (have) succeed(ed)", peer_comp_id.0)
                         ));
+                    }
                 } else {
                     let port_info = comp_ctx.get_port_mut(port_handle);
                     port_info.state.set(PortStateFlag::Closed);
+                }
+            }
         },
         ControlMessageContent::UnblockPort => {
             // We were previously blocked (or already closed)
             let port_to_unblock = message.target_port_id.unwrap();
             let port_handle = comp_ctx.get_port_handle(port_to_unblock);
             let port_info = comp_ctx.get_port_mut(port_handle);
             debug_assert_eq!(port_info.kind, PortKind::Putter);
             debug_assert!(port_info.state.is_set(PortStateFlag::BlockedDueToFullBuffers));
             port_info.state.clear(PortStateFlag::BlockedDueToFullBuffers);
             default_handle_recently_unblocked_port(
                 exec_state, control, consensus, port_handle, sched_ctx,
                 comp_ctx, inbox_main, inbox_backup
             )?;
         },
         ControlMessageContent::PortPeerChangedBlock => {
             // The peer of our port has just changed. So we are asked to
             // temporarily block the port (while our original recipient is
             // potentially rerouting some of the in-flight messages) and
             // Ack. Then we wait for the `unblock` call.
             let port_to_change = message.target_port_id.unwrap();
             let port_handle = comp_ctx.get_port_handle(port_to_change);
             let port_info = comp_ctx.get_port_mut(port_handle);
             let peer_comp_id = port_info.peer_comp_id;
             port_info.state.set(PortStateFlag::BlockedDueToPeerChange);
             let peer_handle = comp_ctx.get_peer_handle(peer_comp_id);
             default_send_ack(message.id, peer_handle, sched_ctx, comp_ctx);
         },
         ControlMessageContent::PortPeerChangedUnblock(new_port_id, new_comp_id) => {
             let port_to_change = message.target_port_id.unwrap();
             let port_handle = comp_ctx.get_port_handle(port_to_change);
             let port_info = comp_ctx.get_port(port_handle);
             debug_assert!(port_info.state.is_set(PortStateFlag::BlockedDueToPeerChange));
             let port_info = comp_ctx.get_port_mut(port_handle);
             port_info.peer_port_id = new_port_id;
             port_info.state.clear(PortStateFlag::BlockedDueToPeerChange);
             comp_ctx.change_port_peer(sched_ctx, port_handle, Some(new_comp_id));
             default_handle_recently_unblocked_port(
                 exec_state, control, consensus, port_handle, sched_ctx,
                 comp_ctx, inbox_main, inbox_backup
             )?;
+        }
+    }
     return Ok(());
+}
 /// Handles a component entering the synchronous block. Will ensure that the
 /// `Consensus` and the `ComponentCtx` are initialized properly.
 pub(crate) fn default_handle_sync_start(
     exec_state: &mut CompExecState, inbox_main: &mut InboxMainRef,
     sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, consensus: &mut Consensus
 ) {
     sched_ctx.info("Component starting sync mode");
     // If any messages are present for this sync round, set the appropriate flag
     // and notify the consensus handler of the present messages
     consensus.notify_sync_start(comp_ctx);
     for (port_index, message) in inbox_main.iter().enumerate() {
         if let Some(message) = message {
             consensus.handle_incoming_data_message(comp_ctx, message);
             let port_info = comp_ctx.get_port_by_index_mut(port_index);
             port_info.received_message_for_sync = true;
+        }
+    }
     // Modify execution state
     debug_assert_eq!(exec_state.mode, CompMode::NonSync);
     exec_state.mode = CompMode::Sync;
+}
 /// Handles a component that has reached the end of the sync block. This does
 /// not necessarily mean that the component will go into the `NonSync` mode, as
 /// it might have to wait for the leader to finish the round for everyone (see
 /// `default_handle_sync_decision`)
 pub(crate) fn default_handle_sync_end(
     exec_state: &mut CompExecState, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx,
     consensus: &mut Consensus
 ) {
     sched_ctx.info("Component ending sync mode (but possibly waiting for a solution)");
     debug_assert_eq!(exec_state.mode, CompMode::Sync);
     let decision = consensus.notify_sync_end_success(sched_ctx, comp_ctx);
     exec_state.mode = CompMode::SyncEnd;
     default_handle_sync_decision(sched_ctx, exec_state, comp_ctx, decision, consensus);
+}
 /// Handles a component initiating the exiting procedure, and closing all of its
 /// ports. Should only be called once per component (which is ensured by
 /// checking and modifying the mode in the execution state).
 #[must_use]
 pub(crate) fn default_handle_start_exit(
     exec_state: &mut CompExecState, control: &mut ControlLayer,
     sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, consensus: &mut Consensus
 ) -> CompScheduling {
     debug_assert_eq!(exec_state.mode, CompMode::StartExit);
     for port_index in 0..comp_ctx.num_ports() {
         let port_info = comp_ctx.get_port_by_index_mut(port_index);
         if port_info.state.is_blocked() {
             return CompScheduling::Sleep;
+        }
+    }
     sched_ctx.info(&format!("Component starting exit (reason: {:?})", exec_state.exit_reason));
     exec_state.mode = CompMode::BusyExit;
     let exit_inside_sync = exec_state.exit_reason.is_in_sync();
     // If exiting while inside sync mode, report to the leader of the current
     // round that we've failed.
     if exit_inside_sync {
         let decision = consensus.notify_sync_end_failure(sched_ctx, comp_ctx);
         default_handle_sync_decision(sched_ctx, exec_state, comp_ctx, decision, consensus);
+    }
     // Iterating over ports by index to work around borrowing rules
     for port_index in 0..comp_ctx.num_ports() {
         let port = comp_ctx.get_port_by_index_mut(port_index);
         println!("DEBUG: Considering port:\n{:?}", port);
         if port.state.is_closed() || port.state.is_set(PortStateFlag::Transmitted) || port.close_at_sync_end {
             // Already closed, or in the process of being closed
             continue;
+        }
         // Mark as closed
         let port_id = port.self_id;
         port.state.set(PortStateFlag::Closed);
         // Notify peer of closing
         let port_handle = comp_ctx.get_port_handle(port_id);
         let (peer, message) = control.initiate_port_closing(port_handle, exit_inside_sync, comp_ctx);
         let peer_info = comp_ctx.get_peer(peer);
         peer_info.handle.send_message_logged(sched_ctx, Message::Control(message), true);
+    }
     return CompScheduling::Immediate; // to check if we can shut down immediately
+}
 /// Handles a component waiting until all peers are notified that it is quitting
 /// (i.e. after calling `default_handle_start_exit`).
 #[must_use]
 pub(crate) fn default_handle_busy_exit(
     exec_state: &mut CompExecState, control: &ControlLayer,
     sched_ctx: &SchedulerCtx
 ) -> CompScheduling {
     debug_assert_eq!(exec_state.mode, CompMode::BusyExit);
     if control.has_acks_remaining() {
         sched_ctx.info("Component busy exiting, still has `Ack`s remaining");
         return CompScheduling::Sleep;
     } else {
         sched_ctx.info("Component busy exiting, now shutting down");
         exec_state.mode = CompMode::Exit;
         return CompScheduling::Exit;
+    }
+}
 /// Handles a potential synchronous round decision. If there was a decision then
 /// the `Some(success)` value indicates whether the round succeeded or not.
 /// Might also end up changing the `ExecState`.
 ///
 /// Might be called in two cases:
 /// 1. The component is in regular execution mode, at the end of a sync round,
 ///     and is waiting for a solution to the round.
 /// 2. The component has encountered an error during a sync round and is
 ///     exiting, hence is waiting for a "Failure" message from the leader.
 pub(crate) fn default_handle_sync_decision(
     sched_ctx: &SchedulerCtx, exec_state: &mut CompExecState, comp_ctx: &mut CompCtx,
     decision: SyncRoundDecision, consensus: &mut Consensus
 ) -> Option<bool> {
     let success = match decision {
         SyncRoundDecision::None => return None,
         SyncRoundDecision::Solution => true,
         SyncRoundDecision::Failure => false,
     };
     debug_assert!(
         exec_state.mode == CompMode::SyncEnd || (
             exec_state.mode.is_busy_exiting() && exec_state.exit_reason.is_error()
         ) || (
             exec_state.mode.is_in_sync_block() && decision == SyncRoundDecision::Failure
+        )
     );
     sched_ctx.info(&format!("Handling decision {:?} (in mode: {:?})", decision, exec_state.mode));
     consensus.notify_sync_decision(decision);
     if success {
         // We cannot get a success message if the component has encountered an
         // error.
         for port_index in 0..comp_ctx.num_ports() {
             let port_info = comp_ctx.get_port_by_index_mut(port_index);
             if port_info.close_at_sync_end {
                 port_info.state.set(PortStateFlag::Closed);
+            }
             port_info.state.clear(PortStateFlag::Received);
+        }
         debug_assert_eq!(exec_state.mode, CompMode::SyncEnd);
         exec_state.mode = CompMode::NonSync;
         return Some(true);
     } else {
         // We may get failure both in all possible cases. But we should only
         // modify the execution state if we're not already in exit mode
         if !exec_state.mode.is_busy_exiting() {
             sched_ctx.error("failed synchronous round, initiating exit");
             exec_state.set_as_start_exit(ExitReason::ErrorNonSync);
+        }
         return Some(false);
+    }
+}
 /// Special component creation function. This function assumes that the
 /// transferred ports are NOT blocked, and that the channels to whom the ports
 /// belong are fully owned by the creating component. This will be checked in
 /// debug mode.
 pub(crate) fn special_create_component(
     exec_state: &mut CompExecState, sched_ctx: &SchedulerCtx, instantiator_ctx: &mut CompCtx,
     control: &mut ControlLayer, inbox_main: &mut InboxMain, inbox_backup: &mut InboxBackup,
     component_instance: Box<dyn Component>, component_ports: Vec<PortId>,
 ) {
     debug_assert_eq!(exec_state.mode, CompMode::NonSync);
     let reservation = sched_ctx.runtime.start_create_component();
     let mut created_ctx = CompCtx::new(&reservation);
     let mut port_pairs = Vec::new();
     // Retrieve ports
     for instantiator_port_id in component_ports.iter() {
         let instantiator_port_id = *instantiator_port_id;
         let instantiator_port_handle = instantiator_ctx.get_port_handle(instantiator_port_id);
         let instantiator_port = instantiator_ctx.get_port(instantiator_port_handle);
         // Check if conditions for calling this function are valid
         debug_assert!(!instantiator_port.state.is_blocked_due_to_port_change());
         debug_assert_eq!(instantiator_port.peer_comp_id, instantiator_ctx.id);
         // Create port at new component
         let created_port_handle = created_ctx.add_port(
             instantiator_port.peer_comp_id, instantiator_port.peer_port_id,
             instantiator_port.kind, instantiator_port.state
         );
         let created_port = created_ctx.get_port(created_port_handle);
         let created_port_id = created_port.self_id;
         // Store in port pairs
         let is_open = instantiator_port.state.is_open();
         port_pairs.push(PortPair{
             instantiator_id: instantiator_port_id,
             instantiator_handle: instantiator_port_handle,
             created_id: created_port_id,
             created_handle: created_port_handle,
             is_open,
         });
+    }
     // Set peer of the port for the new component
     for pair in port_pairs.iter() {
         let instantiator_port_info = instantiator_ctx.get_port(pair.instantiator_handle);
         let created_port_info = created_ctx.get_port_mut(pair.created_handle);
         // Note: we checked above (in debug mode) that the peer of the port is
         // owned by the creator as well, now check if the peer is transferred
         // as well.
         let created_port_peer_index = port_pairs.iter()
             .position(|v| v.instantiator_id == instantiator_port_info.peer_port_id);
         match created_port_peer_index {
             Some(created_port_peer_index) => {
                 // Both ends of the channel are moving to the new component
                 let peer_pair = &port_pairs[created_port_peer_index];
                 created_port_info.peer_port_id = peer_pair.created_id;
                 created_port_info.peer_comp_id = reservation.id();
             },
             None => {
                 created_port_info.peer_comp_id = instantiator_ctx.id;
                 if pair.is_open {
                     created_ctx.change_port_peer(sched_ctx, pair.created_handle, Some(instantiator_ctx.id));
+                }
+            }
+        }
+    }
     // Store component in runtime storage and retrieve component fields in their
     // name memory location
     let (created_key, created_runtime_component) = sched_ctx.runtime.finish_create_component(
         reservation, component_instance, created_ctx, false
     );
     let created_ctx = &mut created_runtime_component.ctx;
     let created_component = &mut created_runtime_component.component;
     created_component.on_creation(created_key.downgrade(), sched_ctx);
     // Transfer messages and link instantiator to created component
     for pair in port_pairs.iter() {
         instantiator_ctx.change_port_peer(sched_ctx, pair.instantiator_handle, None);
         transfer_messages(inbox_main, inbox_backup, pair, instantiator_ctx, created_ctx, created_component.as_mut());
         instantiator_ctx.remove_port(pair.instantiator_handle);
         let created_port_info = created_ctx.get_port(pair.created_handle);
         if pair.is_open && created_port_info.peer_comp_id == instantiator_ctx.id {
             // Set up channel between instantiator component port, and its peer,
             // which is owned by the new component
             let instantiator_port_handle = instantiator_ctx.get_port_handle(created_port_info.peer_port_id);
             let instantiator_port_info = instantiator_ctx.get_port_mut(instantiator_port_handle);
             instantiator_port_info.peer_port_id = created_port_info.self_id;
             instantiator_ctx.change_port_peer(sched_ctx, instantiator_port_handle, Some(created_ctx.id));
+        }
+    }
     // By definition we did not have any remote peers for the transferred ports,
     // so we can schedule the new component immediately
     sched_ctx.runtime.enqueue_work(created_key);
+}
 /// Puts the component in an execution state where the specified component will
 /// end up being created. The component goes through state changes (driven by
 /// incoming control messages) to make sure that all of the ports that are going
 /// to be transferred are not in a blocked state. Once finished the component
 /// returns to the `NonSync` mode.
 pub(crate) fn default_start_create_component(
     exec_state: &mut CompExecState, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx,
     control: &mut ControlLayer, inbox_main: &mut InboxMain, inbox_backup: &mut InboxBackup,
     definition_id: ProcedureDefinitionId, type_id: TypeId, arguments: ValueGroup
 ) {
     debug_assert_eq!(exec_state.mode, CompMode::NonSync);
     let mut transferred_ports = Vec::new();
     find_ports_in_value_group(&arguments, &mut transferred_ports);
     // Set execution state as waiting until we can create the component. If we
     // can do so right away, then we will.
     exec_state.set_as_create_component_blocked(definition_id, type_id, arguments);
     if ports_not_blocked(comp_ctx, &transferred_ports) {
         perform_create_component(exec_state, sched_ctx, comp_ctx, control, inbox_main, inbox_backup);
+    }
+}
 /// Actually creates a component (and assumes that the caller made sure that
 /// none of the ports are involved in a blocking operation).
 pub(crate) fn perform_create_component(
     exec_state: &mut CompExecState, sched_ctx: &SchedulerCtx, instantiator_ctx: &mut CompCtx,
     control: &mut ControlLayer, inbox_main: &mut InboxMain, inbox_backup: &mut InboxBackup
 ) {
     // Small internal utilities
     struct PortPair {
         instantiator_id: PortId,
         instantiator_handle: LocalPortHandle,
         created_id: PortId,
         created_handle: LocalPortHandle,
         is_open: bool,
+    }
     // Retrieve ports from the arguments
     debug_assert_eq!(exec_state.mode, CompMode::NewComponentBlocked);
     let (procedure_id, procedure_type_id) = exec_state.mode_component;
     let mut arguments = exec_state.mode_value.take();
     let mut ports = Vec::new();
     find_ports_in_value_group(&arguments, &mut ports);
     debug_assert!(ports_not_blocked(instantiator_ctx, &ports));
     // Reserve a location for the new component
     let reservation = sched_ctx.runtime.start_create_component();
     let mut created_ctx = CompCtx::new(&reservation);
     let mut port_pairs = Vec::with_capacity(ports.len());
     // Go over all the ports that will be transferred. Since the ports will get
     // a new ID in the new component, we will take care of that here.
     for (port_location, instantiator_port_id) in &ports {
         // Retrieve port information from instantiator
         let instantiator_port_id = *instantiator_port_id;
         let instantiator_port_handle = instantiator_ctx.get_port_handle(instantiator_port_id);
         let instantiator_port = instantiator_ctx.get_port(instantiator_port_handle);
         // Create port at created component
         let created_port_handle = created_ctx.add_port(
             instantiator_port.peer_comp_id, instantiator_port.peer_port_id,
             instantiator_port.kind, instantiator_port.state
         );
         let created_port = created_ctx.get_port(created_port_handle);
         let created_port_id = created_port.self_id;
         // Modify port ID in the arguments to the new component and store them
         // for later access
         let is_open = instantiator_port.state.is_open();
         port_pairs.push(PortPair{
             instantiator_id: instantiator_port_id,
             instantiator_handle: instantiator_port_handle,
             created_id: created_port_id,
             created_handle: created_port_handle,
             is_open,
         });
         for location in port_location.iter().copied() {
             let value = arguments.get_value_mut(location);
             match value {
                 Value::Input(id) => *id = port_id_to_eval(created_port_id),
                 Value::Output(id) => *id = port_id_to_eval(created_port_id),
                 _ => unreachable!(),
+            }
+        }
+    }
     // For each of the ports in the newly created component we set the peer to
     // the correct value. We will not yet change the peer on the instantiator's
     // ports (as we haven't yet stored the new component in the runtime's
     // component storage)
     let mut created_component_has_remote_peers = false;
     for pair in port_pairs.iter() {
         let instantiator_port_info = instantiator_ctx.get_port(pair.instantiator_handle);
         let created_port_info = created_ctx.get_port_mut(pair.created_handle);
         if created_port_info.peer_comp_id == instantiator_ctx.id {
             // The peer of the created component's port seems to be the
             // instantiator.
             let created_port_peer_index = port_pairs.iter()
                 .position(|v| v.instantiator_id == instantiator_port_info.peer_port_id);
             match created_port_peer_index {
                 Some(created_port_peer_index) => {
                     // However, the peer port is also moved to the new
                     // component, so the complete channel is owned by the new
                     // component.
                     let peer_pair = &port_pairs[created_port_peer_index];
                     created_port_info.peer_port_id = peer_pair.created_id;
                     created_port_info.peer_comp_id = reservation.id();
                 },
                 None => {
                     // Peer port remains with instantiator. However, we cannot
                     // set the peer on the instantiator yet, because the new
                     // component has not yet been stored in the runtime's
                     // component storage. So we do this later
                     created_port_info.peer_comp_id = instantiator_ctx.id;
                     if pair.is_open {
                         created_ctx.change_port_peer(sched_ctx, pair.created_handle, Some(instantiator_ctx.id));
+                    }
+                }
+            }
         } else {
             // Peer is a different component
             if pair.is_open {
                 // And the port is still open, so we need to notify the peer
                 let peer_handle = instantiator_ctx.get_peer_handle(created_port_info.peer_comp_id);
                 let peer_info = instantiator_ctx.get_peer(peer_handle);
                 created_ctx.change_port_peer(sched_ctx, pair.created_handle, Some(peer_info.id));
                 created_component_has_remote_peers = true;
+            }
+        }
+    }
     // Now we store the new component into the runtime's component storage using
     // the reservation.
     let component = create_component(
         &sched_ctx.runtime.protocol, procedure_id, procedure_type_id,
         arguments, port_pairs.len()
     );
     let (created_key, created_runtime_component) = sched_ctx.runtime.finish_create_component(
         reservation, component, created_ctx, false
     );
     let created_ctx = &mut created_runtime_component.ctx;
     let created_component = &mut created_runtime_component.component;
     created_component.on_creation(created_key.downgrade(), sched_ctx);
     // We now pass along the messages that the instantiator component still has
     // that belong to the new component. At the same time we'll take care of
     // setting the correct peer of the instantiator component
     for pair in port_pairs.iter() {
         // Transferring the messages and removing the port from the
         // instantiator component
         let instantiator_port_index = instantiator_ctx.get_port_index(pair.instantiator_handle);
         instantiator_ctx.change_port_peer(sched_ctx, pair.instantiator_handle, None);
         transfer_messages(inbox_main, inbox_backup, pair, instantiator_ctx, created_ctx, created_component.as_mut());
         instantiator_ctx.remove_port(pair.instantiator_handle);
         if let Some(mut message) = inbox_main[instantiator_port_index].take() {
             message.data_header.target_port = pair.created_id;
             created_component.adopt_message(created_ctx, message);
+        }
         let mut message_index = 0;
         while message_index < inbox_backup.len() {
             let message = &inbox_backup[message_index];
             if message.data_header.target_port == pair.instantiator_id {
                 // Transfer the message
                 let mut message = inbox_backup.remove(message_index);
                 message.data_header.target_port = pair.created_id;
                 created_component.adopt_message(created_ctx, message);
             } else {
                 // Message does not belong to the port pair that we're
                 // transferring to the new component.
                 message_index += 1;
+            }
+        }
         // Here we take care of the case where the instantiator previously owned
         // both ends of the channel, but has transferred one port to the new
         // component (hence creating a channel between the instantiator
         // component and the new component).
         let created_port_info = created_ctx.get_port(pair.created_handle);
         if pair.is_open && created_port_info.peer_comp_id == instantiator_ctx.id {
             // Note: the port we're receiving here belongs to the instantiator
             // and is NOT in the "port_pairs" array.
             let instantiator_port_handle = instantiator_ctx.get_port_handle(created_port_info.peer_port_id);
             let instantiator_port_info = instantiator_ctx.get_port_mut(instantiator_port_handle);
             instantiator_port_info.peer_port_id = created_port_info.self_id;
             instantiator_ctx.change_port_peer(sched_ctx, instantiator_port_handle, Some(created_ctx.id));
+        }
+    }
     // Finally: if we did move ports around whose peers are different
     // components, then we'll initiate the appropriate protocol to notify them.
     if created_component_has_remote_peers {
         let schedule_entry_id = control.add_schedule_entry(created_ctx.id);
         for pair in &port_pairs {
             let port_info = created_ctx.get_port(pair.created_handle);
             if pair.is_open && port_info.peer_comp_id != instantiator_ctx.id && port_info.peer_comp_id != created_ctx.id {
                 // Peer component is not the instantiator, and it is not the
                 // new component itself
                 let message = control.add_reroute_entry(
                     instantiator_ctx.id, port_info.peer_port_id, port_info.peer_comp_id,
                     pair.instantiator_id, pair.created_id, created_ctx.id,
                     schedule_entry_id
                 );
                 let peer_handle = created_ctx.get_peer_handle(port_info.peer_comp_id);
                 let peer_info = created_ctx.get_peer(peer_handle);
                 peer_info.handle.send_message_logged(sched_ctx, message, true);
+            }
+        }
     } else {
         // We can schedule the component immediately, we do not have to wait
         // for any peers: there are none.
         sched_ctx.runtime.enqueue_work(created_key);
+    }
     exec_state.mode = CompMode::NonSync;
     exec_state.mode_component = (ProcedureDefinitionId::new_invalid(), TypeId::new_invalid());
+}
 #[inline]
 pub(crate) fn default_handle_exit(_exec_state: &CompExecState) -> CompScheduling {
     debug_assert_eq!(_exec_state.mode, CompMode::Exit);
     return CompScheduling::Exit;
+}
 // -----------------------------------------------------------------------------
 // Internal messaging/state utilities
 // -----------------------------------------------------------------------------
 struct PortPair {
     instantiator_id: PortId,
     instantiator_handle: LocalPortHandle,
     created_id: PortId,
     created_handle: LocalPortHandle,
     is_open: bool,
+}
 pub(crate) fn ports_not_blocked(comp_ctx: &CompCtx, ports: &EncounteredPorts) -> bool {
     for (_port_locations, port_id) in ports {
         let port_handle = comp_ctx.get_port_handle(*port_id);
         let port_info = comp_ctx.get_port(port_handle);
         if port_info.state.is_blocked_due_to_port_change() {
             return false;
+        }
+    }
     return true;
+}
 fn transfer_messages(
     inbox_main: &mut InboxMain, inbox_backup: &mut InboxBackup, port_pair: &PortPair,
     instantiator_ctx: &mut CompCtx, created_ctx: &mut CompCtx, created_component: &mut dyn Component
 ) {
     let instantiator_port_index = instantiator_ctx.get_port_index(port_pair.instantiator_handle);
     if let Some(mut message) = inbox_main.remove(instantiator_port_index) {
         message.data_header.target_port = port_pair.created_id;
         created_component.adopt_message(created_ctx, message);
+    }
     let mut message_index = 0;
     while message_index < inbox_backup.len() {
         let message = &inbox_backup[message_index];
         if message.data_header.target_port == port_pair.instantiator_id {
             // Transfer the message
             let mut message = inbox_backup.remove(message_index);
             message.data_header.target_port = port_pair.created_id;
             created_component.adopt_message(created_ctx, message);
         } else {
             // Message does not belong to the port pair that we're
             // transferring to the new component.
             message_index += 1;
+        }
+    }
+}
 /// Performs the default action of printing the provided error, and then putting
 /// the component in the state where it will shut down. Only to be used for
 /// builtin components: their error message construction is simpler (and more
 /// common) as they don't have any source code.
 pub(crate) fn default_handle_error_for_builtin(
     exec_state: &mut CompExecState, sched_ctx: &SchedulerCtx,
     location_and_message: (PortInstruction, String)
 ) {
     let (_location, message) = location_and_message;
     sched_ctx.error(&message);
     let exit_reason = if exec_state.mode.is_in_sync_block() {
         ExitReason::ErrorInSync
     } else {
         ExitReason::ErrorNonSync
     };
     exec_state.set_as_start_exit(exit_reason);
+}
 #[inline]
 pub(crate) fn default_handle_exit(_exec_state: &CompExecState) -> CompScheduling {
     debug_assert_eq!(_exec_state.mode, CompMode::Exit);
     return CompScheduling::Exit;
+}
 // -----------------------------------------------------------------------------
 // Internal messaging/state utilities
 // -----------------------------------------------------------------------------
 /// Sends a message without any transmitted ports. Does not check if sending
 /// is actually valid.
 fn send_message_without_ports(
     sending_port_handle: LocalPortHandle, value: ValueGroup,
     comp_ctx: &CompCtx, sched_ctx: &SchedulerCtx, consensus: &mut Consensus,
 ) {
     let port_info = comp_ctx.get_port(sending_port_handle);
     debug_assert!(port_info.state.can_send());
     let peer_handle = comp_ctx.get_peer_handle(port_info.peer_comp_id);
     let peer_info = comp_ctx.get_peer(peer_handle);
     let annotated_message = consensus.annotate_data_message(comp_ctx, port_info, value);
     peer_info.handle.send_message_logged(sched_ctx, Message::Data(annotated_message), true);
+}
 /// Prepares sending a message that contains ports. Only once a particular
 /// protocol has completed (where we notify all the peers that the ports will
 /// be transferred) will we actually send the message to the recipient.
 fn start_send_message_with_ports(
     sending_port_id: PortId, sending_port_instruction: PortInstruction, value: ValueGroup,
     exec_state: &mut CompExecState, comp_ctx: &mut CompCtx, sched_ctx: &SchedulerCtx,
     control: &mut ControlLayer
 ) -> Result<(), (PortInstruction, String)> {
     debug_assert_eq!(exec_state.mode, CompMode::Sync); // busy in sync, trying to send
     // Retrieve ports we're going to transfer
     let sending_port_handle = comp_ctx.get_port_handle(sending_port_id);
     let sending_port_info = comp_ctx.get_port_mut(sending_port_handle);
     sending_port_info.last_instruction = sending_port_instruction;
     let mut transmit_ports = Vec::new();
     find_ports_in_value_group(&value, &mut transmit_ports);
     debug_assert!(!transmit_ports.is_empty()); // required from caller
     // Enter the state where we'll wait until all transferred ports are not
     // blocked.
     exec_state.set_as_blocked_put_with_ports(sending_port_id, value);
     if ports_not_blocked(comp_ctx, &transmit_ports) {
         // Ports are not blocked, so we can send them right away.
         perform_send_message_with_ports_notify_peers(
             exec_state, comp_ctx, sched_ctx, control, transmit_ports
         )?;
     } // else: wait until they become unblocked
     return Ok(())
+}
 fn perform_send_message_with_ports_notify_peers(
     exec_state: &mut CompExecState, comp_ctx: &mut CompCtx, sched_ctx: &SchedulerCtx,
     control: &mut ControlLayer, transmit_ports: EncounteredPorts
 ) -> Result<(), (PortInstruction, String)> {
     // Check we're in the correct state in debug mode
     debug_assert_eq!(exec_state.mode, CompMode::PutPortsBlockedTransferredPorts);
     debug_assert!(ports_not_blocked(comp_ctx, &transmit_ports));
     // Set up the final Ack that triggers us to send our final message
     let unblock_put_control_id = control.add_unblock_put_with_ports_entry();
     for (_, port_id) in &transmit_ports {
         let transmit_port_handle = comp_ctx.get_port_handle(*port_id);
         let transmit_port_info = comp_ctx.get_port_mut(transmit_port_handle);
         let peer_comp_id = transmit_port_info.peer_comp_id;
         let peer_port_id = transmit_port_info.peer_port_id;
         // Note: we checked earlier that we are currently in sync mode. Now we
         // will check if we've already used the port we're about to transmit.
         if !transmit_port_info.last_instruction.is_none() {
             let sending_port_handle = comp_ctx.get_port_handle(exec_state.mode_port);
             let sending_port_instruction = comp_ctx.get_port(sending_port_handle).last_instruction;
             return Err((
                 sending_port_instruction,
                 String::from("Cannot transmit one of the ports in this message, as it is used in this sync round")
             ));
+        }
         if transmit_port_info.state.is_set(PortStateFlag::Transmitted) {
             let sending_port_handle = comp_ctx.get_port_handle(exec_state.mode_port);
             let sending_port_instruction = comp_ctx.get_port(sending_port_handle).last_instruction;
             return Err((
                 sending_port_instruction,
                 String::from("Cannot transmit one of the ports in this message, as that port is already transmitted")
             ));
+        }
         // Set the flag for transmission
         transmit_port_info.state.set(PortStateFlag::Transmitted);
         // Block the peer of the port
         let message = control.create_port_transfer_message(unblock_put_control_id, comp_ctx.id, peer_port_id);
         println!("DEBUG: Port transfer message\nControl ID: {:?}\nMessage: {:?}", unblock_put_control_id, message);
         let peer_handle = comp_ctx.get_peer_handle(peer_comp_id);
         let peer_info = comp_ctx.get_peer(peer_handle);
         peer_info.handle.send_message_logged(sched_ctx, message, true);
+    }
     // We've set up the protocol, once all the PPC's are blocked we are supposed
     // to transfer the message to the recipient. So store it temporarily
     exec_state.mode = CompMode::PutPortsBlockedAwaitingAcks;
     return Ok(());
+}
 /// Performs the transmission of a data message that contains ports. These were
 /// all stored in the component's execution state by the
 /// `prepare_send_message_with_ports` function. Port must be ready to send!
 fn perform_send_message_with_ports_to_receiver(
     exec_state: &mut CompExecState, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, consensus: &mut Consensus,
     inbox_main: &mut InboxMain, inbox_backup: &mut InboxBackup
 ) -> Result<(), (PortInstruction, String)> {
     debug_assert_eq!(exec_state.mode, CompMode::PutPortsBlockedSendingPort);
     // Find all ports again
     let mut transmit_ports = Vec::new();
     find_ports_in_value_group(&exec_state.mode_value, &mut transmit_ports);
     // Retrieve the port over which we're going to send the message
     let port_handle = comp_ctx.get_port_handle(exec_state.mode_port);
     let port_info = comp_ctx.get_port(port_handle);
     if !port_info.state.is_open() {
         return Err((
             port_info.last_instruction,
             String::from("cannot send over this port, as it is closed")
         ));
+    }
     debug_assert!(!port_info.state.is_blocked_due_to_port_change()); // caller should have checked this
     let peer_handle = comp_ctx.get_peer_handle(port_info.peer_comp_id);
     // Change state back to its default
     exec_state.mode = CompMode::Sync;
     let message_value = exec_state.mode_value.take();
     exec_state.mode_port = PortId::new_invalid();
     // Annotate the data message
     let mut annotated_message = consensus.annotate_data_message(comp_ctx, port_info, message_value);
     // And further enhance the message by adding data about the ports that are
     // being transferred
     for (port_locations, transmit_port_id) in transmit_ports {
         let transmit_port_handle = comp_ctx.get_port_handle(transmit_port_id);
         let transmit_port_info = comp_ctx.get_port(transmit_port_handle);
         let transmit_messages = take_port_messages(comp_ctx, transmit_port_id, inbox_main, inbox_backup);
         let mut transmit_port_state = transmit_port_info.state;
         debug_assert!(transmit_port_state.is_set(PortStateFlag::Transmitted));
         transmit_port_state.clear(PortStateFlag::Transmitted);
         annotated_message.ports.push(TransmittedPort{
             locations: port_locations,
             messages: transmit_messages,
             peer_comp: transmit_port_info.peer_comp_id,
             peer_port: transmit_port_info.peer_port_id,
             kind: transmit_port_info.kind,
             state: transmit_port_state
         });
         comp_ctx.change_port_peer(sched_ctx, transmit_port_handle, None);
+    }
     // And finally, send the message to the peer
     let peer_info = comp_ctx.get_peer(peer_handle);
     peer_info.handle.send_message_logged(sched_ctx, Message::Data(annotated_message), true);
     return Ok(());
+}
 /// Handles an `Ack` for the control layer.
 fn default_handle_ack(
     exec_state: &mut CompExecState, control: &mut ControlLayer, control_id: ControlId,
     sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, consensus: &mut Consensus,
     inbox_main: &mut InboxMain, inbox_backup: &mut InboxBackup
 ) -> Result<(), (PortInstruction, String)>{
     // Since an `Ack` may cause another one, handle them in a loop
     let mut to_ack = control_id;
     loop {
         let (action, new_to_ack) = control.handle_ack(to_ack, sched_ctx, comp_ctx);
         match action {
             AckAction::SendMessage(target_comp, message) => {
                 // FIX @NoDirectHandle
                 let mut handle = sched_ctx.runtime.get_component_public(target_comp);
                 handle.send_message_logged(sched_ctx, Message::Control(message), true);
                 let _should_remove = handle.decrement_users();
                 debug_assert!(_should_remove.is_none());
             },
             AckAction::ScheduleComponent(to_schedule) => {
                 // FIX @NoDirectHandle
                 let mut handle = sched_ctx.runtime.get_component_public(to_schedule);
                 // Note that the component is intentionally not
                 // sleeping, so we just wake it up
                 debug_assert!(!handle.sleeping.load(std::sync::atomic::Ordering::Acquire));
                 let key = unsafe { to_schedule.upgrade() };
                 sched_ctx.runtime.enqueue_work(key);
                 let _should_remove = handle.decrement_users();
                 debug_assert!(_should_remove.is_none());
             },
             AckAction::UnblockPutWithPorts => {
                 // Send the message (containing ports) stored in the component
                 // execution state to the recipient
                 println!("DEBUG: Unblocking put with ports");
                 debug_assert_eq!(exec_state.mode, CompMode::PutPortsBlockedAwaitingAcks);
                 exec_state.mode = CompMode::PutPortsBlockedSendingPort;
                 let port_handle = comp_ctx.get_port_handle(exec_state.mode_port);
                 // Little bit of a hack, we didn't really unblock the sending
                 // port, but this will mesh nicely with waiting for the sending
                 // port to become unblocked.
                 default_handle_recently_unblocked_port(
                     exec_state, control, consensus, port_handle, sched_ctx,
                     comp_ctx, inbox_main, inbox_backup
                 )?;
             },
             AckAction::None => {}
+        }
         match new_to_ack {
             Some(new_to_ack) => to_ack = new_to_ack,
             None => break,
+        }
+    }
     return Ok(());
+}
 /// Little helper for sending the most common kind of `Ack`
 fn default_send_ack(
     causer_of_ack_id: ControlId, peer_handle: LocalPeerHandle,
     sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx
 ) {
     let peer_info = comp_ctx.get_peer(peer_handle);
     peer_info.handle.send_message_logged(sched_ctx, Message::Control(ControlMessage{
         id: causer_of_ack_id,
         sender_comp_id: comp_ctx.id,
         target_port_id: None,
         content: ControlMessageContent::Ack
     }), true);
+}
 /// Handles the unblocking of a putter port. In case there is a pending message
 /// on that port then it will be sent. There are two reasons for calling this
 /// function: either a port was blocked (i.e. the Blocked state flag was
 /// cleared), or the component is ready to send a message containing ports
 /// (stored in the execution state). In this latter case we might still have
 /// a blocked port.
 fn default_handle_recently_unblocked_port(
     exec_state: &mut CompExecState, control: &mut ControlLayer, consensus: &mut Consensus,
     port_handle: LocalPortHandle, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx,
     inbox_main: &mut InboxMain, inbox_backup: &mut InboxBackup
 ) -> Result<(), (PortInstruction, String)> {
     let port_info = comp_ctx.get_port_mut(port_handle);
     let port_id = port_info.self_id;
     if port_info.state.is_blocked() {
         // Port is still blocked. We wait until the next control message where
         // we unblock the port.
         return Ok(());
+    }
     if exec_state.is_blocked_on_put_without_ports(port_id) {
         // Annotate the message that we're going to send
         let port_info = comp_ctx.get_port(port_handle); // for immutable access
         debug_assert_eq!(port_info.kind, PortKind::Putter);
         let to_send = exec_state.mode_value.take();
         let to_send = consensus.annotate_data_message(comp_ctx, port_info, to_send);
         // Retrieve peer to send the message
         let peer_handle = comp_ctx.get_peer_handle(port_info.peer_comp_id);
         let peer_info = comp_ctx.get_peer(peer_handle);
         peer_info.handle.send_message_logged(sched_ctx, Message::Data(to_send), true);
         // Return to the regular execution mode
         exec_state.mode = CompMode::Sync;
         exec_state.mode_port = PortId::new_invalid();
     } else if exec_state.mode == CompMode::PutPortsBlockedTransferredPorts {
         // We are waiting until all of the transferred ports become unblocked,
         // check so here.
         let mut transfer_ports = Vec::new();
         find_ports_in_value_group(&exec_state.mode_value, &mut transfer_ports);
         if ports_not_blocked(comp_ctx, &transfer_ports) {
             perform_send_message_with_ports_notify_peers(
                 exec_state, comp_ctx, sched_ctx, control, transfer_ports
             )?;
+        }
     } else if exec_state.mode == CompMode::PutPortsBlockedSendingPort && exec_state.mode_port == port_id {
         // We checked above that the port became unblocked, so we can send the
         // message
         perform_send_message_with_ports_to_receiver(
             exec_state, sched_ctx, comp_ctx, consensus, inbox_main, inbox_backup
         )?;
     } else if exec_state.is_blocked_on_create_component() {
         let mut ports = Vec::new();
         find_ports_in_value_group(&exec_state.mode_value, &mut ports);
         if ports_not_blocked(comp_ctx, &ports) {
             perform_create_component(
                 exec_state, sched_ctx, comp_ctx, control, inbox_main, inbox_backup
             );
+        }
+    }
     return Ok(());
+}
 #[inline]
 pub(crate) fn port_id_from_eval(port_id: EvalPortId) -> PortId {
     return PortId(port_id.id);
+}
 #[inline]
 pub(crate) fn port_id_to_eval(port_id: PortId) -> EvalPortId {
     return EvalPortId{ id: port_id.0 };
+}
 // TODO: Optimize double vec
 type EncounteredPorts = Vec<(Vec<ValueId>, PortId)>;
 /// Recursively goes through the value group, attempting to find ports.
 /// Duplicates will only be added once.
 pub(crate) fn find_ports_in_value_group(value_group: &ValueGroup, ports: &mut EncounteredPorts) {
     // Helper to check a value for a port and recurse if needed.
     fn find_port_in_value(group: &ValueGroup, value: &Value, value_location: ValueId, ports: &mut EncounteredPorts) {
         match value {
             Value::Input(port_id) | Value::Output(port_id) => {
                 // This is an actual port
                 let cur_port = PortId(port_id.id);
                 for prev_port in ports.iter_mut() {
                     if prev_port.1 == cur_port {
                         // Already added
                         prev_port.0.push(value_location);
                         return;
+                    }
+                }
                 ports.push((vec![value_location], cur_port));
             },
             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 (value_index, embedded_value) in heap_region.iter().enumerate() {
                     let value_location = ValueId::Heap(*heap_pos, value_index as u32);
                     find_port_in_value(group, embedded_value, value_location, ports);
+                }
             },
             _ => {}, // values we don't care about
+        }
+    }
     // Clear the ports, then scan all the available values
     ports.clear();
     for (value_index, value) in value_group.values.iter().enumerate() {
         find_port_in_value(value_group, value, ValueId::Stack(value_index as u32), ports);
+    }
+}
 /// Goes through the inbox of a component and takes out all the messages that
 /// are targeted at a specific port
 pub(crate) fn take_port_messages(
     comp_ctx: &CompCtx, port_id: PortId,
     inbox_main: &mut InboxMain, inbox_backup: &mut InboxBackup
 ) -> Vec<DataMessage> {
     let mut messages = Vec::new();
     let port_handle = comp_ctx.get_port_handle(port_id);
     let port_index = comp_ctx.get_port_index(port_handle);
     if let Some(message) = inbox_main[port_index].take() {
         messages.push(message);
+    }
     let mut message_index = 0;
     while message_index < inbox_backup.len() {
         let message = &inbox_backup[message_index];
         if message.data_header.target_port == port_id {
             let message = inbox_backup.remove(message_index);
             messages.push(message);
         } else {
             message_index += 1;
+        }
+    }
     return messages;
+}
@@ \ No newline at end of file @@

src/runtime2/component/component_internet.rs

➞

Show inline comments

 use crate::protocol::eval::{ValueGroup, Value};
 use crate::runtime2::*;
 use crate::runtime2::component::{CompCtx, CompId, PortInstruction};
 use crate::runtime2::stdlib::internet::*;
 use crate::runtime2::poll::*;
 use super::component::{self, *};
 use super::control_layer::*;
 use super::consensus::*;
 use std::io::ErrorKind as IoErrorKind;
 use std::net::{IpAddr, Ipv4Addr};
 use crate::protocol::{ProcedureDefinitionId, TypeId};
 enum SocketState {
 // -----------------------------------------------------------------------------
 // ComponentTcpClient
 // -----------------------------------------------------------------------------
 enum ClientSocketState {
     Connected(SocketTcpClient),
     ErrorReported(String),
     Error,
+}
-impl SocketState {
+impl ClientSocketState {
     fn get_socket(&self) -> &SocketTcpClient {
         match self {
             SocketState::Connected(v) => v,
             SocketState::Error => unreachable!(),
             ClientSocketState::Connected(v) => v,
             ClientSocketState::ErrorReported(_) | ClientSocketState::Error => unreachable!(),
+        }
+    }
+}
 /// States from the point of view of the component that is connecting to this
 /// TCP component (i.e. from the point of view of attempting to interface with
 /// a socket).
 #[derive(PartialEq, Debug)]
-enum SyncState {
+enum ClientSyncState {
     AwaitingCmd,
     Getting,
     Putting,
     FinishSync,
     FinishSyncThenQuit,
+}
 pub struct ComponentTcpClient {
     // Properties for the tcp socket
     socket_state: SocketState,
     sync_state: SyncState,
     socket_state: ClientSocketState,
     sync_state: ClientSyncState,
     poll_ticket: Option<PollTicket>,
     inbox_main: InboxMain,
     inbox_backup: InboxBackup,
     pdl_input_port_id: PortId, // input from PDL, so transmitted over socket
     pdl_output_port_id: PortId, // output towards PDL, so received over socket
     // Information about union tags, extracted from PDL
     input_union_send_tag_value: i64,
     input_union_receive_tag_value: i64,
     input_union_finish_tag_value: i64,
     input_union_shutdown_tag_value: i64,
     // Generic component state
     exec_state: CompExecState,
     control: ControlLayer,
     consensus: Consensus,
     // Temporary variables
     byte_buffer: Vec<u8>,
+}
 impl Component for ComponentTcpClient {
     fn on_creation(&mut self, id: CompId, sched_ctx: &SchedulerCtx) {
         // Retrieve type information for messages we're going to receive
         let pd = &sched_ctx.runtime.protocol;
         let cmd_type = pd.find_type(b"std.internet", b"Cmd")
             .expect("'Cmd' type in the 'std.internet' module");
         let cmd_type = pd.find_type(b"std.internet", b"ClientCmd")
             .expect("'ClientCmd' type in the 'std.internet' module");
         let cmd_type = cmd_type
             .as_union();
         self.input_union_send_tag_value = cmd_type.get_variant_tag_value(b"Send").unwrap();
         self.input_union_receive_tag_value = cmd_type.get_variant_tag_value(b"Receive").unwrap();
         self.input_union_finish_tag_value = cmd_type.get_variant_tag_value(b"Finish").unwrap();
         self.input_union_shutdown_tag_value = cmd_type.get_variant_tag_value(b"Shutdown").unwrap();
         // Register socket for async events
-        if let SocketState::Connected(socket) = &self.socket_state {
+        if let ClientSocketState::Connected(socket) = &self.socket_state {
             let self_handle = sched_ctx.runtime.get_component_public(id);
             let poll_ticket = sched_ctx.polling.register(socket, self_handle, true, true)
-                .expect("registering tcp component");
+                .expect("registering tcp client");
             debug_assert!(self.poll_ticket.is_none());
             self.poll_ticket = Some(poll_ticket);
+        }
+    }
     fn on_shutdown(&mut self, sched_ctx: &SchedulerCtx) {
         if let Some(poll_ticket) = self.poll_ticket.take() {
             sched_ctx.polling.unregister(poll_ticket)
                 .expect("unregistering tcp component");
+        }
+    }
     fn adopt_message(&mut self, _comp_ctx: &mut CompCtx, message: DataMessage) {
         let slot = &mut self.inbox_main[0];
         if slot.is_none() {
             *slot = Some(message);
         } else {
             self.inbox_backup.push(message);
+        }
+    }
     fn handle_message(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx, message: Message) {
         match message {
             Message::Data(message) => {
                 self.handle_incoming_data_message(sched_ctx, comp_ctx, message);
             },
             Message::Sync(message) => {
                 let decision = self.consensus.receive_sync_message(sched_ctx, comp_ctx, message);
                 component::default_handle_sync_decision(sched_ctx, &mut self.exec_state, comp_ctx, decision, &mut self.consensus);
             },
             Message::Control(message) => {
                 if let Err(location_and_message) = component::default_handle_control_message(
                     &mut self.exec_state, &mut self.control, &mut self.consensus,
                     message, sched_ctx, comp_ctx, &mut self.inbox_main, &mut self.inbox_backup
                 ) {
                     component::default_handle_error_for_builtin(&mut self.exec_state, sched_ctx, location_and_message);
+                }
             },
             Message::Poll => {
-                sched_ctx.info("Received polling event");
+                sched_ctx.debug("Received polling event");
             },
+        }
+    }
     fn run(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx) -> CompScheduling {
         sched_ctx.info(&format!("Running component ComponentTcpClient (mode: {:?}, sync state: {:?})", self.exec_state.mode, self.sync_state));
         match self.exec_state.mode {
             CompMode::BlockedSelect |
             CompMode::PutPortsBlockedTransferredPorts |
             CompMode::PutPortsBlockedAwaitingAcks |
             CompMode::PutPortsBlockedSendingPort |
             CompMode::NewComponentBlocked => {
                 // Not possible: we never enter this state
                 unreachable!();
             },
             CompMode::NonSync => {
                 // When in non-sync mode
                 match &mut self.socket_state {
                     SocketState::Connected(_socket) => {
                         if self.sync_state == SyncState::FinishSyncThenQuit {
                 match &self.socket_state {
                     ClientSocketState::Connected(_socket) => {
                         if self.sync_state == ClientSyncState::FinishSyncThenQuit {
                             // Previous request was to let the component shut down
                             self.exec_state.set_as_start_exit(ExitReason::Termination);
                         } else {
                             // Reset for a new request
-                            self.sync_state = SyncState::AwaitingCmd;
+                            self.sync_state = ClientSyncState::AwaitingCmd;
                             component::default_handle_sync_start(
                                 &mut self.exec_state, &mut self.inbox_main, sched_ctx, comp_ctx, &mut self.consensus
                             );
+                        }
                         return CompScheduling::Immediate;
                     },
                     SocketState::Error => {
                         // Could potentially send an error message to the
                         // connected component.
                         self.exec_state.set_as_start_exit(ExitReason::ErrorNonSync);
                     ClientSocketState::ErrorReported(message) => {
                         component::default_handle_error_for_builtin(
                             &mut self.exec_state, sched_ctx,
                             (PortInstruction::NoSource, format!("failed socket creation, reason: {}", message))
                         );
                         self.socket_state = ClientSocketState::Error;
                         return CompScheduling::Immediate;
+                    }
                     ClientSocketState::Error => {
                         return CompScheduling::Sleep;
+                    }
+                }
             },
             CompMode::Sync => {
                 // When in sync mode: wait for a command to come in
                 match self.sync_state {
-                    SyncState::AwaitingCmd => {
+                    ClientSyncState::AwaitingCmd => {
                         match component::default_attempt_get(
                             &mut self.exec_state, self.pdl_input_port_id, PortInstruction::NoSource,
                             &mut self.inbox_main, &mut self.inbox_backup, sched_ctx, comp_ctx,
                             &mut self.control, &mut self.consensus
                         ) {
                             GetResult::Received(message) => {
                                 let (tag_value, embedded_heap_pos) = message.content.values[0].as_union();
                                 if tag_value == self.input_union_send_tag_value {
                                     // Retrieve bytes from the message
                                     self.byte_buffer.clear();
                                     let union_content = &message.content.regions[embedded_heap_pos as usize];
                                     debug_assert_eq!(union_content.len(), 1);
                                     let array_heap_pos = union_content[0].as_array();
                                     let array_values = &message.content.regions[array_heap_pos as usize];
                                     self.byte_buffer.reserve(array_values.len());
                                     for value in array_values {
                                         self.byte_buffer.push(value.as_uint8());
+                                    }
-                                    self.sync_state = SyncState::Putting;
+                                    self.sync_state = ClientSyncState::Putting;
                                 } else if tag_value == self.input_union_receive_tag_value {
                                     // Component requires a `recv`
-                                    self.sync_state = SyncState::Getting;
+                                    self.sync_state = ClientSyncState::Getting;
                                 } else if tag_value == self.input_union_finish_tag_value {
                                     // Component requires us to end the sync round
-                                    self.sync_state = SyncState::FinishSync;
+                                    self.sync_state = ClientSyncState::FinishSync;
                                 } else if tag_value == self.input_union_shutdown_tag_value {
                                     // Component wants to close the connection
-                                    self.sync_state = SyncState::FinishSyncThenQuit;
+                                    self.sync_state = ClientSyncState::FinishSyncThenQuit;
                                 } else {
                                     unreachable!("got tag_value {}", tag_value)
+                                }
                                 return CompScheduling::Immediate;
                             },
                             GetResult::NoMessage => {
                                 return CompScheduling::Sleep;
                             },
                             GetResult::Error(location_and_message) => {
                                 component::default_handle_error_for_builtin(&mut self.exec_state, sched_ctx, location_and_message);
                                 return CompScheduling::Immediate;
+                            }
+                        }
                     },
-                    SyncState::Putting => {
+                    ClientSyncState::Putting => {
                         // We're supposed to send a user-supplied message fully
                         // over the socket. But we might end up blocking. In
                         // that case the component goes to sleep until it is
                         // polled.
                         let socket = self.socket_state.get_socket();
                         while !self.byte_buffer.is_empty() {
                             match socket.send(&self.byte_buffer) {
                                 Ok(bytes_sent) => {
                                     self.byte_buffer.drain(..bytes_sent);
                                 },
                                 Err(err) => {
                                     if err.kind() == IoErrorKind::WouldBlock {
                                         return CompScheduling::Sleep; // wait until notified
                                     } else {
                                         todo!("handle socket.send error {:?}", err)
                                         component::default_handle_error_for_builtin(
                                             &mut self.exec_state, sched_ctx,
                                             (PortInstruction::NoSource, format!("failed sending on socket, reason: {}", err))
                                         );
                                         return CompScheduling::Immediate;
+                                    }
+                                }
+                            }
+                        }
                         // If here then we're done putting the data, we can
                         // finish the sync round
                         component::default_handle_sync_end(&mut self.exec_state, sched_ctx, comp_ctx, &mut self.consensus);
                         return CompScheduling::Requeue;
                     },
-                    SyncState::Getting => {
+                    ClientSyncState::Getting => {
                         // We're going to try and receive a single message. If
                         // this causes us to end up blocking the component
                         // goes to sleep until it is polled.
                         const BUFFER_SIZE: usize = 1024; // TODO: Move to config
                         let socket = self.socket_state.get_socket();
                         self.byte_buffer.resize(BUFFER_SIZE, 0);
                         match socket.receive(&mut self.byte_buffer) {
                             Ok(num_received) => {
                                 self.byte_buffer.resize(num_received, 0);
                                 let message_content = self.bytes_to_data_message_content(&self.byte_buffer);
                                 let send_result = component::default_send_data_message(
                                     &mut self.exec_state, self.pdl_output_port_id, PortInstruction::NoSource,
                                     message_content, sched_ctx, &mut self.consensus, &mut self.control, comp_ctx
                                 );
                                 if let Err(location_and_message) = send_result {
                                     component::default_handle_error_for_builtin(&mut self.exec_state, sched_ctx, location_and_message);
                                     return CompScheduling::Immediate;
                                 } else {
                                     let scheduling = send_result.unwrap();
-                                    self.sync_state = SyncState::AwaitingCmd;
+                                    self.sync_state = ClientSyncState::AwaitingCmd;
                                     return scheduling;
+                                }
                             },
                             Err(err) => {
                                 if err.kind() == IoErrorKind::WouldBlock {
                                     return CompScheduling::Sleep; // wait until polled
                                 } else {
                                     todo!("handle socket.receive error {:?}", err)
                                     component::default_handle_error_for_builtin(
                                         &mut self.exec_state, sched_ctx,
                                         (PortInstruction::NoSource, format!("failed receiving from socket, reason: {}", err))
                                     );
                                     return CompScheduling::Immediate;
+                                }
+                            }
+                        }
                     },
-                    SyncState::FinishSync | SyncState::FinishSyncThenQuit => {
+                    ClientSyncState::FinishSync | ClientSyncState::FinishSyncThenQuit => {
                         component::default_handle_sync_end(&mut self.exec_state, sched_ctx, comp_ctx, &mut self.consensus);
                         return CompScheduling::Requeue;
                     },
+                }
             },
             CompMode::BlockedGet => {
                 // Entered when awaiting a new command
-                debug_assert_eq!(self.sync_state, SyncState::AwaitingCmd);
+                debug_assert_eq!(self.sync_state, ClientSyncState::AwaitingCmd);
                 return CompScheduling::Sleep;
             },
             CompMode::SyncEnd | CompMode::BlockedPut =>
                 return CompScheduling::Sleep,
             CompMode::StartExit =>
                 return component::default_handle_start_exit(&mut self.exec_state, &mut self.control, sched_ctx, comp_ctx, &mut self.consensus),
             CompMode::BusyExit =>
                 return component::default_handle_busy_exit(&mut self.exec_state, &mut self.control, sched_ctx),
             CompMode::Exit =>
                 return component::default_handle_exit(&self.exec_state),
+        }
+    }
+}
 impl ComponentTcpClient {
     pub(crate) fn new(arguments: ValueGroup) -> Self {
         use std::net::{IpAddr, Ipv4Addr};
         fn client_socket_state_from_result(result: Result<SocketTcpClient, SocketError>) -> ClientSocketState {
             match result {
                 Ok(socket) => ClientSocketState::Connected(socket),
                 Err(error) => ClientSocketState::ErrorReported(format!("Failed to create socket, reason: {:?}", error)),
+            }
+        }
         debug_assert_eq!(arguments.values.len(), 4);
         // Two possible cases here: if the number of arguments is 3, then we
         // get: (socket_handle, input_port, output_port). If the number of
         // arguments is 4, then we get: (ip, port, input_port, output_port).
         assert!(arguments.values.len() == 3 || arguments.values.len() == 4);
         // Parsing arguments
         let ip_heap_pos = arguments.values[0].as_array();
         let ip_elements = &arguments.regions[ip_heap_pos as usize];
         if ip_elements.len() != 4 {
             todo!("friendly error reporting: ip contains 4 octects");
+        }
         let ip_address = IpAddr::V4(Ipv4Addr::new(
             ip_elements[0].as_uint8(), ip_elements[1].as_uint8(),
             ip_elements[2].as_uint8(), ip_elements[3].as_uint8()
         ));
         let (socket_state, input_port, output_port) = if arguments.values.len() == 3 {
             let socket_handle = arguments.values[0].as_sint32();
             let socket = SocketTcpClient::new_from_handle(socket_handle);
             let socket_state = client_socket_state_from_result(socket);
             let input_port = component::port_id_from_eval(arguments.values[1].as_input());
             let output_port = component::port_id_from_eval(arguments.values[2].as_output());
         let port = arguments.values[1].as_uint16();
             (socket_state, input_port, output_port)
         } else {
             let input_port = component::port_id_from_eval(arguments.values[2].as_input());
             let output_port = component::port_id_from_eval(arguments.values[3].as_output());
         let socket = SocketTcpClient::new(ip_address, port);
         if let Err(socket) = socket {
             todo!("friendly error reporting: failed to open socket (reason: {:?})", socket);
             let ip_and_port = ip_addr_and_port_from_args(&arguments, 0, 1);
             let socket_state = match ip_and_port {
                 Ok((ip_address, port)) => client_socket_state_from_result(SocketTcpClient::new(ip_address, port)),
                 Err(message) => ClientSocketState::ErrorReported(message),
             };
             (socket_state, input_port, output_port)
         };
         return Self{
             socket_state,
             sync_state: ClientSyncState::AwaitingCmd,
             poll_ticket: None,
             inbox_main: vec![None, None],
             inbox_backup: Vec::new(),
             input_union_send_tag_value: -1,
             input_union_receive_tag_value: -1,
             input_union_finish_tag_value: -1,
             input_union_shutdown_tag_value: -1,
             pdl_input_port_id: input_port,
             pdl_output_port_id: output_port,
             exec_state: CompExecState::new(),
             control: ControlLayer::default(),
             consensus: Consensus::new(),
             byte_buffer: Vec::new(),
+        }
+    }
     pub(crate) fn new_with_existing_connection(socket: SocketTcpClient, input_port: PortId, output_port: PortId) -> Self {
         return Self{
             socket_state: SocketState::Connected(socket.unwrap()),
             sync_state: SyncState::AwaitingCmd,
             socket_state: ClientSocketState::Connected(socket),
             sync_state: ClientSyncState::AwaitingCmd,
             poll_ticket: None,
             inbox_main: vec![None],
+            inbox_main: vec![None, None],
             inbox_backup: Vec::new(),
             input_union_send_tag_value: -1,
             input_union_receive_tag_value: -1,
             input_union_finish_tag_value: -1,
             input_union_shutdown_tag_value: -1,
             pdl_input_port_id: input_port,
             pdl_output_port_id: output_port,
             exec_state: CompExecState::new(),
             control: ControlLayer::default(),
             consensus: Consensus::new(),
             byte_buffer: Vec::new(),
+        }
+    }
     // Handles incoming data from the PDL side (hence, going into the socket)
     fn handle_incoming_data_message(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, message: DataMessage) {
         if self.exec_state.mode.is_in_sync_block() {
             self.consensus.handle_incoming_data_message(comp_ctx, &message);
+        }
         match component::default_handle_incoming_data_message(
             &mut self.exec_state, &mut self.inbox_main, comp_ctx, message, sched_ctx, &mut self.control
         ) {
             IncomingData::PlacedInSlot => {},
             IncomingData::SlotFull(message) => {
                 self.inbox_backup.push(message);
+            }
+        }
+    }
     fn data_message_to_bytes(&self, message: DataMessage, bytes: &mut Vec<u8>) {
         debug_assert_eq!(message.data_header.target_port, self.pdl_input_port_id);
         debug_assert_eq!(message.content.values.len(), 1);
         if let Value::Array(array_pos) = message.content.values[0] {
             let region = &message.content.regions[array_pos as usize];
             bytes.reserve(region.len());
             for value in region {
                 bytes.push(value.as_uint8());
+            }
         } else {
             unreachable!();
+        }
+    }
     fn bytes_to_data_message_content(&self, buffer: &[u8]) -> ValueGroup {
         // Turn bytes into silly executor-style array
         let mut values = Vec::with_capacity(buffer.len());
         for byte in buffer.iter().copied() {
             values.push(Value::UInt8(byte));
+        }
         // Put in a value group
         let mut value_group = ValueGroup::default();
         value_group.regions.push(values);
         value_group.values.push(Value::Array(0));
         return value_group;
+    }
+}
 // -----------------------------------------------------------------------------
 // ComponentTcpListener
 // -----------------------------------------------------------------------------
 enum ListenerSocketState {
     Connected(SocketTcpListener),
     ErrorReported(String),
     Error,
+}
 impl ListenerSocketState {
     fn get_socket(&self) -> &SocketTcpListener {
         match self {
             ListenerSocketState::Connected(v) => return v,
             ListenerSocketState::ErrorReported(_) | ListenerSocketState::Error => unreachable!(),
+        }
+    }
+}
 struct PendingComponent {
     client: i32, // OS socket handle
     cmd_rx: PortId,
     data_tx: PortId,
+}
 enum ListenerSyncState {
     AwaitingCmd,
     AcceptCommandReceived, // just received `Accept` command
     AcceptChannelGenerated, // created channel, waiting to end the sync round
     AcceptGenerateComponent, // sync ended, back in non-sync, now generate component
     FinishSyncThenQuit,
+}
 pub struct ComponentTcpListener {
     // Properties for the tcp socket
     socket_state: ListenerSocketState,
     sync_state: ListenerSyncState,
     pending_component: Option<PendingComponent>,
     poll_ticket: Option<PollTicket>,
     inbox_main: InboxMain,
     inbox_backup: InboxBackup,
     pdl_input_port_id: PortId, // input port, receives commands
     pdl_output_port_id: PortId, // output port, sends connections
     // Type information extracted from protocol
     tcp_client_definition: (ProcedureDefinitionId, TypeId),
     input_union_accept_tag: i64,
     input_union_shutdown_tag: i64,
     output_struct_rx_index: usize,
     output_struct_tx_index: usize,
     // Generic component state
     exec_state: CompExecState,
     control: ControlLayer,
     consensus: Consensus,
+}
 impl Component for ComponentTcpListener {
     fn on_creation(&mut self, id: CompId, sched_ctx: &SchedulerCtx) {
         // Retrieve type information for the message with ports we're going to send
         let pd = &sched_ctx.runtime.protocol;
         self.tcp_client_definition = sched_ctx.runtime.protocol.find_procedure(b"std.internet", b"tcp_client")
             .expect("'tcp_client' component in the 'std.internet' module");
         let cmd_type = pd.find_type(b"std.internet", b"ListenerCmd")
             .expect("'ListenerCmd' type in the 'std.internet' module");
         let cmd_type = cmd_type.as_union();
         self.input_union_accept_tag = cmd_type.get_variant_tag_value(b"Accept").unwrap();
         self.input_union_shutdown_tag = cmd_type.get_variant_tag_value(b"Shutdown").unwrap();
         let conn_type = pd.find_type(b"std.internet", b"TcpConnection")
             .expect("'TcpConnection' type in the 'std.internet' module");
         let conn_type = conn_type.as_struct();
         assert_eq!(conn_type.get_num_struct_fields(), 2);
         self.output_struct_rx_index = conn_type.get_struct_field_index(b"rx").unwrap();
         self.output_struct_tx_index = conn_type.get_struct_field_index(b"tx").unwrap();
         // Register socket for async events
         if let ListenerSocketState::Connected(socket) = &self.socket_state {
             let self_handle = sched_ctx.runtime.get_component_public(id);
             let poll_ticket = sched_ctx.polling.register(socket, self_handle, true, false)
                 .expect("registering tcp listener");
             debug_assert!(self.poll_ticket.is_none());
             self.poll_ticket = Some(poll_ticket);
+        }
+    }
     fn on_shutdown(&mut self, sched_ctx: &SchedulerCtx) {
         if let Some(poll_ticket) = self.poll_ticket.take() {
             sched_ctx.polling.unregister(poll_ticket);
+        }
+    }
     fn adopt_message(&mut self, _comp_ctx: &mut CompCtx, _message: DataMessage) {
         unreachable!();
+    }
     fn handle_message(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx, message: Message) {
         match message {
             Message::Data(message) => {
                 self.handle_incoming_data_message(sched_ctx, comp_ctx, message);
             },
             Message::Sync(message) => {
                 let decision = self.consensus.receive_sync_message(sched_ctx, comp_ctx, message);
                 component::default_handle_sync_decision(sched_ctx, &mut self.exec_state, comp_ctx, decision, &mut self.consensus);
             },
             Message::Control(message) => {
                 if let Err(location_and_message) = component::default_handle_control_message(
                     &mut self.exec_state, &mut self.control, &mut self.consensus,
                     message, sched_ctx, comp_ctx, &mut self.inbox_main, &mut self.inbox_backup
                 ) {
                     component::default_handle_error_for_builtin(&mut self.exec_state, sched_ctx, location_and_message);
+                }
             },
             Message::Poll => {
                 sched_ctx.debug("Received polling event");
             },
+        }
+    }
     fn run(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx) -> CompScheduling {
         sched_ctx.info(&format!("Running component ComponentTcpListener (mode: {:?})", self.exec_state.mode));
         match self.exec_state.mode {
             CompMode::BlockedSelect
                 => unreachable!(),
             CompMode::PutPortsBlockedTransferredPorts |
             CompMode::PutPortsBlockedAwaitingAcks |
             CompMode::PutPortsBlockedSendingPort |
             CompMode::NewComponentBlocked
                 => return CompScheduling::Sleep,
             CompMode::NonSync => {
                 match &self.socket_state {
                     ListenerSocketState::Connected(_socket) => {
                         match self.sync_state {
                             ListenerSyncState::AwaitingCmd => {
                                 component::default_handle_sync_start(
                                     &mut self.exec_state, &mut self.inbox_main, sched_ctx, comp_ctx, &mut self.consensus
                                 );
                             },
                             ListenerSyncState::AcceptCommandReceived |
                             ListenerSyncState::AcceptChannelGenerated => unreachable!(),
                             ListenerSyncState::AcceptGenerateComponent => {
                                 // Now that we're outside the sync round, create the tcp client
                                 // component
                                 let pending = self.pending_component.take().unwrap();
                                 let arguments = ValueGroup::new_stack(vec![
                                     Value::SInt32(pending.client),
                                     Value::Input(port_id_to_eval(pending.cmd_rx)),
                                     Value::Output(port_id_to_eval(pending.data_tx)),
                                 ]);
                                 component::default_start_create_component(
                                     &mut self.exec_state, sched_ctx, comp_ctx, &mut self.control,
                                     &mut self.inbox_main, &mut self.inbox_backup,
                                     self.tcp_client_definition.0, self.tcp_client_definition.1,
                                     arguments
                                 );
                                 self.sync_state = ListenerSyncState::AwaitingCmd;
                             },
                             ListenerSyncState::FinishSyncThenQuit => {
                                 self.exec_state.set_as_start_exit(ExitReason::Termination);
                             },
+                        }
                         return CompScheduling::Immediate;
                     },
                     ListenerSocketState::ErrorReported(message) => {
                         component::default_handle_error_for_builtin(
                             &mut self.exec_state, sched_ctx,
                             (PortInstruction::NoSource, message.clone())
                         );
                         self.socket_state = ListenerSocketState::Error;
                         return CompScheduling::Immediate;
+                    }
                     ListenerSocketState::Error => {
                         return CompScheduling::Sleep;
+                    }
+                }
             },
             CompMode::Sync => {
                 match self.sync_state {
                     ListenerSyncState::AwaitingCmd => {
                         match component::default_attempt_get(
                             &mut self.exec_state, self.pdl_input_port_id, PortInstruction::NoSource,
                             &mut self.inbox_main, &mut self.inbox_backup, sched_ctx, comp_ctx,
                             &mut self.control, &mut self.consensus
                         ) {
                             GetResult::Received(message) => {
                                 let (tag_value, _) = message.content.values[0].as_union();
                                 if tag_value == self.input_union_accept_tag {
                                     self.sync_state = ListenerSyncState::AcceptCommandReceived;
                                 } else if tag_value == self.input_union_shutdown_tag {
                                     self.sync_state = ListenerSyncState::FinishSyncThenQuit;
                                 } else {
                                     unreachable!("got tag_value {}", tag_value);
+                                }
                                 return CompScheduling::Immediate;
                             },
                             GetResult::NoMessage => {
                                 return CompScheduling::Sleep;
                             },
                             GetResult::Error(location_and_message) => {
                                 component::default_handle_error_for_builtin(&mut self.exec_state, sched_ctx, location_and_message);
                                 return CompScheduling::Immediate;
+                            }
+                        }
                     },
                     ListenerSyncState::AcceptCommandReceived => {
                         let socket = self.socket_state.get_socket();
                         match socket.accept() {
                             Ok(client_handle) => {
                                 // Create the channels (and the inbox entries, to stay consistent
                                 // with the expectations from the `component` module's functions)
                                 let cmd_channel = comp_ctx.create_channel();
                                 let data_channel = comp_ctx.create_channel();
                                 let port_ids = [
                                     cmd_channel.putter_id, cmd_channel.getter_id,
                                     data_channel.putter_id, data_channel.getter_id,
                                 ];
                                 for port_id in port_ids {
                                     let expected_port_index = self.inbox_main.len();
                                     let port_handle = comp_ctx.get_port_handle(port_id);
                                     self.inbox_main.push(None);
                                     self.consensus.notify_of_new_port(expected_port_index, port_handle, comp_ctx);
+                                }
                                 // Construct the message containing the appropriate ports that will
                                 // be sent to the component commanding this listener.
                                 let mut values = ValueGroup::new_stack(Vec::with_capacity(1));
                                 values.values.push(Value::Struct(0));
                                 values.regions.push(vec![Value::Unassigned, Value::Unassigned]);
                                 values.regions[0][self.output_struct_tx_index] = Value::Output(port_id_to_eval(cmd_channel.putter_id));
                                 values.regions[0][self.output_struct_rx_index] = Value::Input(port_id_to_eval(data_channel.getter_id));
                                 if let Err(location_and_message) = component::default_send_data_message(
                                     &mut self.exec_state, self.pdl_output_port_id, PortInstruction::NoSource, values,
                                     sched_ctx, &mut self.consensus, &mut self.control, comp_ctx
                                 ) {
                                     component::default_handle_error_for_builtin(
                                         &mut self.exec_state, sched_ctx, location_and_message
                                     );
+                                }
                                 // Prepare for finishing the consensus round, and once finished,
                                 // create the tcp client component
                                 self.sync_state = ListenerSyncState::AcceptChannelGenerated;
                                 debug_assert!(self.pending_component.is_none());
                                 self.pending_component = Some(PendingComponent{
                                     client: client_handle,
                                     cmd_rx: cmd_channel.getter_id,
                                     data_tx: data_channel.putter_id
                                 });
                                 return CompScheduling::Requeue;
                             },
                             Err(err) => {
                                 if err.kind() == IoErrorKind::WouldBlock {
                                     return CompScheduling::Sleep;
                                 } else {
                                     component::default_handle_error_for_builtin(
                                         &mut self.exec_state, sched_ctx,
                                         (PortInstruction::NoSource, format!("failed to listen on socket, reason: {}", err))
                                     );
                                     return CompScheduling::Immediate;
+                                }
+                            }
+                        }
                     },
                     ListenerSyncState::AcceptChannelGenerated => {
                         component::default_handle_sync_end(&mut self.exec_state, sched_ctx, comp_ctx, &mut self.consensus);
                         self.sync_state = ListenerSyncState::AcceptGenerateComponent;
                         return CompScheduling::Requeue;
+                    }
                     ListenerSyncState::FinishSyncThenQuit => {
                         component::default_handle_sync_end(&mut self.exec_state, sched_ctx, comp_ctx, &mut self.consensus);
                         return CompScheduling::Requeue;
                     },
                     ListenerSyncState::AcceptGenerateComponent => unreachable!(),
+                }
             },
             CompMode::BlockedGet => {
                 return CompScheduling::Sleep;
             },
             CompMode::SyncEnd | CompMode::BlockedPut
                 => return CompScheduling::Sleep,
             CompMode::StartExit =>
                 return component::default_handle_start_exit(&mut self.exec_state, &mut self.control, sched_ctx, comp_ctx, &mut self.consensus),
             CompMode::BusyExit =>
                 return component::default_handle_busy_exit(&mut self.exec_state, &mut self.control, sched_ctx),
             CompMode::Exit =>
                 return component::default_handle_exit(&self.exec_state),
+        }
+    }
+}
 impl ComponentTcpListener {
     pub(crate) fn new(arguments: ValueGroup) -> Self {
         debug_assert_eq!(arguments.values.len(), 4);
         // Parsing arguments
         let input_port = component::port_id_from_eval(arguments.values[2].as_input());
         let output_port = component::port_id_from_eval(arguments.values[3].as_output());
         let socket_state = match ip_addr_and_port_from_args(&arguments, 0, 1) {
             Ok((ip_address, port)) => {
                 let socket = SocketTcpListener::new(ip_address, port);
                 match socket {
                     Ok(socket) => ListenerSocketState::Connected(socket),
                     Err(err) => ListenerSocketState::ErrorReported(format!("failed to create listener socket, reason: {:?}", err), )
+                }
             },
             Err(message) => ListenerSocketState::ErrorReported(message),
         };
         return Self {
             socket_state,
             sync_state: ListenerSyncState::AwaitingCmd,
             pending_component: None,
             poll_ticket: None,
             inbox_main: vec![None, None],
             inbox_backup: InboxBackup::new(),
             pdl_input_port_id: input_port,
             pdl_output_port_id: output_port,
             tcp_client_definition: (ProcedureDefinitionId::new_invalid(), TypeId::new_invalid()),
             input_union_accept_tag: -1,
             input_union_shutdown_tag: -1,
             output_struct_tx_index: 0,
             output_struct_rx_index: 0,
             exec_state: CompExecState::new(),
             control: ControlLayer::default(),
             consensus: Consensus::new(),
+        }
+    }
     fn handle_incoming_data_message(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, message: DataMessage) {
         if self.exec_state.mode.is_in_sync_block() {
             self.consensus.handle_incoming_data_message(comp_ctx, &message);
+        }
         match component::default_handle_incoming_data_message(
             &mut self.exec_state, &mut self.inbox_main, comp_ctx, message, sched_ctx, &mut self.control
         ) {
             IncomingData::PlacedInSlot => {},
             IncomingData::SlotFull(message) => {
                 self.inbox_backup.push(message);
+            }
+        }
+    }
+}
 fn ip_addr_and_port_from_args(
     arguments: &ValueGroup, ip_index: usize, port_index: usize
 ) -> Result<(IpAddr, u16), String> {
     debug_assert!(ip_index < arguments.values.len());
     debug_assert!(port_index < arguments.values.len());
     // Parsing IP address
     let ip_heap_pos = arguments.values[0].as_array();
     let ip_elements = &arguments.regions[ip_heap_pos as usize];
     let ip_address = match ip_elements.len() {
 => IpAddr::V4(Ipv4Addr::UNSPECIFIED),
 => IpAddr::V4(Ipv4Addr::new(
             ip_elements[0].as_uint8(), ip_elements[1].as_uint8(),
             ip_elements[2].as_uint8(), ip_elements[3].as_uint8()
         )),
         _ => return Err(format!("Expected 0 or 4 elements in the IP address, got {}", ip_elements.len())),
     };
     let port = arguments.values[port_index].as_uint16();
     return Ok((ip_address, port));
+}

src/runtime2/component/consensus.rs

➞

Show inline comments

 use crate::protocol::eval::ValueGroup;
 use crate::runtime2::scheduler::*;
 use crate::runtime2::runtime::*;
 use crate::runtime2::communication::*;
 use super::component_context::*;
 pub struct PortAnnotation {
     self_comp_id: CompId,
     self_port_id: PortId,
     peer_comp_id: CompId, // only valid for getter ports
     peer_port_id: PortId, // only valid for getter ports
     peer_discovered: bool, // only valid for getter ports
     mapping: Option<u32>,
     kind: PortKind,
+}
 impl PortAnnotation {
     fn new(comp_id: CompId, port_id: PortId, kind: PortKind) -> Self {
         return Self{
             self_comp_id: comp_id,
             self_port_id: port_id,
             peer_comp_id: CompId::new_invalid(),
             peer_port_id: PortId::new_invalid(),
             peer_discovered: false,
             mapping: None,
             kind,
+        }
+    }
+}
 #[derive(Debug, Eq, PartialEq)]
 enum Mode {
     NonSync,
     SyncBusy,
     SyncAwaitingSolution,
     SelectBusy,
     SelectWait,
+}
 struct SolutionCombiner {
     solution: SyncPartialSolution,
     matched_channels: usize,
+}
 impl SolutionCombiner {
     fn new() -> Self {
         return Self {
             solution: SyncPartialSolution::default(),
             matched_channels: 0,
+        }
+    }
     #[inline]
     fn has_contributions(&self) -> bool {
         return !self.solution.channel_mapping.is_empty();
+    }
     /// Returns a decision for the current round. If there is no decision (yet)
     /// then `RoundDecision::None` is returned.
     fn get_decision(&self) -> SyncRoundDecision {
         if self.matched_channels == self.solution.channel_mapping.len() {
             debug_assert_ne!(self.solution.decision, SyncRoundDecision::None);
             return self.solution.decision;
+        }
         return SyncRoundDecision::None; // even in case of failure: wait for everyone.
+    }
     fn combine_with_partial_solution(&mut self, partial: SyncPartialSolution) {
         debug_assert_ne!(self.solution.decision, SyncRoundDecision::Solution);
         debug_assert_ne!(partial.decision, SyncRoundDecision::Solution);
         if partial.decision == SyncRoundDecision::Failure {
             self.solution.decision = SyncRoundDecision::Failure;
+        }
         for entry in partial.channel_mapping {
             let channel_index = if entry.getter.is_some() && entry.putter.is_some() {
                 let channel_index = self.solution.channel_mapping.len();
                 self.solution.channel_mapping.push(entry);
                 channel_index
             } else if let Some(putter) = entry.putter {
                 self.combine_with_putter_port(putter)
             } else if let Some(getter) = entry.getter {
                 self.combine_with_getter_port(getter)
             } else {
                 unreachable!(); // both putter and getter are None
             };
             let channel = &self.solution.channel_mapping[channel_index];
             if let Some(consistent) = Self::channel_is_consistent(channel) {
                 if !consistent {
                     self.solution.decision = SyncRoundDecision::Failure;
+                }
                 self.matched_channels += 1;
+            }
+        }
         self.update_solution();
+    }
     /// Combines the currently stored global solution (if any) with the newly
     /// provided local solution. Make sure to check the `has_decision` return
     /// value afterwards.
     fn combine_with_local_solution(&mut self, _comp_id: CompId, solution: SyncLocalSolution) {
         debug_assert_ne!(self.solution.decision, SyncRoundDecision::Solution);
         // Combine partial solution with the local solution entries
         for entry in solution {
             // Match the current entry up with its peer endpoint, or add a new
             // entry.
             let channel_index = match entry {
                 SyncLocalSolutionEntry::Putter(putter) => {
                     self.combine_with_putter_port(putter)
                 },
                 SyncLocalSolutionEntry::Getter(getter) => {
                     self.combine_with_getter_port(getter)
+                }
             };
             // Check if channel is now consistent
             let channel = &self.solution.channel_mapping[channel_index];
             if let Some(consistent) = Self::channel_is_consistent(channel) {
                 if !consistent {
                     self.solution.decision = SyncRoundDecision::Failure;
+                }
                 self.matched_channels += 1;
+            }
+        }
         self.update_solution();
+    }
     /// Takes whatever partial solution is present in the solution combiner and
     /// returns it. The solution combiner's solution will end up being empty.
     /// This is used when a new leader is found and we need to pass along our
     /// partial results.
     fn take_partial_solution(&mut self) -> SyncPartialSolution {
         let mut partial_solution = SyncPartialSolution::default();
         std::mem::swap(&mut partial_solution, &mut self.solution);
         self.clear();
         return partial_solution;
+    }
     fn clear(&mut self) {
         self.solution.channel_mapping.clear();
         self.solution.decision = SyncRoundDecision::None;
         self.matched_channels = 0;
+    }
     // --- Small utilities for combining solutions
     fn combine_with_putter_port(&mut self, putter: SyncSolutionPutterPort) -> usize {
         let channel_index = self.get_channel_index_for_putter(putter.self_comp_id, putter.self_port_id);
         if let Some(channel_index) = channel_index {
             let channel = &mut self.solution.channel_mapping[channel_index];
             debug_assert!(channel.putter.is_none());
             channel.putter = Some(putter);
             return channel_index;
         } else {
             let channel_index = self.solution.channel_mapping.len();
             self.solution.channel_mapping.push(SyncSolutionChannel{
                 putter: Some(putter),
                 getter: None,
             });
             return channel_index;
+        }
+    }
     fn combine_with_getter_port(&mut self, getter: SyncSolutionGetterPort) -> usize {
         let channel_index = self.get_channel_index_for_getter(getter.peer_comp_id, getter.peer_port_id);
         if let Some(channel_index) = channel_index {
             let channel = &mut self.solution.channel_mapping[channel_index];
             debug_assert!(channel.getter.is_none());
             channel.getter = Some(getter);
             return channel_index;
         } else {
             let channel_index = self.solution.channel_mapping.len();
             self.solution.channel_mapping.push(SyncSolutionChannel{
                 putter: None,
                 getter: Some(getter)
             });
             return channel_index;
+        }
+    }
     /// Retrieve index of the channel containing a getter port that has received
     /// from the specified putter port.
     fn get_channel_index_for_putter(&self, putter_comp_id: CompId, putter_port_id: PortId) -> Option<usize> {
         for (channel_index, channel) in self.solution.channel_mapping.iter().enumerate() {
             if let Some(getter) = &channel.getter {
                 if getter.peer_comp_id == putter_comp_id && getter.peer_port_id == putter_port_id {
                     return Some(channel_index);
+                }
+            }
+        }
         return None;
+    }
     /// Retrieve index of the channel for a getter port. To find this channel
     /// the **peer** component/port IDs of the getter port are used.
     fn get_channel_index_for_getter(&self, peer_comp_id: CompId, peer_port_id: PortId) -> Option<usize> {
         for (channel_index, channel) in self.solution.channel_mapping.iter().enumerate() {
             if let Some(putter) = &channel.putter {
                 if putter.self_comp_id == peer_comp_id && putter.self_port_id == peer_port_id {
                     return Some(channel_index);
+                }
+            }
+        }
         return None;
+    }
     fn channel_is_consistent(channel: &SyncSolutionChannel) -> Option<bool> {
         if channel.putter.is_none() || channel.getter.is_none() {
             return None;
+        }
         let putter = channel.putter.as_ref().unwrap();
         let getter = channel.getter.as_ref().unwrap();
         return Some(
             !putter.failed &&
             !getter.failed &&
             putter.mapping == getter.mapping
         );
+    }
     /// Determines the global solution if all components have contributed their
     /// local solutions.
     fn update_solution(&mut self) {
         if self.matched_channels == self.solution.channel_mapping.len() {
             if self.solution.decision != SyncRoundDecision::Failure {
                 self.solution.decision = SyncRoundDecision::Solution;
+            }
+        }
+    }
+}
 /// Tracking consensus state
 pub struct Consensus {
     // General state of consensus manager
     mapping_counter: u32,
     mode: Mode,
     // State associated with sync round
     round_index: u32,
     highest_id: CompId,
     ports: Vec<PortAnnotation>,
     // State associated with arriving at a solution and being a (temporary)
     // leader in the consensus round
     solution: SolutionCombiner,
+}
 impl Consensus {
     pub(crate) fn new() -> Self {
         return Self{
             round_index: 0,
             highest_id: CompId::new_invalid(),
             ports: Vec::new(),
             mapping_counter: 0,
             mode: Mode::NonSync,
             solution: SolutionCombiner::new(),
+        }
+    }
     // -------------------------------------------------------------------------
     // Managing sync state
     // -------------------------------------------------------------------------
     /// Notifies the consensus management that the PDL code has reached the
     /// start of a sync block.
     pub(crate) fn notify_sync_start(&mut self, comp_ctx: &CompCtx) {
         debug_assert_eq!(self.mode, Mode::NonSync);
         self.highest_id = comp_ctx.id;
         self.mapping_counter = 0;
         self.mode = Mode::SyncBusy;
         // Make the internally stored port annotation array consistent with the
         // ports that the component currently owns. They should match by index
         // (i.e. annotation at index `i` corresponds to port `i` in `comp_ctx`).
         let mut needs_setting_ports = false;
         if comp_ctx.num_ports() != self.ports.len() {
             needs_setting_ports = true;
         } else {
             for (idx, port) in comp_ctx.iter_ports().enumerate() {
                 let comp_port_id = port.self_id;
                 let cons_port_id = self.ports[idx].self_port_id;
                 if comp_port_id != cons_port_id {
                     needs_setting_ports = true;
                     break;
+                }
+            }
+        }
         if needs_setting_ports {
             // Reset all ports
             self.ports.clear();
             self.ports.reserve(comp_ctx.num_ports());
             for port in comp_ctx.iter_ports() {
                 self.ports.push(PortAnnotation::new(comp_ctx.id, port.self_id, port.kind));
+            }
         } else {
             // Make sure that we consider all peers as undiscovered again
             for annotation in self.ports.iter_mut() {
                 annotation.peer_discovered = false;
+            }
+        }
+    }
     /// Notifies the consensus management that the PDL code has reached the end
     /// of a sync block. A local solution will be submitted, after which we wait
     /// until the participants in the round (hopefully) reach a conclusion.
     pub(crate) fn notify_sync_end_success(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx) -> SyncRoundDecision {
         debug_assert_eq!(self.mode, Mode::SyncBusy);
         self.mode = Mode::SyncAwaitingSolution;
         let local_solution = self.generate_local_solution(comp_ctx, false);
         let decision = self.handle_local_solution(sched_ctx, comp_ctx, comp_ctx.id, local_solution, false);
         return decision;
+    }
     /// Notifies the consensus management that the component has encountered a
     /// critical error during the synchronous round. Hence we should report that
     /// we've failed and wait until all the participants have been notified of
     /// the error.
     pub(crate) fn notify_sync_end_failure(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx) -> SyncRoundDecision {
         debug_assert_eq!(self.mode, Mode::SyncBusy);
         self.mode = Mode::SyncAwaitingSolution;
         let local_solution = self.generate_local_solution(comp_ctx, true);
         let decision = self.handle_local_solution(sched_ctx, comp_ctx, comp_ctx.id, local_solution, true);
         return decision;
+    }
     /// Notifies that a decision has been reached. Note that the caller should
     /// still take the appropriate actions based on the decision it is supplying
     /// to the consensus layer.
     pub(crate) fn notify_sync_decision(&mut self, _decision: SyncRoundDecision) {
         // Reset everything for the next round
         debug_assert_eq!(self.mode, Mode::SyncAwaitingSolution);
         self.mode = Mode::NonSync;
         self.round_index = self.round_index.wrapping_add(1);
         for port in self.ports.iter_mut() {
             port.mapping = None;
+        }
         self.solution.clear();
+    }
-    pub(crate) fn notify_received_port(&mut self, _expected_index: usize, port_handle: LocalPortHandle, comp_ctx: &CompCtx) {
+    pub(crate) fn notify_of_new_port(&mut self, _expected_index: usize, port_handle: LocalPortHandle, comp_ctx: &CompCtx) {
         debug_assert_eq!(_expected_index, self.ports.len());
         let port_info = comp_ctx.get_port(port_handle);
         self.ports.push(PortAnnotation{
             self_comp_id: comp_ctx.id,
             self_port_id: port_info.self_id,
             peer_comp_id: port_info.peer_comp_id,
             peer_port_id: port_info.peer_port_id,
             peer_discovered: false,
             mapping: None,
             kind: port_info.kind,
         });
+    }
     // -------------------------------------------------------------------------
     // Handling inbound and outbound messages
     // -------------------------------------------------------------------------
     /// Prepares a set of values to be sent of a channel.
     pub(crate) fn annotate_data_message(&mut self, comp_ctx: &CompCtx, port_info: &Port, content: ValueGroup) -> DataMessage {
         debug_assert_eq!(self.mode, Mode::SyncBusy); // can only send between sync start and sync end
         debug_assert!(self.ports.iter().any(|v| v.self_port_id == port_info.self_id));
         let data_header = self.create_data_header_and_update_mapping(port_info);
         let sync_header = self.create_sync_header(comp_ctx);
         return DataMessage{
             data_header, sync_header, content,
             ports: Vec::new()
         };
+    }
     /// Handles the arrival of a new data message (needs to be called for every
     /// new data message, even though it might not end up being received). This
     /// is used to determine peers of `get`ter ports.
     // TODO: The use of this function is rather ugly. Find a more robust
     //  scheme about owners of `get`ter ports not knowing about their peers.
     pub(crate) fn handle_incoming_data_message(&mut self, comp_ctx: &CompCtx, message: &DataMessage) {
         let target_handle = comp_ctx.get_port_handle(message.data_header.target_port);
         let target_index = comp_ctx.get_port_index(target_handle);
         let annotation = &mut self.ports[target_index];
         debug_assert!(
             !annotation.peer_discovered || (
                 annotation.peer_comp_id == message.sync_header.sending_id &&
                 annotation.peer_port_id == message.data_header.source_port
+            )
         );
         annotation.peer_comp_id = message.sync_header.sending_id;
         annotation.peer_port_id = message.data_header.source_port;
         annotation.peer_discovered = true;
+    }
     /// Checks if the data message can be received (due to port annotations), if
     /// it can then `true` is returned and the caller is responsible for handing
     /// the message of to the PDL code. Otherwise the message cannot be
     /// received.
     pub(crate) fn try_receive_data_message(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, message: &DataMessage) -> bool {
         debug_assert_eq!(self.mode, Mode::SyncBusy);
         debug_assert!(self.ports.iter().any(|v| v.self_port_id == message.data_header.target_port));
         // Make sure the expected mapping matches the currently stored mapping
         for (peer_port_kind, expected_annotation) in &message.data_header.expected_mapping {
             // Determine our annotation, in order to do so we need to find the
             // port matching the peer ports
             let mut self_annotation = None;
             let mut self_annotation_found = false;
             match peer_port_kind {
                 PortAnnotationKind::Putter(peer_port) => {
                     for self_port in &self.ports {
                         if self_port.kind == PortKind::Getter &&
                             self_port.peer_discovered &&
                             self_port.peer_comp_id == peer_port.self_comp_id &&
                             self_port.peer_port_id == peer_port.self_port_id
+                        {
                             self_annotation = self_port.mapping;
                             self_annotation_found = true;
                             break;
+                        }
+                    }
                 },
                 PortAnnotationKind::Getter(peer_port) => {
                     if peer_port.peer_comp_id == comp_ctx.id {
                         // Peer indicates that we talked to it
                         let self_port_handle = comp_ctx.get_port_handle(peer_port.peer_port_id);
                         let self_port_index = comp_ctx.get_port_index(self_port_handle);
                         self_annotation = self.ports[self_port_index].mapping;
                         self_annotation_found = true;
+                    }
+                }
+            }
             if !self_annotation_found {
                 continue
+            }
             if self_annotation != *expected_annotation {
                 return false;
+            }
+        }
         // Expected mapping matches current mapping, so we will receive the message
         self.set_annotation(message.sync_header.sending_id, &message.data_header);
         // Handle the sync header embedded within the data message
         self.handle_sync_header(sched_ctx, comp_ctx, &message.sync_header);
         return true;
+    }
     /// Receives the sync message and updates the consensus state appropriately.
     pub(crate) fn receive_sync_message(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, message: SyncMessage) -> SyncRoundDecision {
         // Whatever happens: handle the sync header (possibly changing the
         // currently registered leader)
         self.handle_sync_header(sched_ctx, comp_ctx, &message.sync_header);
         match message.content {
             SyncMessageContent::NotificationOfLeader => {
                 return SyncRoundDecision::None;
             },
             SyncMessageContent::LocalSolution(solution_generator_id, local_solution) => {
                 return self.handle_local_solution(sched_ctx, comp_ctx, solution_generator_id, local_solution, false);
             },
             SyncMessageContent::PartialSolution(partial_solution) => {
                 return self.handle_partial_solution(sched_ctx, comp_ctx, partial_solution);
             },
             SyncMessageContent::GlobalSolution => {
                 debug_assert_eq!(self.mode, Mode::SyncAwaitingSolution); // leader can only find global- if we submitted local solution
                 return SyncRoundDecision::Solution;
             },
             SyncMessageContent::GlobalFailure => {
                 debug_assert_eq!(self.mode, Mode::SyncAwaitingSolution);
                 return SyncRoundDecision::Failure;
+            }
+        }
+    }
     fn handle_sync_header(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, header: &MessageSyncHeader) {
         if header.highest_id.0 > self.highest_id.0 {
             // Sender knows of someone with a higher ID. So store highest ID,
             // notify all peers, and forward local solutions
             self.highest_id = header.highest_id;
             for peer in comp_ctx.iter_peers() {
                 if peer.id == header.sending_id {
                     continue; // do not send to sender: it has the higher ID
+                }
                 // also: only send if we received a message in this round
                 let mut performed_communication = false; // TODO: Revise, temporary fix
                 for port in self.ports.iter() {
                     if port.peer_comp_id == peer.id && port.mapping.is_some() {
                         performed_communication = true;
                         break;
+                    }
+                }
                 if !performed_communication {
                     continue;
+                }
                 let message = SyncMessage{
                     sync_header: self.create_sync_header(comp_ctx),
                     content: SyncMessageContent::NotificationOfLeader,
                 };
                 peer.handle.send_message_logged(sched_ctx, Message::Sync(message), true);
+            }
             self.forward_partial_solution(sched_ctx, comp_ctx);
         } else if header.highest_id.0 < self.highest_id.0 {
             // Sender has a lower ID, so notify it of our higher one
             let message = SyncMessage{
                 sync_header: self.create_sync_header(comp_ctx),
                 content: SyncMessageContent::NotificationOfLeader,
             };
             let peer_handle = comp_ctx.get_peer_handle(header.sending_id);
             let peer_info = comp_ctx.get_peer(peer_handle);
             peer_info.handle.send_message_logged(sched_ctx, Message::Sync(message), true);
         } // else: exactly equal
+    }
     fn set_annotation(&mut self, source_comp_id: CompId, data_header: &MessageDataHeader) {
         for annotation in self.ports.iter_mut() {
             if annotation.self_port_id == data_header.target_port {
                 // Message should have already passed the `handle_new_data_message` function, so we
                 // should have already annotated the peer of the port.
                 debug_assert!(
                     annotation.peer_discovered &&
                     annotation.peer_comp_id == source_comp_id &&
                     annotation.peer_port_id == data_header.source_port
                 );
                 annotation.mapping = Some(data_header.new_mapping);
+            }
+        }
+    }
     // -------------------------------------------------------------------------
     // Leader-related methods
     // -------------------------------------------------------------------------
     fn forward_partial_solution(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx) {
         debug_assert_ne!(self.highest_id, comp_ctx.id); // not leader
         // Make sure that we have something to send
         if !self.solution.has_contributions() {
             return;
+        }
         // Swap the container with the partial solution and then send it along
         let partial_solution = self.solution.take_partial_solution();
         self.send_to_leader(sched_ctx, comp_ctx, Message::Sync(SyncMessage{
             sync_header: self.create_sync_header(comp_ctx),
             content: SyncMessageContent::PartialSolution(partial_solution),
         }));
+    }
     fn handle_local_solution(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx, solution_sender_id: CompId, solution: SyncLocalSolution, fail_if_empty: bool) -> SyncRoundDecision {
         if self.highest_id == comp_ctx.id {
             // We are the leader
             self.solution.combine_with_local_solution(solution_sender_id, solution);
             let mut round_decision = self.solution.get_decision();
             if round_decision != SyncRoundDecision::None {
                 if fail_if_empty && self.solution.matched_channels == 0 {
                     // TODO: Not sure about this, bit of a hack. Situation is that a component
                     //  cannot interact with other components, but it is in a sync round, and has
                     //  failed that sync round.
                     round_decision = SyncRoundDecision::Failure;
+                }
                 self.broadcast_decision(sched_ctx, comp_ctx, round_decision);
+            }
             return round_decision;
         } else {
             // Forward the solution
             let message = SyncMessage{
                 sync_header: self.create_sync_header(comp_ctx),
                 content: SyncMessageContent::LocalSolution(solution_sender_id, solution),
             };
             self.send_to_leader(sched_ctx, comp_ctx, Message::Sync(message));
             return SyncRoundDecision::None;
+        }
+    }
     fn handle_partial_solution(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, solution: SyncPartialSolution) -> SyncRoundDecision {
         if self.highest_id == comp_ctx.id {
             // We are the leader, combine existing and new solution
             self.solution.combine_with_partial_solution(solution);
             let round_decision = self.solution.get_decision();
             if round_decision != SyncRoundDecision::None {
                 self.broadcast_decision(sched_ctx, comp_ctx, round_decision);
+            }
             return round_decision;
         } else {
             // Forward the partial solution
             let message = SyncMessage{
                 sync_header: self.create_sync_header(comp_ctx),
                 content: SyncMessageContent::PartialSolution(solution),
             };
             self.send_to_leader(sched_ctx, comp_ctx, Message::Sync(message));
             return SyncRoundDecision::None;
+        }
+    }
     fn broadcast_decision(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx, decision: SyncRoundDecision) {
         debug_assert_eq!(self.highest_id, comp_ctx.id);
         let is_success = match decision {
             SyncRoundDecision::None => unreachable!(),
             SyncRoundDecision::Solution => true,
             SyncRoundDecision::Failure => false,
         };
         let mut peers = Vec::with_capacity(self.solution.solution.channel_mapping.len()); // TODO: @Performance
         for channel in self.solution.solution.channel_mapping.iter() {
             let getter = channel.getter.as_ref().unwrap();
             if getter.self_comp_id != comp_ctx.id && !peers.contains(&getter.self_comp_id) {
                 peers.push(getter.self_comp_id);
+            }
             if getter.peer_comp_id != comp_ctx.id && !peers.contains(&getter.peer_comp_id) {
                 peers.push(getter.peer_comp_id);
+            }
+        }
         for peer in peers {
             let mut handle = sched_ctx.runtime.get_component_public(peer);
             let message = Message::Sync(SyncMessage{
                 sync_header: self.create_sync_header(comp_ctx),
                 content: if is_success { SyncMessageContent::GlobalSolution } else { SyncMessageContent::GlobalFailure },
             });
             handle.send_message_logged(sched_ctx, message, true);
             let _should_remove = handle.decrement_users();
             debug_assert!(_should_remove.is_none());
+        }
+    }
     fn send_to_leader(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx, message: Message) {
         debug_assert_ne!(self.highest_id, comp_ctx.id); // we're not the leader, // TODO: @NoDirectHandle
         let mut leader_info = sched_ctx.runtime.get_component_public(self.highest_id);
         leader_info.send_message_logged(sched_ctx, message, true);
         let should_remove = leader_info.decrement_users();
         if let Some(key) = should_remove {
             sched_ctx.runtime.destroy_component(key);
+        }
+    }
     // -------------------------------------------------------------------------
     // Small utilities
     // -------------------------------------------------------------------------
     fn generate_local_solution(&self, comp_ctx: &CompCtx, failed: bool) -> SyncLocalSolution {
         let mut local_solution = Vec::with_capacity(self.ports.len());
         for port in &self.ports {
             if let Some(mapping) = port.mapping {
                 let port_handle = comp_ctx.get_port_handle(port.self_port_id);
                 let port_info = comp_ctx.get_port(port_handle);
                 let new_entry = match port_info.kind {
                     PortKind::Putter => SyncLocalSolutionEntry::Putter(SyncSolutionPutterPort{
                         self_comp_id: comp_ctx.id,
                         self_port_id: port_info.self_id,
                         mapping,
                         failed
                     }),
                     PortKind::Getter => SyncLocalSolutionEntry::Getter(SyncSolutionGetterPort{
                         self_comp_id: comp_ctx.id,
                         self_port_id: port_info.self_id,
                         peer_comp_id: port.peer_comp_id,
                         peer_port_id: port.peer_port_id,
                         mapping,
                         failed
                     })
                 };
                 local_solution.push(new_entry);
+            }
+        }
         return local_solution;
+    }
     fn create_data_header_and_update_mapping(&mut self, port_info: &Port) -> MessageDataHeader {
         let mut expected_mapping = Vec::with_capacity(self.ports.len());
         let mut port_index = usize::MAX;
         for (index, port) in self.ports.iter().enumerate() {
             if port.self_port_id == port_info.self_id {
                 port_index = index; // remember for later updating
+            }
             // Add all of the
             let annotation_kind = match port.kind {
                 PortKind::Putter => {
                     PortAnnotationKind::Putter(PortAnnotationPutter{
                         self_comp_id: port.self_comp_id,
                         self_port_id: port.self_port_id
                     })
                 },
                 PortKind::Getter => {
                     if !port.peer_discovered {
                         continue;
+                    }
                     PortAnnotationKind::Getter(PortAnnotationGetter{
                         self_comp_id: port.self_comp_id,
                         self_port_id: port.self_port_id,
                         peer_comp_id: port.peer_comp_id,
                         peer_port_id: port.peer_port_id,
                     })
+                }
             };
             expected_mapping.push((annotation_kind, port.mapping));
+        }
         let new_mapping = self.take_mapping();
         self.ports[port_index].mapping = Some(new_mapping);
         debug_assert_eq!(port_info.kind, PortKind::Putter);
         return MessageDataHeader{
             expected_mapping,
             new_mapping,
             source_port: port_info.self_id,
             target_port: port_info.peer_port_id,
         };
+    }
     #[inline]
     fn create_sync_header(&self, comp_ctx: &CompCtx) -> MessageSyncHeader {
         return MessageSyncHeader{
             sync_round: self.round_index,
             sending_id: comp_ctx.id,
             highest_id: self.highest_id,
         };

src/runtime2/poll/mod.rs

➞

Show inline comments

 use libc::{self, c_int};
 use std::{io, ptr, time, thread};
 use std::sync::Arc;
 use std::sync::atomic::{AtomicU32, Ordering};
 use std::collections::HashMap;
 use crate::runtime2::RtError;
 use crate::runtime2::runtime::{CompHandle, RuntimeInner, LogLevel};
 use crate::runtime2::store::queue_mpsc::*;
 pub(crate) type FileDescriptor = c_int;
 pub(crate) trait AsFileDescriptor {
     fn as_file_descriptor(&self) -> FileDescriptor;
+}
 #[derive(Copy, Clone)]
 pub(crate) struct UserData(u64);
 // -----------------------------------------------------------------------------
 // Poller
 // -----------------------------------------------------------------------------
 #[cfg(unix)]
 pub(crate) struct Poller {
     handle: c_int,
+}
 // All of this is gleaned from the `mio` crate.
 #[cfg(unix)]
 impl Poller {
     pub fn new() -> io::Result<Self> {
         let handle = syscall_result(unsafe{ libc::epoll_create1(libc::EPOLL_CLOEXEC) })?;
         return Ok(Self{
             handle,
         })
+    }
     fn register(&self, fd: FileDescriptor, user: UserData, read: bool, write: bool) -> io::Result<()> {
         let mut event = libc::epoll_event{
             events: Self::events_from_rw_flags(read, write),
             u64: user.0,
         };
         syscall_result(unsafe{
             libc::epoll_ctl(self.handle, libc::EPOLL_CTL_ADD, fd, &mut event)
         })?;
         return Ok(());
+    }
     fn unregister(&self, fd: FileDescriptor) -> io::Result<()> {
         syscall_result(unsafe{
             libc::epoll_ctl(self.handle, libc::EPOLL_CTL_DEL, fd, ptr::null_mut())
         })?;
         return Ok(());
+    }
     /// Performs `epoll_wait`, waiting for the provided timeout or until events
     /// are reported. They are stored in the `events` variable (up to
     /// `events.cap()` are reported, so ensure it is preallocated).
     pub fn wait(&self, events: &mut Vec<libc::epoll_event>, timeout: time::Duration) -> io::Result<()> {
         // See `mio` for the reason. Works around a linux bug
         #[cfg(target_pointer_width = "32")]
         const MAX_TIMEOUT: u128 = 1789569;
         #[cfg(not(target_pointer_width = "32"))]
         const MAX_TIMEOUT: u128 = c_int::MAX as u128;
         let timeout_millis = timeout.as_millis();
         let timeout_millis = if timeout_millis > MAX_TIMEOUT {
             -1 // effectively infinite
         } else {
             timeout_millis as c_int
         };
         debug_assert!(events.is_empty());
         debug_assert!(events.capacity() > 0 && events.capacity() < i32::MAX as usize);
         let num_events = syscall_result(unsafe{
             libc::epoll_wait(self.handle, events.as_mut_ptr(), events.capacity() as i32, timeout_millis)
         })?;
         unsafe{
             debug_assert!(num_events >= 0);
             events.set_len(num_events as usize);
+        }
         return Ok(());
+    }
     fn events_from_rw_flags(read: bool, write: bool) -> u32 {
         let mut events = libc::EPOLLET;
         if read {
             events |= libc::EPOLLIN | libc::EPOLLRDHUP;
+        }
         if write {
             events |= libc::EPOLLOUT;
+        }
         return events as u32;
+    }
+}
 #[cfg(unix)]
 impl Drop for Poller {
     fn drop(&mut self) {
         unsafe{ libc::close(self.handle); }
+    }
+}
 #[inline]
 fn syscall_result(result: c_int) -> io::Result<c_int> {
     if result < 0 {
         return Err(io::Error::last_os_error());
     } else {
         return Ok(result);
+    }
+}
 #[cfg(not(unix))]
 struct Poller {
     // Not implemented for OS's other than unix
+}
 // -----------------------------------------------------------------------------
 // Polling Thread
 // -----------------------------------------------------------------------------
 enum PollCmd {
     Register(CompHandle, UserData),
     Unregister(FileDescriptor, UserData),
     Shutdown,
+}
 pub struct PollingThread {
     poller: Arc<Poller>,
     runtime: Arc<RuntimeInner>,
     queue: QueueDynMpsc<PollCmd>,
     log_level: LogLevel,
+}
 impl PollingThread {
     pub(crate) fn new(runtime: Arc<RuntimeInner>, log_level: LogLevel) -> Result<(PollingThreadHandle, PollingClientFactory), RtError> {
         let poller = Poller::new()
             .map_err(|e| rt_error!("failed to create poller, because: {}", e))?;
         let poller = Arc::new(poller);
         let queue = QueueDynMpsc::new(64);
         let queue_producers = queue.producer_factory();
         let mut thread_data = PollingThread{
             poller: poller.clone(),
             runtime: runtime.clone(),
             queue,
             log_level,
         };
         let thread_handle = thread::Builder::new()
             .name(String::from("poller"))
             .spawn(move || { thread_data.run() })
             .map_err(|reason|
                 rt_error!("failed to start polling thread, because: {}", reason)
             )?;
         let thread_handle = PollingThreadHandle{
             queue: Some(queue_producers.producer()),
             handle: Some(thread_handle),
         };
         let client_factory = PollingClientFactory{
             poller,
             generation_counter: Arc::new(AtomicU32::new(0)),
             queue_factory: queue_producers,
         };
         return Ok((thread_handle, client_factory));
+    }
     pub(crate) fn run(&mut self) {
         use std::io::ErrorKind;
         use crate::runtime2::communication::Message;
         const NUM_EVENTS: usize = 256;
         const EPOLL_DURATION: time::Duration = time::Duration::from_millis(250);
         // @performance: Lot of improvements possible here, a HashMap is likely
         // a horrible way to do this.
         let mut events = Vec::with_capacity(NUM_EVENTS);
         let mut lookup = HashMap::with_capacity(64);
         self.log("Starting polling thread");
         loop {
             // Retrieve events first (because the PollingClient will first
             // register at epoll, and then push a command into the queue).
             loop {
                 let wait_result = self.poller.wait(&mut events, EPOLL_DURATION);
                 match wait_result {
                     Ok(()) => break,
                     Err(reason) => {
                         match reason.kind() {
                             ErrorKind::Interrupted => {
                                 // Happens when we're debugging and set a break-
                                 // point, we want to continue waiting
                             },
                             _ => {
                                 panic!("failed to poll: {}", reason);
+                            }
+                        }
+                    }
+                }
+            }
             // Then handle everything in the command queue.
             while let Some(command) = self.queue.pop() {
                 match command {
                     PollCmd::Register(handle, user_data) => {
                         self.log(&format!("Registering component {:?} as {}", handle.id(), user_data.0));
                         let key = Self::user_data_as_key(user_data);
                         debug_assert!(!lookup.contains_key(&key));
                         lookup.insert(key, handle);
                     },
                     PollCmd::Unregister(_file_descriptor, user_data) => {
                         let key = Self::user_data_as_key(user_data);
                         debug_assert!(lookup.contains_key(&key));
                         let mut handle = lookup.remove(&key).unwrap();
                         self.log(&format!("Unregistering component {:?} as {}", handle.id(), user_data.0));
                         if let Some(key) = handle.decrement_users() {
                             self.runtime.destroy_component(key);
+                        }
                     },
                     PollCmd::Shutdown => {
                         // The contract is that all scheduler threads shutdown
                         // before the polling thread. This happens when all
                         // components are removed.
                         self.log("Received shutdown signal");
                         debug_assert!(lookup.is_empty());
                         return;
+                    }
+                }
+            }
             // Now process all of the events. Because we might have had a
             // `Register` command followed by an `Unregister` command (e.g. a
             // component has died), we might get events that are not associated
             // with an entry in the lookup.
             for event in events.drain(..) {
                 let key = event.u64;
                 if let Some(handle) = lookup.get(&key) {
                     let events = event.events;
                     self.log(&format!("Sending poll to {:?} (event: {:x})", handle.id(), events));
                     handle.send_message(&self.runtime, Message::Poll, true);
+                }
+            }
+        }
+    }
     #[inline]
     fn user_data_as_key(data: UserData) -> u64 {
         return data.0;
+    }
     fn log(&self, message: &str) {
-        if self.log_level >= LogLevel::Info {
+        if LogLevel::Info >= self.log_level {
             println!("[polling] {}", message);
+        }
+    }
+}
 // bit convoluted, but it works
 pub(crate) struct PollingThreadHandle {
     // requires Option, because:
     queue: Option<QueueDynProducer<PollCmd>>, // destructor needs to be called
     handle: Option<thread::JoinHandle<()>>, // we need to call `join`
+}
 impl PollingThreadHandle {
     pub(crate) fn shutdown(&mut self) -> thread::Result<()> {
         debug_assert!(self.handle.is_some(), "polling thread already destroyed");
         self.queue.take().unwrap().push(PollCmd::Shutdown);
         return self.handle.take().unwrap().join();
+    }
+}
 impl Drop for PollingThreadHandle {
     fn drop(&mut self) {
         debug_assert!(self.queue.is_none() && self.handle.is_none());
+    }
+}
 // oh my god, now I'm writing factory objects. I'm not feeling too well
 pub(crate) struct PollingClientFactory {
     poller: Arc<Poller>,
     generation_counter: Arc<AtomicU32>,
     queue_factory: QueueDynProducerFactory<PollCmd>,
+}
 impl PollingClientFactory {
     pub(crate) fn client(&self) -> PollingClient {
         return PollingClient{
             poller: self.poller.clone(),
             generation_counter: self.generation_counter.clone(),
             queue: self.queue_factory.producer(),
         };
+    }
+}
 pub(crate) struct PollTicket(FileDescriptor, u64);
 /// A structure that allows the owner to register components at the polling
 /// thread. Because of assumptions in the communication queue all of these
 /// clients should be dropped before stopping the polling thread.
 pub(crate) struct PollingClient {
     poller: Arc<Poller>,
     generation_counter: Arc<AtomicU32>,
     queue: QueueDynProducer<PollCmd>,
+}
 impl PollingClient {
     pub(crate) fn register<F: AsFileDescriptor>(&self, entity: &F, handle: CompHandle, read: bool, write: bool) -> Result<PollTicket, RtError> {
         let generation = self.generation_counter.fetch_add(1, Ordering::Relaxed);
         let user_data = user_data_for_component(handle.id().0, generation);
         self.queue.push(PollCmd::Register(handle, user_data));
         let file_descriptor = entity.as_file_descriptor();
         self.poller.register(file_descriptor, user_data, read, write)
             .map_err(|e| rt_error!("failed to register for polling, because: {}", e))?;
         return Ok(PollTicket(file_descriptor, user_data.0));
+    }
     pub(crate) fn unregister(&self, ticket: PollTicket) -> Result<(), RtError> {
         let file_descriptor = ticket.0;
         let user_data = UserData(ticket.1);
         self.queue.push(PollCmd::Unregister(file_descriptor, user_data));
         self.poller.unregister(file_descriptor)
             .map_err(|e| rt_error!("failed to unregister polling, because: {}", e))?;
         return Ok(());
+    }
+}
 #[inline]
 fn user_data_for_component(component_id: u32, generation: u32) -> UserData {
     return UserData((generation as u64) << 32 | (component_id as u64));
+}
@@ \ No newline at end of file @@

src/runtime2/stdlib/internet.rs

➞

Show inline comments

 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 use std::mem::size_of;
 use std::io::Error as IoError;
 use libc::{
     c_int,
     sockaddr_in, sockaddr_in6, in_addr, in6_addr,
     socket, bind, listen, accept, connect, close,
 };
 use crate::runtime2::poll::{AsFileDescriptor, FileDescriptor};
 #[derive(Debug)]
 pub enum SocketError {
     Opening,
     Modifying,
     Binding,
     Listening,
     Connecting,
     Accepted,
     Accepting,
+}
 enum SocketState {
     Opened,
     Listening,
+}
 /// TCP connection
 const SOCKET_BLOCKING: bool = false;
 /// TCP (client) connection
 pub struct SocketTcpClient {
     socket_handle: libc::c_int,
     is_blocking: bool,
+}
 impl SocketTcpClient {
     pub fn new(ip: IpAddr, port: u16) -> Result<Self, SocketError> {
         const BLOCKING: bool = false;
         let socket_handle = create_and_connect_socket(
             libc::SOCK_STREAM, libc::IPPROTO_TCP, ip, port
         )?;
-        if !set_socket_blocking(socket_handle, BLOCKING) {
+        if !set_socket_blocking(socket_handle, SOCKET_BLOCKING) {
             unsafe{ libc::close(socket_handle); }
             return Err(SocketError::Modifying);
+        }
         println!(" CREATE  [{:04}] client", socket_handle);
         return Ok(SocketTcpClient{
             socket_handle,
             is_blocking: BLOCKING,
             is_blocking: SOCKET_BLOCKING,
         })
+    }
     pub(crate) fn new_from_handle(socket_handle: libc::c_int) -> Result<Self, SocketError> {
         if !set_socket_blocking(socket_handle, SOCKET_BLOCKING) {
             unsafe{ libc::close(socket_handle); }
             return Err(SocketError::Modifying);
+        }
         return Ok(SocketTcpClient{
             socket_handle,
             is_blocking: SOCKET_BLOCKING,
         })
+    }
     pub fn send(&self, message: &[u8]) -> Result<usize, IoError> {
         let result = unsafe{
             let message_pointer = message.as_ptr().cast();
             libc::send(self.socket_handle, message_pointer, message.len() as libc::size_t, 0)
         };
         if result < 0 {
             return Err(IoError::last_os_error());
+        }
         return Ok(result as usize);
+    }
     /// Receives data from the TCP socket. Returns the number of bytes received.
     /// More bytes may be present even thought `used < buffer.len()`.
     pub fn receive(&self, buffer: &mut [u8]) -> Result<usize, IoError> {
         let result = unsafe {
             let message_pointer = buffer.as_mut_ptr().cast();
             libc::recv(self.socket_handle, message_pointer, buffer.len(), 0)
         };
         if result < 0 {
             return Err(IoError::last_os_error());
+        }
         return Ok(result as usize);
+    }
+}
 impl Drop for SocketTcpClient {
     fn drop(&mut self) {
         println!("DESTRUCT [{:04}] client", self.socket_handle);
         debug_assert!(self.socket_handle >= 0);
         unsafe{ close(self.socket_handle) };
+    }
+}
 impl AsFileDescriptor for SocketTcpClient {
     fn as_file_descriptor(&self) -> FileDescriptor {
         return self.socket_handle;
+    }
+}
 /// TCP listener. Yielding new connections
 pub struct SocketTcpListener {
     socket_handle: libc::c_int,
     is_blocking: bool,
+}
 impl SocketTcpListener {
     pub fn new(ip: IpAddr, port: u16) -> Result<Self, SocketError> {
         // Create and bind
         let socket_handle = create_and_bind_socket(
             libc::SOCK_STREAM, libc::IPPROTO_TCP, ip, port
         )?;
         if !set_socket_blocking(socket_handle, SOCKET_BLOCKING) {
             unsafe{ libc::close(socket_handle); }
             return Err(SocketError::Modifying);
+        }
         // Listen
         unsafe {
             let result = listen(socket_handle, libc::SOMAXCONN);
             if result < 0 {
                 unsafe{ libc::close(socket_handle); }
                 return Err(SocketError::Listening);
+            }
+        }
         println!(" CREATE  [{:04}] listener", socket_handle);
         return Ok(SocketTcpListener{
             socket_handle,
             is_blocking: SOCKET_BLOCKING,
         });
+    }
     pub fn accept(&self) -> Result<libc::c_int, IoError> {
         let (mut address, mut address_size) = create_sockaddr_in_empty();
         let address_pointer = &mut address as *mut sockaddr_in;
         let socket_handle = unsafe { accept(self.socket_handle, address_pointer.cast(), &mut address_size) };
         if socket_handle < 0 {
             return Err(IoError::last_os_error());
+        }
         println!(" CREATE  [{:04}] client (from listener)", socket_handle);
         return Ok(socket_handle);
+    }
+}
 impl Drop for SocketTcpListener {
     fn drop(&mut self) {
         println!("DESTRUCT [{:04}] listener", self.socket_handle);
         debug_assert!(self.socket_handle >= 0);
         unsafe{ close(self.socket_handle) };
+    }
+}
 impl AsFileDescriptor for SocketTcpListener {
     fn as_file_descriptor(&self) -> FileDescriptor {
         return self.socket_handle;
+    }
+}
 /// Raw socket receiver. Essentially a listener that accepts a single connection
 struct SocketRawRx {
     listen_handle: c_int,
     accepted_handle: c_int,
+}
 impl SocketRawRx {
     pub fn new(ip: Option<Ipv4Addr>, port: u16) -> Result<Self, SocketError> {
         let ip = ip.unwrap_or(Ipv4Addr::UNSPECIFIED); // unspecified is the same as INADDR_ANY
         let address = unsafe{ in_addr{
             s_addr: std::mem::transmute(ip.octets()),
         }};
         let socket_address = sockaddr_in{
             sin_family: libc::AF_INET as libc::sa_family_t,
             sin_port: htons(port),
             sin_addr: address,
             sin_zero: [0; 8],
         };
         unsafe {
             let socket_handle = create_and_bind_socket(libc::SOCK_RAW, 0, IpAddr::V4(ip), port)?;
             let result = listen(socket_handle, 3);
             if result < 0 { return Err(SocketError::Listening); }
             return Ok(SocketRawRx{
                 listen_handle: socket_handle,
                 accepted_handle: -1,
             });
+        }
+    }
     // pub fn try_accept(&mut self, timeout_ms: u32) -> Result<(), SocketError> {
     //     if self.accepted_handle >= 0 {
     //         // Already accepted a connection
     //         return Err(SocketError::Accepted);
     //     }
     //
     //     let mut socket_address = sockaddr_in{
     //         sin_family: 0,
     //         sin_port: 0,
     //         sin_addr: in_addr{ s_addr: 0 },
     //         sin_zero: [0; 8]
     //     };
     //     let mut size = size_of::<sockaddr_in>() as u32;
     //     unsafe {
     //         let result = accept(self.listen_handle, &mut socket_address as *mut _, &mut size as *mut _);
     //         if result < 0 {
     //             return Err(SocketError::Accepting);
     //         }
     //     }
     //
     //     return Ok(());
     // }
+}
 impl Drop for SocketRawRx {
     fn drop(&mut self) {
         if self.accepted_handle >= 0 {
             unsafe {
                 close(self.accepted_handle);
+            }
+        }
         if self.listen_handle >= 0 {
             unsafe {
                 close(self.listen_handle);
+            }
+        }
+    }
+}
 // The following is essentially stolen from `mio`'s io_source.rs file.
 #[cfg(unix)]
 trait AsRawFileDescriptor {
     fn as_raw_file_descriptor(&self) -> c_int;
+}
 impl AsRawFileDescriptor for SocketTcpClient {
     fn as_raw_file_descriptor(&self) -> c_int {
         return self.socket_handle;
+    }
+}
 /// Performs the `socket` and `bind` calls.
 fn create_and_bind_socket(socket_type: libc::c_int, protocol: libc::c_int, ip: IpAddr, port: u16) -> Result<libc::c_int, SocketError> {
     let family = socket_family_from_ip(ip);
     unsafe {
         let socket_handle = socket(family, socket_type, protocol);
         if socket_handle < 0 {
             return Err(SocketError::Opening);
+        }
         let result = match ip {
             IpAddr::V4(ip) => {
                 let (socket_address, address_size) = create_sockaddr_in_v4(ip, port);
                 let socket_pointer = &socket_address as *const sockaddr_in;
                 bind(socket_handle, socket_pointer.cast(), address_size)
             },
             IpAddr::V6(ip) => {
                 let (socket_address, address_size) = create_sockaddr_in_v6(ip, port);
                 let socket_pointer= &socket_address as *const sockaddr_in6;
                 bind(socket_handle, socket_pointer.cast(), address_size)
+            }
         };
         if result < 0 {
             close(socket_handle);
             return Err(SocketError::Binding);
+        }
         return Ok(socket_handle);
+    }
+}
 /// Performs the `socket` and `connect` calls
 fn create_and_connect_socket(socket_type: libc::c_int, protocol: libc::c_int, ip: IpAddr, port: u16) -> Result<libc::c_int, SocketError> {
     let family = socket_family_from_ip(ip);
     unsafe {
         let socket_handle = socket(family, socket_type, protocol);
         if socket_handle < 0 {
             return Err(SocketError::Opening);
+        }
         let result = match ip {
             IpAddr::V4(ip) => {
                 let (socket_address, address_size) = create_sockaddr_in_v4(ip, port);
                 let socket_pointer = &socket_address as *const sockaddr_in;
                 connect(socket_handle, socket_pointer.cast(), address_size)
             },
             IpAddr::V6(ip) => {
                 let (socket_address, address_size) = create_sockaddr_in_v6(ip, port);
                 let socket_pointer= &socket_address as *const sockaddr_in6;
                 connect(socket_handle, socket_pointer.cast(), address_size)
+            }
         };
         if result < 0 {
             close(socket_handle);
             return Err(SocketError::Connecting);
+        }
         return Ok(socket_handle);
+    }
+}
 #[inline]
 fn create_sockaddr_in_empty() -> (sockaddr_in, libc::socklen_t) {
     let socket_address = sockaddr_in{
         sin_family: 0,
         sin_port: 0,
         sin_addr: in_addr { s_addr: 0 },
         sin_zero: [0; 8],
     };
     let address_size = size_of::<sockaddr_in>();
     return (socket_address, address_size as _);
+}
 #[inline]
 fn create_sockaddr_in_v4(ip: Ipv4Addr, port: u16) -> (sockaddr_in, libc::socklen_t) {
     let address = unsafe{
         in_addr{
             s_addr: std::mem::transmute(ip.octets())
+        }
     };
     let socket_address = sockaddr_in{
         sin_family: libc::AF_INET as libc::sa_family_t,
         sin_port: htons(port),
         sin_addr: address,
         sin_zero: [0; 8]
     };
     let address_size = size_of::<sockaddr_in>();
     return (socket_address, address_size as _);
+}
 #[inline]
 fn create_sockaddr_in_v6(ip: Ipv6Addr, port: u16) -> (sockaddr_in6, libc::socklen_t) {
     // flow label is advised to be, according to RFC6437 a (somewhat
     // secure) random number taken from a uniform distribution
     let flow_info = rand::random();
     let address = unsafe{
         in6_addr{
             s6_addr: ip.octets()
+        }
     };
     let socket_address = sockaddr_in6{
         sin6_family: libc::AF_INET6 as libc::sa_family_t,
         sin6_port: htons(port),
         sin6_flowinfo: flow_info,
         sin6_addr: address,
         sin6_scope_id: 0, // incorrect in case of loopback address
     };
     let address_size = size_of::<sockaddr_in6>();
     return (socket_address, address_size as _);
+}
 #[inline]
 fn set_socket_blocking(handle: libc::c_int, blocking: bool) -> bool {
     if handle < 0 {
         return false;
+    }
     unsafe{
         let mut flags = libc::fcntl(handle, libc::F_GETFL, 0);
         if flags < 0 {
             return false;
+        }
         if blocking {
             flags &= !libc::O_NONBLOCK;
         } else {
             flags |= libc::O_NONBLOCK;
+        }
         let result = libc::fcntl(handle, libc::F_SETFL, flags);
         if result < 0 {
             return false;
+        }
+    }
     return true;
+}
 #[inline]
 fn socket_family_from_ip(ip: IpAddr) -> libc::c_int {
     return match ip {
         IpAddr::V4(_) => libc::AF_INET,
         IpAddr::V6(_) => libc::AF_INET6,
     };
+}
 #[inline]
 fn htons(port: u16) -> u16 {
     return port.to_be();
+}

src/runtime2/tests/error_handling.rs

➞

Show inline comments

 use super::*;
 #[test]
 fn test_unconnected_component_error() {
     compile_and_create_component("
-    primitive interact_with_noone() {
+    comp interact_with_noone() {
         u8[] array = { 5 };
         auto value = array[1];
     }", "interact_with_noone", no_args());
+}
 #[test]
 fn test_connected_uncommunicating_component_error() {
     compile_and_create_component("
-    primitive crashing_and_burning(out<u32> unused) {
+    comp crashing_and_burning(out<u32> unused) {
         u8[] array = { 1337 };
         auto value = array[1337];
+    }
-    primitive sitting_idly_waiting(in<u32> never_providing) {
+    comp sitting_idly_waiting(in<u32> never_providing) {
         sync auto a = get(never_providing);
+    }
-    composite constructor() {
+    comp constructor() {
         // Test one way
         // channel a -> b;
         // new sitting_idly_waiting(b);
         // new crashing_and_burning(a);
         // And the other way around
         channel c -> d;
         new crashing_and_burning(c);
         new sitting_idly_waiting(d);
     }", "constructor", no_args())
+}
 #[test]
 fn test_connected_communicating_component_error() {
     compile_and_create_component("
-    primitive send_and_fail(out<u32> tx) {
+    comp send_and_fail(out<u32> tx) {
         u8[] array = {};
         sync {
             put(tx, 0);
             array[0] = 5;
+        }
+    }
-    primitive receive_once(in<u32> rx) {
+    comp receive_once(in<u32> rx) {
         sync auto a = get(rx);
+    }
-    composite constructor() {
+    comp constructor() {
         channel a -> b;
         new send_and_fail(a);
         new receive_once(b);
         channel c -> d;
         new receive_once(d);
         new send_and_fail(c);
+    }
     ", "constructor", no_args())
+}
 #[test]
 fn test_failing_after_successful_sync() {
     compile_and_create_component("
     primitive put_and_fail(out<u8> tx) { sync put(tx, 1); u8 a = {}[0]; }
     primitive get_and_fail(in<u8> rx) { sync auto a = get(rx); u8 a = {}[0]; }
     primitive put_and_exit(out<u8> tx) { sync put(tx, 2); }
     primitive get_and_exit(in<u8> rx) { sync auto a = get(rx); }
     comp put_and_fail(out<u8> tx) { sync put(tx, 1); u8 a = {}[0]; }
     comp get_and_fail(in<u8> rx) { sync auto a = get(rx); u8 a = {}[0]; }
     comp put_and_exit(out<u8> tx) { sync put(tx, 2); }
     comp get_and_exit(in<u8> rx) { sync auto a = get(rx); }
-    composite constructor() {
+    comp constructor() {
+        {
             channel a -> b;
             new put_and_fail(a);
             new get_and_exit(b);
+        }
+        {
             channel a -> b;
             new get_and_exit(b);
             new put_and_fail(a);
+        }
+        {
             channel a -> b;
             new put_and_exit(a);
             new get_and_fail(b);
+        }
+        {
             channel a -> b;
             new get_and_fail(b);
             new put_and_exit(a);
+        }
+    }
     ", "constructor", no_args());
+}
@@ \ No newline at end of file @@

src/runtime2/tests/internet.rs

➞

Show inline comments

@@ new file 100644 @@
 use super::*;
 // silly test to make sure that the PDL will never be an issue when doing TCP
 // stuff with the actual components
 #[test]
 fn test_stdlib_file() {
     compile_and_create_component("
     import std.internet as inet;
     comp fake_listener_once(out<inet::TcpConnection> tx) {
         channel cmd_tx -> cmd_rx;
         channel data_tx -> data_rx;
         new fake_socket(cmd_rx, data_tx);
         sync put(tx, inet::TcpConnection{
             tx: cmd_tx,
             rx: data_rx,
         });
+    }
     comp fake_socket(in<inet::ClientCmd> cmds, out<u8[]> tx) {
         auto to_send = {};
         auto shutdown = false;
         while (!shutdown) {
             auto keep_going = true;
             sync {
                 while (keep_going) {
                     auto cmd = get(cmds);
                     if (let inet::ClientCmd::Send(data) = cmd) {
                         to_send = data;
                         keep_going = false;
                     } else if (let inet::ClientCmd::Receive = cmd) {
                         put(tx, to_send);
                     } else if (let inet::ClientCmd::Finish = cmd) {
                         keep_going = false;
                     } else if (let inet::ClientCmd::Shutdown = cmd) {
                         keep_going = false;
                         shutdown = true;
+                    }
+                }
+            }
+        }
+    }
     comp fake_client(inet::TcpConnection conn) {
         sync put(conn.tx, inet::ClientCmd::Send({1, 3, 3, 7}));
         sync {
             put(conn.tx, inet::ClientCmd::Receive);
             auto val = get(conn.rx);
             while (val[0] != 1 || val[1] != 3 || val[2] != 3 || val[3] != 7) {
                 print(\"this is going very wrong\");
+            }
             put(conn.tx, inet::ClientCmd::Finish);
+        }
         sync put(conn.tx, inet::ClientCmd::Shutdown);
+    }
     comp constructor() {
         channel conn_tx -> conn_rx;
         new fake_listener_once(conn_tx);
         // Same crap as before:
         channel cmd_tx -> unused_cmd_rx;
         channel unused_data_tx -> data_rx;
         auto connection = inet::TcpConnection{ tx: cmd_tx, rx: data_rx };
         sync {
             connection = get(conn_rx);
+        }
         new fake_client(connection);
+    }
     ", "constructor", no_args());
+}
 #[test]
 fn test_tcp_listener_and_client() {
     compile_and_create_component("
     import std.internet::*;
     func listen_port() -> u16 {
         return 2392;
+    }
     comp server(u32 num_connections, in<()> shutdown) {
         // Start tcp listener
         channel listen_cmd_tx -> listen_cmd_rx;
         channel listen_conn_tx -> listen_conn_rx;
         new tcp_listener({}, listen_port(), listen_cmd_rx, listen_conn_tx);
         // Fake channels such that we can create a dummy connection variable
         channel client_cmd_tx -> unused_client_cmd_rx;
         channel unused_client_data_tx -> client_data_rx;
         auto new_connection = TcpConnection{
             tx: client_cmd_tx,
             rx: client_data_rx,
         };
         auto connection_counter = 0;
         while (connection_counter < num_connections) {
             // Wait until we get a connection
             print(\"server: waiting for an accepted connection\");
             sync {
                 put(listen_cmd_tx, ListenerCmd::Accept);
                 new_connection = get(listen_conn_rx);
+            }
             // We have a new connection, spawn an 'echoer' for it
             print(\"server: spawning an echo'ing component\");
             new echo_machine(new_connection);
             connection_counter += 1;
+        }
         // Shut down the listener
         print(\"server: shutting down listener\");
         sync auto v = get(shutdown);
         sync put(listen_cmd_tx, ListenerCmd::Shutdown);
+    }
     // Waits for a single TCP byte (to simplify potentially having to
     // concatenate requests) and echos it
     comp echo_machine(TcpConnection conn) {
         auto data_to_echo = {};
         // Wait for a message
         sync {
             print(\"echo: receiving data\");
             put(conn.tx, ClientCmd::Receive);
             data_to_echo = get(conn.rx);
             put(conn.tx, ClientCmd::Finish);
+        }
         // Echo the message
         print(\"echo: sending back data\");
         sync put(conn.tx, ClientCmd::Send(data_to_echo));
         // Ask the tcp connection to shut down
         print(\"echo: shutting down\");
         sync put(conn.tx, ClientCmd::Shutdown);
+    }
     comp echo_requester(u8 byte_to_send, out<()> done) {
         channel cmd_tx -> cmd_rx;
         channel data_tx -> data_rx;
         new tcp_client({127, 0, 0, 1}, listen_port(), cmd_rx, data_tx);
         // Send the message
         print(\"requester: sending bytes\");
         sync put(cmd_tx, ClientCmd::Send({ byte_to_send }));
         // Receive the echo'd byte
         auto received_byte = byte_to_send + 1;
         sync {
             print(\"requester: receiving echo response\");
             put(cmd_tx, ClientCmd::Receive);
             received_byte = get(data_rx)[0];
             put(cmd_tx, ClientCmd::Finish);
+        }
         // Silly check, as always
         while (byte_to_send != received_byte) {
             print(\"requester: Oh no! The echo is an otherworldly distorter\");
+        }
         // Shut down the TCP connection
         print(\"requester: shutting down TCP component\");
         sync put(cmd_tx, ClientCmd::Shutdown);
         sync put(done, ());
+    }
     comp constructor() {
         auto num_connections = 1;
         channel shutdown_listener_tx -> shutdown_listener_rx;
         new server(num_connections, shutdown_listener_rx);
         auto connection_index = 0;
         auto all_done = {};
         while (connection_index < num_connections) {
             channel done_tx -> done_rx;
             new echo_requester(cast(connection_index), done_tx);
             connection_index += 1;
             all_done @= {done_rx};
+        }
         auto counter = 0;
         while (counter < length(all_done)) {
             print(\"constructor: waiting for requester to exit\");
             sync auto v = get(all_done[counter]);
             counter += 1;
+        }
         print(\"constructor: instructing listener to exit\");
         sync put(shutdown_listener_tx, ());
+    }
     ", "constructor", no_args());
+}
@@ \ No newline at end of file @@

src/runtime2/tests/messaging.rs

➞

Show inline comments

 use super::*;
 #[test]
 fn test_component_communication() {
     let pd = ProtocolDescription::parse(b"
-    primitive sender(out<u32> o, u32 outside_loops, u32 inside_loops) {
+    comp sender(out<u32> o, u32 outside_loops, u32 inside_loops) {
         u32 outside_index = 0;
         while (outside_index < outside_loops) {
             u32 inside_index = 0;
             sync while (inside_index < inside_loops) {
                 put(o, inside_index);
                 inside_index += 1;
+            }
             outside_index += 1;
+        }
+    }
-    primitive receiver(in<u32> i, u32 outside_loops, u32 inside_loops) {
+    comp receiver(in<u32> i, u32 outside_loops, u32 inside_loops) {
         u32 outside_index = 0;
         while (outside_index < outside_loops) {
             u32 inside_index = 0;
             sync while (inside_index < inside_loops) {
                 auto val = get(i);
                 while (val != inside_index) {} // infinite loop if incorrect value is received
                 inside_index += 1;
+            }
             outside_index += 1;
+        }
+    }
-    composite constructor() {
+    comp constructor() {
         channel o_orom -> i_orom;
         channel o_mrom -> i_mrom;
         channel o_ormm -> i_ormm;
         channel o_mrmm -> i_mrmm;
         // one round, one message per round
         new sender(o_orom, 1, 1);
         new receiver(i_orom, 1, 1);
         // multiple rounds, one message per round
         new sender(o_mrom, 5, 1);
         new receiver(i_mrom, 5, 1);
         // one round, multiple messages per round
         new sender(o_ormm, 1, 5);
         new receiver(i_ormm, 1, 5);
         // multiple rounds, multiple messages per round
         new sender(o_mrmm, 5, 5);
         new receiver(i_mrmm, 5, 5);
     }").expect("compilation");
     let rt = Runtime::new(3, LOG_LEVEL, pd).unwrap();
     create_component(&rt, "", "constructor", no_args());
+}
 #[test]
 fn test_send_to_self() {
     compile_and_create_component("
-    primitive insane_in_the_membrane() {
+    comp insane_in_the_membrane() {
         channel a -> b;
         sync {
             put(a, 1);
             auto v = get(b);
             while (v != 1) {}
+        }
+    }
     ", "insane_in_the_membrane", no_args());
+}
 #[test]
 fn test_intermediate_messenger() {
     let pd = ProtocolDescription::parse(b"
-    primitive receiver<T>(in<T> rx, u32 num) {
+    comp receiver<T>(in<T> rx, u32 num) {
         auto index = 0;
         while (index < num) {
             sync { auto v = get(rx); }
             index += 1;
+        }
+    }
-    primitive middleman<T>(in<T> rx, out<T> tx, u32 num) {
+    comp middleman<T>(in<T> rx, out<T> tx, u32 num) {
         auto index = 0;
         while (index < num) {
             sync { put(tx, get(rx)); }
             index += 1;
+        }
+    }
-    primitive sender<T>(out<T> tx, u32 num) {
+    comp sender<T>(out<T> tx, u32 num) {
         auto index = 0;
         while (index < num) {
             sync put(tx, 1337);
             index += 1;
+        }
+    }
-    composite constructor_template<T>() {
+    comp constructor_template<T>() {
         auto num = 0;
         channel<T> tx_a -> rx_a;
         channel tx_b -> rx_b;
         new sender(tx_a, 3);
         new middleman(rx_a, tx_b, 3);
         new receiver(rx_b, 3);
+    }
-    composite constructor() {
+    comp constructor() {
         new constructor_template<u16>();
         new constructor_template<u32>();
         new constructor_template<u64>();
         new constructor_template<s16>();
         new constructor_template<s32>();
         new constructor_template<s64>();
+    }
     ").expect("compilation");
     let rt = Runtime::new(3, LOG_LEVEL, pd).unwrap();
     create_component(&rt, "", "constructor", no_args());
+}

src/runtime2/tests/mod.rs

➞

Show inline comments

 use crate::protocol::*;
 use crate::protocol::eval::*;
 use crate::runtime2::runtime::*;
 use crate::runtime2::component::{CompCtx, CompPDL};
 mod messaging;
 mod error_handling;
 mod transfer_ports;
 mod internet;
 const LOG_LEVEL: LogLevel = LogLevel::Debug;
 const NUM_THREADS: u32 = 1;
 pub(crate) fn compile_and_create_component(source: &str, routine_name: &str, args: ValueGroup) {
     let protocol = ProtocolDescription::parse(source.as_bytes())
         .expect("successful compilation");
-    let runtime = Runtime::new(NUM_THREADS, LOG_LEVEL, protocol)
+    let runtime = Runtime::new(NUM_THREADS, LogLevel::None, protocol)
         .expect("successful runtime startup");
     create_component(&runtime, "", routine_name, args);
+}
 pub(crate) fn create_component(rt: &Runtime, module_name: &str, routine_name: &str, args: ValueGroup) {
     let prompt = rt.inner.protocol.new_component(
         module_name.as_bytes(), routine_name.as_bytes(), args
     ).expect("create prompt");
     let reserved = rt.inner.start_create_component();
     let ctx = CompCtx::new(&reserved);
     let component = Box::new(CompPDL::new(prompt, 0));
     let (key, _) = rt.inner.finish_create_component(reserved, component, ctx, false);
     rt.inner.enqueue_work(key);
+}
 pub(crate) fn no_args() -> ValueGroup { ValueGroup::new_stack(Vec::new()) }
 #[test]
 fn test_component_creation() {
     let pd = ProtocolDescription::parse(b"
-    primitive nothing_at_all() {
+    comp nothing_at_all() {
         s32 a = 5;
         auto b = 5 + a;
+    }
     ").expect("compilation");
     let rt = Runtime::new(1, LOG_LEVEL, pd).unwrap();
     for _i in 0..20 {
         create_component(&rt, "", "nothing_at_all", no_args());
+    }
+}
 #[test]
 fn test_simple_select() {
     let pd = ProtocolDescription::parse(b"
     func infinite_assert<T>(T val, T expected) -> () {
         while (val != expected) { print(\"nope!\"); }
         return ();
+    }
-    primitive receiver(in<u32> in_a, in<u32> in_b, u32 num_sends) {
+    comp receiver(in<u32> in_a, in<u32> in_b, u32 num_sends) {
         auto num_from_a = 0;
         auto num_from_b = 0;
         while (num_from_a + num_from_b < 2 * num_sends) {
             sync select {
                 auto v = get(in_a) -> {
                     print(\"got something from A\");
                     auto _ = infinite_assert(v, num_from_a);
                     num_from_a += 1;
+                }
                 auto v = get(in_b) -> {
                     print(\"got something from B\");
                     auto _ = infinite_assert(v, num_from_b);
                     num_from_b += 1;
+                }
+            }
+        }
+    }
-    primitive sender(out<u32> tx, u32 num_sends) {
+    comp sender(out<u32> tx, u32 num_sends) {
         auto index = 0;
         while (index < num_sends) {
             sync {
                 put(tx, index);
                 index += 1;
+            }
+        }
+    }
-    composite constructor() {
+    comp constructor() {
         auto num_sends = 1;
         channel tx_a -> rx_a;
         channel tx_b -> rx_b;
         new sender(tx_a, num_sends);
         new receiver(rx_a, rx_b, num_sends);
         new sender(tx_b, num_sends);
+    }
     ").expect("compilation");
     let rt = Runtime::new(3, LOG_LEVEL, pd).unwrap();
     create_component(&rt, "", "constructor", no_args());
+}
 #[test]
 fn test_unguarded_select() {
     let pd = ProtocolDescription::parse(b"
-    primitive constructor_outside_select() {
+    comp constructor_outside_select() {
         u32 index = 0;
         while (index < 5) {
             sync select { auto v = () -> print(\"hello\"); }
             index += 1;
+        }
+    }
-    primitive constructor_inside_select() {
+    comp constructor_inside_select() {
         u32 index = 0;
         while (index < 5) {
             sync select { auto v = () -> index += 1; }
+        }
+    }
     ").expect("compilation");
     let rt = Runtime::new(3, LOG_LEVEL, pd).unwrap();
     create_component(&rt, "", "constructor_outside_select", no_args());
     create_component(&rt, "", "constructor_inside_select", no_args());
+}
 #[test]
 fn test_empty_select() {
     let pd = ProtocolDescription::parse(b"
-    primitive constructor() {
+    comp constructor() {
         u32 index = 0;
         while (index < 5) {
             sync select {}
             index += 1;
+        }
+    }
     ").expect("compilation");
     let rt = Runtime::new(3, LOG_LEVEL, pd).unwrap();
     create_component(&rt, "", "constructor", no_args());
+}
 #[test]
 fn test_random_u32_temporary_thingo() {
     let pd = ProtocolDescription::parse(b"
     import std.random::random_u32;
-    primitive random_taker(in<u32> generator, u32 num_values) {
+    comp random_taker(in<u32> generator, u32 num_values) {
         auto i = 0;
         while (i < num_values) {
             sync {
                 auto a = get(generator);
+            }
             i += 1;
+        }
+    }
-    composite constructor() {
+    comp constructor() {
         channel tx -> rx;
         auto num_values = 25;
         new random_u32(tx, 1, 100, num_values);
         new random_taker(rx, num_values);
+    }
     ").expect("compilation");
     let rt = Runtime::new(1, LOG_LEVEL, pd).unwrap();
     create_component(&rt, "", "constructor", no_args());
+}
 #[test]
 fn test_tcp_socket_http_request() {
     let _pd = ProtocolDescription::parse(b"
     import std.internet::*;
-    primitive requester(out<Cmd> cmd_tx, in<u8[]> data_rx) {
+    comp requester(out<ClientCmd> cmd_tx, in<u8[]> data_rx) {
         print(\"*** TCPSocket: Sending request\");
         sync {
-            put(cmd_tx, Cmd::Send(b\"GET / HTTP/1.1\\r\\n\\r\\n\"));
+            put(cmd_tx, ClientCmd::Send(b\"GET / HTTP/1.1\\r\\n\\r\\n\"));
+        }
         print(\"*** TCPSocket: Receiving response\");
         auto buffer = {};
         auto done_receiving = false;
         sync while (!done_receiving) {
-            put(cmd_tx, Cmd::Receive);
+            put(cmd_tx, ClientCmd::Receive);
             auto data = get(data_rx);
             buffer @= data;
             // Completely crap detection of end-of-document. But here we go, we
             // try to detect the trailing </html>. Proper way would be to parse
             // for 'content-length' or 'content-encoding'
             s32 index = 0;
             s32 partial_length = cast(length(data) - 7);
             while (index < partial_length) {
                 // No string conversion yet, so check byte buffer one byte at
                 // a time.
                 auto c1 = data[index];
                 if (c1 == cast('<')) {
                     auto c2 = data[index + 1];
                     auto c3 = data[index + 2];
                     auto c4 = data[index + 3];
                     auto c5 = data[index + 4];
                     auto c6 = data[index + 5];
                     auto c7 = data[index + 6];
                     if ( // i.e. if (data[index..] == '</html>'
                         c2 == cast('/') && c3 == cast('h') && c4 == cast('t') &&
                         c5 == cast('m') && c6 == cast('l') && c7 == cast('>')
                     ) {
                         print(\"*** TCPSocket: Detected </html>\");
-                        put(cmd_tx, Cmd::Finish);
+                        put(cmd_tx, ClientCmd::Finish);
                         done_receiving = true;
+                    }
+                }
                 index += 1;
+            }
+        }
         print(\"*** TCPSocket: Requesting shutdown\");
         sync {
-            put(cmd_tx, Cmd::Shutdown);
+            put(cmd_tx, ClientCmd::Shutdown);
+        }
+    }
-    composite main() {
+    comp main() {
         channel cmd_tx -> cmd_rx;
         channel data_tx -> data_rx;
         new tcp_client({142, 250, 179, 163}, 80, cmd_rx, data_tx); // port 80 of google
         new requester(cmd_tx, data_rx);
+    }
     ").expect("compilation");
     // This test is disabled because it performs a HTTP request to google.
-    // let rt = Runtime::new(1, true, pd).unwrap();
+    // let rt = Runtime::new(1, LOG_LEVEL, _pd).unwrap();
     // create_component(&rt, "", "main", no_args());
+}
 #[test]
 fn test_sending_receiving_union() {
     let pd = ProtocolDescription::parse(b"
     union Cmd {
         Set(u8[]),
         Get,
         Shutdown,
+    }
-    primitive database(in<Cmd> rx, out<u8[]> tx) {
+    comp database(in<Cmd> rx, out<u8[]> tx) {
         auto stored = {};
         auto done = false;
         while (!done) {
             sync {
                 auto command = get(rx);
                 if (let Cmd::Set(bytes) = command) {
                     print(\"database: storing value\");
                     stored = bytes;
                 } else if (let Cmd::Get = command) {
                     print(\"database: returning value\");
                     put(tx, stored);
                 } else if (let Cmd::Shutdown = command) {
                     print(\"database: shutting down\");
                     done = true;
                 } else while (true) print(\"impossible\"); // no other case possible
+            }
+        }
+    }
-    primitive client(out<Cmd> tx, in<u8[]> rx, u32 num_rounds) {
+    comp client(out<Cmd> tx, in<u8[]> rx, u32 num_rounds) {
         auto round = 0;
         while (round < num_rounds) {
             auto set_value = b\"hello there\";
             print(\"client: putting a value\");
             sync put(tx, Cmd::Set(set_value));
             auto retrieved = {};
             print(\"client: retrieving what was sent\");
             sync {
                 put(tx, Cmd::Get);
                 retrieved = get(rx);
+            }
             if (set_value != retrieved) while (true) print(\"wrong!\");
             round += 1;
+        }
         sync put(tx, Cmd::Shutdown);
+    }
-    composite main() {
+    comp main() {
         auto num_rounds = 5;
         channel cmd_tx -> cmd_rx;
         channel data_tx -> data_rx;
         new database(cmd_rx, data_tx);
         new client(cmd_tx, data_rx, num_rounds);
+    }
     ").expect("compilation");
     let rt = Runtime::new(1, LOG_LEVEL, pd).unwrap();
     create_component(&rt, "", "main", no_args());
+}
@@ \ No newline at end of file @@

src/runtime2/tests/transfer_ports.rs

➞

Show inline comments

 use super::*;
 #[test]
 fn test_transfer_precreated_port_with_owned_peer() {
     compile_and_create_component("
-    primitive port_sender(out<in<u32>> tx) {
+    comp port_sender(out<in<u32>> tx) {
         channel a -> b;
         sync put(tx, b);
+    }
-    primitive port_receiver(in<in<u32>> rx) {
+    comp port_receiver(in<in<u32>> rx) {
         sync auto a = get(rx);
+    }
-    composite constructor() {
+    comp constructor() {
         channel a -> b;
         new port_sender(a);
         new port_receiver(b);
+    }
     ", "constructor", no_args());
+}
 #[test]
 fn test_transfer_precreated_in_struct_with_owned_peer() {
     compile_and_create_component("
     struct PortPair<T> {
         out<T> tx,
         in<T> rx,
+    }
     comp port_sender(out<PortPair<u32>> tx) {
         channel created_tx_a -> created_rx_a;
         channel created_tx_b -> created_rx_b;
         sync put(tx, PortPair{ tx: created_tx_a, rx: created_rx_b });
         sync {
             auto val = get(created_rx_a);
             put(created_tx_b, val);
+        }
+    }
     comp port_receiver(in<PortPair<u32>> rx) {
         channel fake_tx -> fake_rx;
         auto conn = PortPair{ tx: fake_tx, rx: fake_rx };
         sync conn = get(rx);
         sync {
             put(conn.tx, 5);
             auto val = get(conn.rx);
             while (val != 5) {}
+        }
+    }
     comp constructor() {
         channel tx -> rx;
         new port_sender(tx);
         new port_receiver(rx);
+    }
     ", "constructor", no_args());
+}
 #[test]
 fn test_transfer_precreated_port_with_foreign_peer() {
     compile_and_create_component("
-    primitive port_sender(out<in<u32>> tx, in<u32> to_send) {
+    comp port_sender(out<in<u32>> tx, in<u32> to_send) {
         sync put(tx, to_send);
+    }
-    primitive port_receiver(in<in<u32>> rx) {
+    comp port_receiver(in<in<u32>> rx) {
         sync auto a = get(rx);
+    }
-    composite constructor() {
+    comp constructor() {
         channel tx -> rx;
         channel forgotten -> to_send;
         new port_sender(tx, to_send);
         new port_receiver(rx);
+    }
     ", "constructor", no_args());
+}
 #[test]
 fn test_transfer_synccreated_port() {
     compile_and_create_component("
-    primitive port_sender(out<in<u32>> tx) {
+    comp port_sender(out<in<u32>> tx) {
         sync {
             channel a -> b;
             put(tx, b);
+        }
+    }
-    primitive port_receiver(in<in<u32>> rx) {
+    comp port_receiver(in<in<u32>> rx) {
         sync auto a = get(rx);
+    }
-    composite constructor() {
+    comp constructor() {
         channel a -> b;
         new port_sender(a);
         new port_receiver(b);
+    }
     ", "constructor", no_args());
+}
 #[test]
 fn test_transfer_precreated_port_with_owned_peer_and_communication() {
     compile_and_create_component("
-    primitive port_sender(out<in<u32>> tx) {
+    comp port_sender(out<in<u32>> tx) {
         channel a -> b;
         sync put(tx, b);
         sync put(a, 1337);
+    }
-    primitive port_receiver(in<in<u32>> rx) {
+    comp port_receiver(in<in<u32>> rx) {
         channel a -> b; // this is stupid, but we need to have a variable to use
         sync b = get(rx);
         u32 value = 0;
         sync value = get(b);
         while (value != 1337) {}
+    }
-    composite constructor() {
+    comp constructor() {
         channel a -> b;
         new port_sender(a);
         new port_receiver(b);
+    }
     ", "constructor", no_args());
+}
 #[test]
 fn test_transfer_precreated_port_with_foreign_peer_and_communication() {
     compile_and_create_component("
-    primitive port_sender(out<in<u32>> tx, in<u32> to_send) {
+    comp port_sender(out<in<u32>> tx, in<u32> to_send) {
         sync put(tx, to_send);
+    }
-    primitive message_transmitter(out<u32> tx) {
+    comp message_transmitter(out<u32> tx) {
         sync put(tx, 1337);
+    }
-    primitive port_receiver(in<in<u32>> rx) {
+    comp port_receiver(in<in<u32>> rx) {
         channel unused -> b;
         sync b = get(rx);
         u32 value = 0;
         sync value = get(b);
         while (value != 1337) {}
+    }
-    composite constructor() {
+    comp constructor() {
         channel port_tx -> port_rx;
         channel value_tx -> value_rx;
         new port_sender(port_tx, value_rx);
         new port_receiver(port_rx);
         new message_transmitter(value_tx);
+    }
     ", "constructor", no_args());
+}
 #[test]
 fn test_transfer_precreated_port_with_owned_peer_back_and_forth() {
     compile_and_create_component("
-    primitive port_send_and_receive(out<in<u32>> tx, in<in<u32>> rx) {
+    comp port_send_and_receive(out<in<u32>> tx, in<in<u32>> rx) {
         channel a -> b;
         sync {
             put(tx, b);
             b = get(rx);
+        }
+    }
-    primitive port_receive_and_send(in<in<u32>> rx, out<in<u32>> tx) {
+    comp port_receive_and_send(in<in<u32>> rx, out<in<u32>> tx) {
         channel unused -> transferred; // same problem as in different tests
         sync {
             transferred = get(rx);
             put(tx, transferred);
+        }
+    }
-    composite constructor() {
+    comp constructor() {
         channel port_tx_forward -> port_rx_forward;
         channel port_tx_backward -> port_rx_backward;
         new port_send_and_receive(port_tx_forward, port_rx_backward);
         new port_receive_and_send(port_rx_forward, port_tx_backward);
     }", "constructor", no_args());
+}
 #[test]
 fn test_transfer_precreated_port_with_foreign_peer_back_and_forth_and_communication() {
     compile_and_create_component("
-    primitive port_send_and_receive(out<in<u32>> tx, in<in<u32>> rx, in<u32> to_transfer) {
+    comp port_send_and_receive(out<in<u32>> tx, in<in<u32>> rx, in<u32> to_transfer) {
         sync {
             put(tx, to_transfer);
             to_transfer = get(rx);
+        }
         sync {
             auto value = get(to_transfer);
             while (value != 1337) {}
+        }
+    }
-    primitive port_receive_and_send(in<in<u32>> rx, out<in<u32>> tx) {
+    comp port_receive_and_send(in<in<u32>> rx, out<in<u32>> tx) {
         channel unused -> transferred;
         sync {
             transferred = get(rx);
             put(tx, transferred);
+        }
+    }
-    primitive value_sender(out<u32> tx) {
+    comp value_sender(out<u32> tx) {
         sync put(tx, 1337);
+    }
-    composite constructor() {
+    comp constructor() {
         channel port_tx_forward -> port_rx_forward;
         channel port_tx_backward -> port_rx_backward;
         channel message_tx -> message_rx;
         new port_send_and_receive(port_tx_forward, port_rx_backward, message_rx);
         new port_receive_and_send(port_rx_forward, port_tx_backward);
         new value_sender(message_tx);
+    }
     ", "constructor", no_args());
+}
@@ \ No newline at end of file @@

std/std.internet.pdl

➞

Show inline comments

 #module std.internet
-union Cmd {
+union ClientCmd {
     Send(u8[]),
     Receive,
     Finish,
     Shutdown,
+}
 primitive tcp_client(u8[] ip, u16 port, in<Cmd> cmds, out<u8[]> rx) {
 comp tcp_client(u8[] ip, u16 port, in<ClientCmd> cmds, out<u8[]> rx) {
     #builtin
+}
 union ListenerCmd {
     Accept,
     Shutdown,
+}
 struct TcpConnection {
     out<ClientCmd> tx,
     in<u8[]> rx,
+}
 comp tcp_listener(u8[] ip, u16 port, in<ListenerCmd> cmds, out<TcpConnection> rx) {
     #builtin
+}
@@ \ No newline at end of file @@

std/std.random.pdl

➞

Show inline comments

 #module std.random
-primitive random_u32(out<u32> generator, u32 min, u32 max, u32 num_sends) { #builtin }
+comp random_u32(out<u32> generator, u32 min, u32 max, u32 num_sends) { #builtin }

testdata/basic-modules/consumer.pdl

➞

Show inline comments

 #module consumer
-primitive consumer(in<u32> input) {
+comp consumer(in<u32> input) {
     sync {
         print("C: going to receive a value");
         auto v = get(input);
         print("C: I have received a value");
+    }
     print("C: I am now exiting");
+}
@@ \ No newline at end of file @@

testdata/basic-modules/main.pdl

➞

Show inline comments

 import consumer as c;
 import producer::producer;
-composite main() {
+comp main() {
     channel output -> input;
     new c::consumer(input);
     new producer(output);
+}
@@ \ No newline at end of file @@

testdata/basic-modules/producer.pdl

➞

Show inline comments

 #module producer
-primitive producer(out<u32> output) {
+comp producer(out<u32> output) {
     sync {
         print("P: Going to send a value!");
         put(output, 1337);
         print("P: I just sent a value!");
+    }
     print("P: I am exiting");
+}
@@ \ No newline at end of file @@

testdata/basic/testing.pdl

➞

Show inline comments

-primitive consumer(in<u32> input) {
+comp consumer(in<u32> input) {
     sync {
         print("C: going to receive a value");
         auto v = get(input);
         print("C: I have received a value");
+    }
     print("C: I am now exiting");
+}
-primitive producer(out<u32> output) {
+comp producer(out<u32> output) {
     sync {
         print("P: Going to send a value!");
         put(output, 1337);
         print("P: I just sent a value!");
+    }
     print("P: I am exiting");
+}
-composite main() {
+comp main() {
     channel output -> input;
     new consumer(input);
     new producer(output);
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)