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

Changeset - 44a98be4e4b4

Parent rev.

Child rev.

[Not reviewed]

0 17 2

Christopher Esterhuyse - 5 years ago 2020-06-19 17:04:03
christopher.esterhuyse@gmail.com

beginning large overhaul: moving to globally-unique ports & port -> endpoint route mappings

13 files changed:

Cargo.toml

src/common.rs

src/lib.rs

src/macros.rs

src/protocol/arena.rs

src/protocol/eval.rs

src/protocol/inputsource.rs

src/protocol/lexer.rs

115

src/protocol/mod.rs

src/protocol/parser.rs

src/runtime/actors.rs

src/runtime/communication.rs

src/runtime/errors.rs

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

0 comments (0 inline, 0 general)

Cargo.toml

➞

Show inline comments

 [package]
 name = "reowolf_rs"
 version = "0.1.3"
 authors = [
 	"Christopher Esterhuyse <esterhuy@cwi.nl, christopher.esterhuyse@gmail.com>",
 	"Hans-Dieter Hiep <hdh@cwi.nl>"
+]
 edition = "2018"
 [dependencies]
 # convenience macros
 maplit = "1.0.2"
 derive_more = "0.99.2"
 # runtime
 bincode = "1.2.1"
 serde = { version = "1.0.112", features = ["derive"] }
 getrandom = "0.1.14" # tiny crate. used to guess controller-id
 take_mut = "0.2.2"
 indexmap = "1.3.0" # hashsets/hashmaps with efficient arbitrary element removal
 # network
 integer-encoding = "1.0.7"
 byteorder = "1.3.2"
-mio = "0.6.21" # migrate to mio v0.7.0 when it stabilizes
 mio = "0.6.21"
 mio-extras = "2.0.6"
 mio07 = { version = "0.7.0", package = "mio", features = ["tcp", "os-poll"] }
 # protocol
 # id-arena = "2.2.1"
 backtrace = "0.3"
 [dev-dependencies]
 test-generator = "0.3.0"
 crossbeam-utils = "0.7.0"
 lazy_static = "1.4.0"
 [lib]
 # compile target: dynamically linked library using C ABI
 crate-type = ["cdylib"]
 [features]
 default = ["ffi"]
 ffi = [] # no feature dependencies
@@ \ No newline at end of file @@

src/common.rs

➞

Show inline comments

 ///////////////////// PRELUDE /////////////////////
 pub use crate::protocol::{ComponentState, ProtocolDescription};
 pub use crate::runtime::{NonsyncContext, SyncContext};
 pub use core::{
     cmp::Ordering,
     fmt::{Debug, Formatter},
     hash::{Hash, Hasher},
     ops::{Range, RangeFrom},
     time::Duration,
 };
 pub use indexmap::{IndexMap, IndexSet};
 pub use maplit::{hashmap, hashset};
 pub use mio::{
     net::{TcpListener, TcpStream},
     Event, Evented, Events, Poll, PollOpt, Ready, Token,
 };
 pub use std::{
     collections::{hash_map::Entry, BTreeMap, HashMap, HashSet},
     convert::TryInto,
     io::{Read, Write},
     net::SocketAddr,
     sync::Arc,
     time::Instant,
 };
 pub use Polarity::*;
 ///////////////////// DEFS /////////////////////
 pub type ControllerId = u32;
-pub type ChannelIndex = u32;
+pub type PortSuffix = u32;
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd)]
 // globally unique
 #[derive(
     Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd, serde::Serialize, serde::Deserialize,
 )]
 pub struct PortId {
     pub(crate) controller_id: ControllerId,
-    pub(crate) port_index: u32,
+    pub(crate) port_index: PortSuffix,
+}
 #[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd)]
 pub struct Payload(Arc<Vec<u8>>);
 /// This is a unique identifier for a channel (i.e., port).
 #[derive(Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd)]
 pub struct ChannelId {
     pub(crate) controller_id: ControllerId,
     pub(crate) channel_index: ChannelIndex,
+}
 #[derive(Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd)]
 #[derive(
     Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd, serde::Serialize, serde::Deserialize,
 )]
 pub enum Polarity {
     Putter, // output port (from the perspective of the component)
     Getter, // input port (from the perspective of the component)
+}
 #[derive(
     Eq, PartialEq, Ord, PartialOrd, Hash, Copy, Clone, serde::Serialize, serde::Deserialize,
 )]
 #[repr(C)]
 pub struct Port(pub u32); // ports are COPY
 #[derive(Eq, PartialEq, Copy, Clone, Debug)]
-pub enum MainComponentErr {
+pub enum AddComponentError {
     NoSuchComponent,
     NonPortTypeParameters,
-    CannotMovePort(Port),
+    CannotMovePort(PortId),
     WrongNumberOfParamaters { expected: usize },
     UnknownPort(Port),
     WrongPortPolarity { param_index: usize, port: Port },
     DuplicateMovedPort(Port),
+}
 pub trait ProtocolDescription: Sized {
     type S: ComponentState<D = Self>;
     fn parse(pdl: &[u8]) -> Result<Self, String>;
     fn component_polarities(&self, identifier: &[u8]) -> Result<Vec<Polarity>, MainComponentErr>;
     fn new_main_component(&self, identifier: &[u8], ports: &[Port]) -> Self::S;
+}
 pub trait ComponentState: Sized + Clone {
     type D: ProtocolDescription;
     fn pre_sync_run<C: MonoContext<D = Self::D, S = Self>>(
         &mut self,
         runtime_ctx: &mut C,
         protocol_description: &Self::D,
     ) -> MonoBlocker;
     fn sync_run<C: PolyContext<D = Self::D>>(
         &mut self,
         runtime_ctx: &mut C,
         protocol_description: &Self::D,
     ) -> PolyBlocker;
     UnknownPort(PortId),
     WrongPortPolarity { port: PortId, expected_polarity: Polarity },
     DuplicateMovedPort(PortId),
+}
 #[derive(Debug, Clone)]
-pub enum MonoBlocker {
+pub enum NonsyncBlocker {
     Inconsistent,
     ComponentExit,
     SyncBlockStart,
+}
 #[derive(Debug, Clone)]
-pub enum PolyBlocker {
+pub enum SyncBlocker {
     Inconsistent,
     SyncBlockEnd,
     CouldntReadMsg(Port),
     CouldntCheckFiring(Port),
     PutMsg(Port, Payload),
+}
 pub trait MonoContext {
     type D: ProtocolDescription;
     type S: ComponentState<D = Self::D>;
     fn new_component(&mut self, moved_ports: HashSet<Port>, init_state: Self::S);
     fn new_channel(&mut self) -> [Port; 2];
     fn new_random(&mut self) -> u64;
+}
 pub trait PolyContext {
     type D: ProtocolDescription;
     fn is_firing(&mut self, port: Port) -> Option<bool>;
     fn read_msg(&mut self, port: Port) -> Option<&Payload>;
     CouldntReadMsg(PortId),
     CouldntCheckFiring(PortId),
     PutMsg(PortId, Payload),
+}
 ///////////////////// IMPL /////////////////////
 impl Payload {
     pub fn new(len: usize) -> Payload {
         let mut v = Vec::with_capacity(len);
         unsafe {
             v.set_len(len);
+        }
         Payload(Arc::new(v))
+    }
     pub fn len(&self) -> usize {
         self.0.len()
+    }
     pub fn as_slice(&self) -> &[u8] {
         &self.0
+    }
     pub fn as_mut_slice(&mut self) -> &mut [u8] {
         Arc::make_mut(&mut self.0) as _
+    }
     pub fn concat_with(&mut self, other: &Self) {
         let bytes = other.as_slice().iter().copied();
         let me = Arc::make_mut(&mut self.0);
         me.extend(bytes);
+    }
+}
 impl serde::Serialize for Payload {
     fn serialize<S>(
         &self,
         serializer: S,
     ) -> std::result::Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error>
     where
         S: serde::Serializer,
+    {
         let inner: &Vec<u8> = &self.0;
         inner.serialize(serializer)
+    }
+}
 impl<'de> serde::Deserialize<'de> for Payload {
     fn deserialize<D>(
         deserializer: D,
     ) -> std::result::Result<Self, <D as serde::Deserializer<'de>>::Error>
     where
         D: serde::Deserializer<'de>,
+    {
         let inner: Vec<u8> = Vec::deserialize(deserializer)?;
         Ok(Self(Arc::new(inner)))
+    }
+}
 impl std::iter::FromIterator<u8> for Payload {
     fn from_iter<I: IntoIterator<Item = u8>>(it: I) -> Self {
         Self(Arc::new(it.into_iter().collect()))
+    }
+}
 impl From<Vec<u8>> for Payload {
     fn from(s: Vec<u8>) -> Self {
         Self(s.into())
+    }
+}
-impl Debug for Port {
+impl Debug for PortId {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         write!(f, "Port({})", self.0)
+    }
+}
 impl Port {
     pub fn from_raw(raw: u32) -> Self {
         Self(raw)
+    }
     pub fn to_raw(self) -> u32 {
         self.0
+    }
     pub fn to_token(self) -> mio::Token {
         mio::Token(self.0.try_into().unwrap())
+    }
     pub fn from_token(t: mio::Token) -> Self {
         Self(t.0.try_into().unwrap())
         write!(f, "PortId({},{})", self.controller_id, self.port_index)
+    }
+}

src/lib.rs

➞

Show inline comments

 #[macro_use]
 mod macros;
 mod common;
 mod protocol;
 mod runtime;
 #[cfg(test)]
 mod test;
 // #[cfg(test)]
 // mod test;
 pub use runtime::{errors, Connector, PortBinding};
 pub use common::Polarity;
 pub use protocol::ProtocolDescription;
 pub use runtime::{Connector, EndpointSetup, StringLogger};
 #[cfg(feature = "ffi")]
 pub use runtime::ffi;
 // #[cfg(feature = "ffi")]
 // pub use runtime::ffi;

src/macros.rs

➞

Show inline comments

 macro_rules! log {
     ($logger:expr, $($arg:tt)*) => {{
         use std::fmt::Write;
         writeln!($logger, $($arg)*).unwrap();
         let _ = write!($logger.line_writer(), $($arg)*).unwrap();
     }};
+}
 macro_rules! assert_let {
     ($pat:pat = $expr:expr => $work:expr) => {
         if let $pat = $expr {
             $work
         } else {
             panic!("assert_let failed");
+        }
     };
+}
 // macro_rules! assert_let {
 //     ($pat:pat = $expr:expr => $work:expr) => {
 //         if let $pat = $expr {
 //             $work
 //         } else {
 //             panic!("assert_let failed");
 //         }
 //     };
 // }
 #[test]
 fn assert_let() {
     let x = Some(5);
     let z = assert_let![Some(y) = x => {
         println!("{:?}", y);
     }];
     println!("{:?}", z);
+}
 // #[test]
 // fn assert_let() {
 //     let x = Some(5);
 //     let z = assert_let![Some(y) = x => {
 //         println!("{:?}", y);
 //         3
 //     }];
 //     println!("{:?}", z);
 // }
 #[test]
 #[should_panic]
 fn must_let_panic() {
     let x: Option<u32> = None;
     assert_let![Some(y) = x => {
         println!("{:?}", y);
     }];
+}
 // #[test]
 // #[should_panic]
 // fn must_let_panic() {
 //     let x: Option<u32> = None;
 //     assert_let![Some(y) = x => {
 //         println!("{:?}", y);
 //     }];
 // }

src/protocol/arena.rs

➞

Show inline comments

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

src/protocol/eval.rs

➞

Show inline comments

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

src/protocol/inputsource.rs

➞

Show inline comments

 use std::fmt;
 use std::fs::File;
 use std::io;
 use std::path::Path;
 use backtrace::Backtrace;
 #[derive(Clone, serde::Serialize, serde::Deserialize)]
 pub struct InputSource {
     filename: String,
     input: Vec<u8>,
     line: usize,
     column: usize,
     offset: usize,
+}
 static STD_LIB_PDL: &'static [u8] = b"
 primitive forward(in i, out o) {
     while(true) synchronous() put(o, get(i));
+}
 primitive sync(in i, out o) {
     while(true) synchronous() if(fires(i)) put(o, get(i));
+}
 primitive alternator_2(in i, out l, out r) {
     while(true) {
         synchronous() put(l, get(i));
         synchronous() put(r, get(i));
+    }
+}
 primitive replicator_2(in i, out l, out r) {
     while(true) synchronous() if(fires(i)) {
         msg m = get(i);
         put(l, m);
         put(r, m);
+    }
+}
 primitive merger_2(in l, in r, out o) {
     while(true) synchronous {
         if(fires(l)) put(o, get(l));
         else         put(o, get(r));
+    }
 }";
 impl InputSource {
     // Constructors
     pub fn new<R: io::Read, S: ToString>(filename: S, reader: &mut R) -> io::Result<InputSource> {
         let mut vec = STD_LIB_PDL.to_vec();
         reader.read_to_end(&mut vec)?;
         Ok(InputSource {
             filename: filename.to_string(),
             input: vec,
             line: 1,
             column: 1,
             offset: 0,
         })
+    }
     // Constructor helpers
     pub fn from_file(path: &Path) -> io::Result<InputSource> {
         let filename = path.file_name();
         match filename {
             Some(filename) => {
                 let mut f = File::open(path)?;
                 InputSource::new(filename.to_string_lossy(), &mut f)
+            }
             None => Err(io::Error::new(io::ErrorKind::NotFound, "Invalid path")),
+        }
+    }
     pub fn from_string(string: &str) -> io::Result<InputSource> {
         let buffer = Box::new(string);
         let mut bytes = buffer.as_bytes();
         InputSource::new(String::new(), &mut bytes)
+    }
     pub fn from_buffer(buffer: &[u8]) -> io::Result<InputSource> {
         InputSource::new(String::new(), &mut Box::new(buffer))
+    }
     // Internal methods
     pub fn pos(&self) -> InputPosition {
         InputPosition { line: self.line, column: self.column, offset: self.offset }
+    }
     pub fn error<S: ToString>(&self, message: S) -> ParseError {
         self.pos().parse_error(message)
+    }
     pub fn is_eof(&self) -> bool {
         self.next() == None
+    }
     pub fn next(&self) -> Option<u8> {
         if self.offset < self.input.len() {
             Some((*self.input)[self.offset])
         } else {
             None
+        }
+    }
     pub fn lookahead(&self, pos: usize) -> Option<u8> {
         if let Some(x) = usize::checked_add(self.offset, pos) {
             if x < self.input.len() {
                 return Some((*self.input)[x]);
+            }
+        }
         None
+    }
     pub fn consume(&mut self) {
         match self.next() {
             Some(x) if x == b'\r' && self.lookahead(1) != Some(b'\n') || x == b'\n' => {
                 self.line += 1;
                 self.offset += 1;
                 self.column = 1;
+            }
             Some(_) => {
                 self.offset += 1;
                 self.column += 1;
+            }
             None => {}
+        }
+    }
+}
 impl fmt::Display for InputSource {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.pos().fmt(f)
+    }
+}
 #[derive(Debug, Clone, Copy, Default, serde::Serialize, serde::Deserialize)]
 pub struct InputPosition {
     line: usize,
     column: usize,
     offset: usize,
+}
 impl InputPosition {
     fn context<'a>(&self, source: &'a InputSource) -> &'a [u8] {
         let start = self.offset - (self.column - 1);
         let mut end = self.offset;
         while end < source.input.len() {
             let cur = (*source.input)[end];
             if cur == b'\n' || cur == b'\r' {
                 break;
+            }
             end += 1;
+        }
         &source.input[start..end]
+    }
     fn parse_error<S: ToString>(&self, message: S) -> ParseError {
         ParseError { position: *self, message: message.to_string(), backtrace: Backtrace::new() }
+    }
     fn eval_error<S: ToString>(&self, message: S) -> EvalError {
         EvalError { position: *self, message: message.to_string(), backtrace: Backtrace::new() }
+    }
+}
 impl fmt::Display for InputPosition {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}:{}", self.line, self.column)
+    }
+}
 pub trait SyntaxElement {
     fn position(&self) -> InputPosition;
     fn error<S: ToString>(&self, message: S) -> EvalError {
         self.position().eval_error(message)
+    }
+}
 #[derive(Debug, Clone)]
 pub struct ParseError {
     position: InputPosition,
     message: String,
     backtrace: Backtrace,
+}
 impl ParseError {
     pub fn new<S: ToString>(position: InputPosition, message: S) -> ParseError {
         ParseError { position, message: message.to_string(), backtrace: Backtrace::new() }
+    }
     // Diagnostic methods
     pub fn write<A: io::Write>(&self, source: &InputSource, writer: &mut A) -> io::Result<()> {
         if !source.filename.is_empty() {
             writeln!(
                 writer,
                 "Parse error at {}:{}: {}",
                 source.filename, self.position, self.message
             )?;
         } else {
             writeln!(writer, "Parse error at {}: {}", self.position, self.message)?;
+        }
         let line = self.position.context(source);
         writeln!(writer, "{}", String::from_utf8_lossy(line))?;
         let mut arrow: Vec<u8> = Vec::new();
         for pos in 1..self.position.column {
             let c = line[pos - 1];
             if c == b'\t' {
                 arrow.push(b'\t')
             } else {
                 arrow.push(b' ')
+            }
+        }
         arrow.push(b'^');
         writeln!(writer, "{}", String::from_utf8_lossy(&arrow))
+    }
     pub fn print(&self, source: &InputSource) {
         self.write(source, &mut std::io::stdout()).unwrap()
+    }
     pub fn display<'a>(&'a self, source: &'a InputSource) -> DisplayParseError<'a> {
         DisplayParseError::new(self, source)
+    }
+}
 impl From<ParseError> for io::Error {
     fn from(_: ParseError) -> io::Error {
         io::Error::new(io::ErrorKind::InvalidInput, "parse error")
+    }
+}
 #[derive(Clone, Copy)]
 pub struct DisplayParseError<'a> {
     error: &'a ParseError,
     source: &'a InputSource,
+}
 impl DisplayParseError<'_> {
     fn new<'a>(error: &'a ParseError, source: &'a InputSource) -> DisplayParseError<'a> {
         DisplayParseError { error, source }
+    }
+}
 impl fmt::Display for DisplayParseError<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut vec: Vec<u8> = Vec::new();
         match self.error.write(self.source, &mut vec) {
             Err(_) => {
                 return fmt::Result::Err(fmt::Error);
+            }
             Ok(_) => {}
+        }
         write!(f, "{}", String::from_utf8_lossy(&vec))
+    }
+}
 #[derive(Debug, Clone)]
 pub struct EvalError {
     position: InputPosition,
     message: String,
     backtrace: Backtrace,
+}
 impl EvalError {
     pub fn new<S: ToString>(position: InputPosition, message: S) -> EvalError {
         EvalError { position, message: message.to_string(), backtrace: Backtrace::new() }
+    }
     // Diagnostic methods
     pub fn write<A: io::Write>(&self, source: &InputSource, writer: &mut A) -> io::Result<()> {
         if !source.filename.is_empty() {
             writeln!(
                 writer,
                 "Evaluation error at {}:{}: {}",
                 source.filename, self.position, self.message
             )?;
         } else {
             writeln!(writer, "Evaluation error at {}: {}", self.position, self.message)?;
+        }
         let line = self.position.context(source);
         writeln!(writer, "{}", String::from_utf8_lossy(line))?;
         let mut arrow: Vec<u8> = Vec::new();
         for pos in 1..self.position.column {
             let c = line[pos - 1];
             if c == b'\t' {
                 arrow.push(b'\t')
             } else {
                 arrow.push(b' ')
+            }
+        }
         arrow.push(b'^');
         writeln!(writer, "{}", String::from_utf8_lossy(&arrow))
+    }
     pub fn print(&self, source: &InputSource) {
         self.write(source, &mut std::io::stdout()).unwrap()
+    }
     pub fn display<'a>(&'a self, source: &'a InputSource) -> DisplayEvalError<'a> {
         DisplayEvalError::new(self, source)
+    }
+}
 impl From<EvalError> for io::Error {
     fn from(_: EvalError) -> io::Error {
         io::Error::new(io::ErrorKind::InvalidInput, "eval error")
+    }
+}
 #[derive(Clone, Copy)]
 pub struct DisplayEvalError<'a> {
     error: &'a EvalError,
     source: &'a InputSource,
+}
 impl DisplayEvalError<'_> {
     fn new<'a>(error: &'a EvalError, source: &'a InputSource) -> DisplayEvalError<'a> {
         DisplayEvalError { error, source }
+    }
+}
 impl fmt::Display for DisplayEvalError<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut vec: Vec<u8> = Vec::new();
         match self.error.write(self.source, &mut vec) {
             Err(_) => {
                 return fmt::Result::Err(fmt::Error);
+            }
             Ok(_) => {}
+        }
         write!(f, "{}", String::from_utf8_lossy(&vec))
+    }
+}
 #[cfg(test)]
 mod tests {
     use super::*;
 // #[cfg(test)]
 // mod tests {
 //     use super::*;
     #[test]
     fn test_from_string() {
         let mut is = InputSource::from_string("#version 100\n").unwrap();
         assert!(is.input.len() == 13);
         assert!(is.line == 1);
         assert!(is.column == 1);
         assert!(is.offset == 0);
         let ps = is.pos();
         assert!(ps.line == 1);
         assert!(ps.column == 1);
         assert!(ps.offset == 0);
         assert!(is.next() == Some(b'#'));
         is.consume();
         assert!(is.next() == Some(b'v'));
         assert!(is.lookahead(1) == Some(b'e'));
         is.consume();
         assert!(is.next() == Some(b'e'));
         is.consume();
         assert!(is.next() == Some(b'r'));
         is.consume();
         assert!(is.next() == Some(b's'));
         is.consume();
         assert!(is.next() == Some(b'i'));
         is.consume();
+        {
             let ps = is.pos();
             assert_eq!(b"#version 100", ps.context(&is));
             let er = is.error("hello world!");
             let mut vec: Vec<u8> = Vec::new();
             er.write(&is, &mut vec).unwrap();
             assert_eq!(
                 "Parse error at 1:7: hello world!\n#version 100\n      ^\n",
                 String::from_utf8_lossy(&vec)
             );
+        }
         assert!(is.next() == Some(b'o'));
         is.consume();
         assert!(is.next() == Some(b'n'));
         is.consume();
         assert!(is.input.len() == 13);
         assert!(is.line == 1);
         assert!(is.column == 9);
         assert!(is.offset == 8);
         assert!(is.next() == Some(b' '));
         is.consume();
         assert!(is.next() == Some(b'1'));
         is.consume();
         assert!(is.next() == Some(b'0'));
         is.consume();
         assert!(is.next() == Some(b'0'));
         is.consume();
         assert!(is.input.len() == 13);
         assert!(is.line == 1);
         assert!(is.column == 13);
         assert!(is.offset == 12);
         assert!(is.next() == Some(b'\n'));
         is.consume();
         assert!(is.input.len() == 13);
         assert!(is.line == 2);
         assert!(is.column == 1);
         assert!(is.offset == 13);
+        {
             let ps = is.pos();
             assert_eq!(b"", ps.context(&is));
+        }
         assert!(is.next() == None);
         is.consume();
         assert!(is.next() == None);
+    }
 //     #[test]
 //     fn test_from_string() {
 //         let mut is = InputSource::from_string("#version 100\n").unwrap();
 //         assert!(is.input.len() == 13);
 //         assert!(is.line == 1);
 //         assert!(is.column == 1);
 //         assert!(is.offset == 0);
 //         let ps = is.pos();
 //         assert!(ps.line == 1);
 //         assert!(ps.column == 1);
 //         assert!(ps.offset == 0);
 //         assert!(is.next() == Some(b'#'));
 //         is.consume();
 //         assert!(is.next() == Some(b'v'));
 //         assert!(is.lookahead(1) == Some(b'e'));
 //         is.consume();
 //         assert!(is.next() == Some(b'e'));
 //         is.consume();
 //         assert!(is.next() == Some(b'r'));
 //         is.consume();
 //         assert!(is.next() == Some(b's'));
 //         is.consume();
 //         assert!(is.next() == Some(b'i'));
 //         is.consume();
 //         {
 //             let ps = is.pos();
 //             assert_eq!(b"#version 100", ps.context(&is));
 //             let er = is.error("hello world!");
 //             let mut vec: Vec<u8> = Vec::new();
 //             er.write(&is, &mut vec).unwrap();
 //             assert_eq!(
 //                 "Parse error at 1:7: hello world!\n#version 100\n      ^\n",
 //                 String::from_utf8_lossy(&vec)
 //             );
 //         }
 //         assert!(is.next() == Some(b'o'));
 //         is.consume();
 //         assert!(is.next() == Some(b'n'));
 //         is.consume();
 //         assert!(is.input.len() == 13);
 //         assert!(is.line == 1);
 //         assert!(is.column == 9);
 //         assert!(is.offset == 8);
 //         assert!(is.next() == Some(b' '));
 //         is.consume();
 //         assert!(is.next() == Some(b'1'));
 //         is.consume();
 //         assert!(is.next() == Some(b'0'));
 //         is.consume();
 //         assert!(is.next() == Some(b'0'));
 //         is.consume();
 //         assert!(is.input.len() == 13);
 //         assert!(is.line == 1);
 //         assert!(is.column == 13);
 //         assert!(is.offset == 12);
 //         assert!(is.next() == Some(b'\n'));
 //         is.consume();
 //         assert!(is.input.len() == 13);
 //         assert!(is.line == 2);
 //         assert!(is.column == 1);
 //         assert!(is.offset == 13);
 //         {
 //             let ps = is.pos();
 //             assert_eq!(b"", ps.context(&is));
 //         }
 //         assert!(is.next() == None);
 //         is.consume();
 //         assert!(is.next() == None);
 //     }
     #[test]
     fn test_split() {
         let mut is = InputSource::from_string("#version 100\n").unwrap();
         let backup = is.clone();
         assert!(is.next() == Some(b'#'));
         is.consume();
         assert!(is.next() == Some(b'v'));
         is.consume();
         assert!(is.next() == Some(b'e'));
         is.consume();
         is = backup;
         assert!(is.next() == Some(b'#'));
         is.consume();
         assert!(is.next() == Some(b'v'));
         is.consume();
         assert!(is.next() == Some(b'e'));
         is.consume();
+    }
+}
 //     #[test]
 //     fn test_split() {
 //         let mut is = InputSource::from_string("#version 100\n").unwrap();
 //         let backup = is.clone();
 //         assert!(is.next() == Some(b'#'));
 //         is.consume();
 //         assert!(is.next() == Some(b'v'));
 //         is.consume();
 //         assert!(is.next() == Some(b'e'));
 //         is.consume();
 //         is = backup;
 //         assert!(is.next() == Some(b'#'));
 //         is.consume();
 //         assert!(is.next() == Some(b'v'));
 //         is.consume();
 //         assert!(is.next() == Some(b'e'));
 //         is.consume();
 //     }
 // }

src/protocol/lexer.rs

➞

Show inline comments

@@ @@ -891,889 +891,889 @@ impl Lexer<'_> { @@
                         operation,
                         expression,
                     })
                     .upcast();
             } else if self.has_string(b"--") {
                 self.consume_string(b"--")?;
                 let operation = UnaryOperation::PostDecrement;
                 let expression = result;
                 self.consume_whitespace(false)?;
                 result = h
                     .alloc_unary_expression(|this| UnaryExpression {
                         this,
                         position,
                         operation,
                         expression,
                     })
                     .upcast();
             } else if self.has_string(b"[") {
                 self.consume_string(b"[")?;
                 self.consume_whitespace(false)?;
                 let subject = result;
                 let index = self.consume_expression(h)?;
                 self.consume_whitespace(false)?;
                 if self.has_string(b"..") || self.has_string(b":") {
                     position = self.source.pos();
                     if self.has_string(b"..") {
                         self.consume_string(b"..")?;
                     } else {
                         self.consume_string(b":")?;
+                    }
                     self.consume_whitespace(false)?;
                     let to_index = self.consume_expression(h)?;
                     self.consume_whitespace(false)?;
                     result = h
                         .alloc_slicing_expression(|this| SlicingExpression {
                             this,
                             position,
                             subject,
                             from_index: index,
                             to_index,
                         })
                         .upcast();
                 } else {
                     result = h
                         .alloc_indexing_expression(|this| IndexingExpression {
                             this,
                             position,
                             subject,
                             index,
                         })
                         .upcast();
+                }
                 self.consume_string(b"]")?;
                 self.consume_whitespace(false)?;
             } else {
                 assert!(self.has_string(b"."));
                 self.consume_string(b".")?;
                 self.consume_whitespace(false)?;
                 let subject = result;
                 let field;
                 if self.has_keyword(b"length") {
                     self.consume_keyword(b"length")?;
                     field = Field::Length;
                 } else {
                     field = Field::Symbolic(self.consume_identifier(h)?);
+                }
                 result = h
                     .alloc_select_expression(|this| SelectExpression {
                         this,
                         position,
                         subject,
                         field,
                     })
                     .upcast();
+            }
+        }
         Ok(result)
+    }
     fn consume_primary_expression(&mut self, h: &mut Heap) -> Result<ExpressionId, ParseError> {
         if self.has_string(b"(") {
             return self.consume_paren_expression(h);
+        }
         if self.has_string(b"{") {
             return Ok(self.consume_array_expression(h)?.upcast());
+        }
         if self.has_constant()
             || self.has_keyword(b"null")
             || self.has_keyword(b"true")
             || self.has_keyword(b"false")
+        {
             return Ok(self.consume_constant_expression(h)?.upcast());
+        }
         if self.has_call_expression() {
             return Ok(self.consume_call_expression(h)?.upcast());
+        }
         Ok(self.consume_variable_expression(h)?.upcast())
+    }
     fn consume_array_expression(&mut self, h: &mut Heap) -> Result<ArrayExpressionId, ParseError> {
         let position = self.source.pos();
         let mut elements = Vec::new();
         self.consume_string(b"{")?;
         self.consume_whitespace(false)?;
         if !self.has_string(b"}") {
             while self.source.next().is_some() {
                 elements.push(self.consume_expression(h)?);
                 self.consume_whitespace(false)?;
                 if self.has_string(b"}") {
                     break;
+                }
                 self.consume_string(b",")?;
                 self.consume_whitespace(false)?;
+            }
+        }
         self.consume_string(b"}")?;
         Ok(h.alloc_array_expression(|this| ArrayExpression { this, position, elements }))
+    }
     fn has_constant(&self) -> bool {
         is_constant(self.source.next())
+    }
     fn consume_constant_expression(
         &mut self,
         h: &mut Heap,
     ) -> Result<ConstantExpressionId, ParseError> {
         let position = self.source.pos();
         let value;
         if self.has_keyword(b"null") {
             self.consume_keyword(b"null")?;
             value = Constant::Null;
         } else if self.has_keyword(b"true") {
             self.consume_keyword(b"true")?;
             value = Constant::True;
         } else if self.has_keyword(b"false") {
             self.consume_keyword(b"false")?;
             value = Constant::False;
         } else if self.source.next() == Some(b'\'') {
             self.source.consume();
             let mut data = Vec::new();
             let mut next = self.source.next();
             while next != Some(b'\'') && (is_vchar(next) || next == Some(b' ')) {
                 data.push(next.unwrap());
                 self.source.consume();
                 next = self.source.next();
+            }
             if next != Some(b'\'') || data.len() == 0 {
                 return Err(self.source.error("Expected character constant"));
+            }
             self.source.consume();
             value = Constant::Character(data);
         } else {
             let mut data = Vec::new();
             let mut next = self.source.next();
             if !is_integer_start(next) {
                 return Err(self.source.error("Expected integer constant"));
+            }
             while is_integer_rest(next) {
                 data.push(next.unwrap());
                 self.source.consume();
                 next = self.source.next();
+            }
             value = Constant::Integer(data);
+        }
         Ok(h.alloc_constant_expression(|this| ConstantExpression { this, position, value }))
+    }
     fn has_call_expression(&mut self) -> bool {
         /* We prevent ambiguity with variables, by looking ahead
         the identifier to see if we can find an opening
         parenthesis: this signals a call expression. */
         if self.has_builtin_keyword() {
             return true;
+        }
         let backup = self.source.clone();
         let mut result = false;
         match self.consume_identifier_spilled() {
             Ok(_) => match self.consume_whitespace(false) {
                 Ok(_) => {
                     result = self.has_string(b"(");
+                }
                 Err(_) => {}
             },
             Err(_) => {}
+        }
         *self.source = backup;
         return result;
+    }
     fn consume_call_expression(&mut self, h: &mut Heap) -> Result<CallExpressionId, ParseError> {
         let position = self.source.pos();
         let method;
         if self.has_keyword(b"get") {
             self.consume_keyword(b"get")?;
             method = Method::Get;
         } else if self.has_keyword(b"fires") {
             self.consume_keyword(b"fires")?;
             method = Method::Fires;
         } else if self.has_keyword(b"create") {
             self.consume_keyword(b"create")?;
             method = Method::Create;
         } else {
             let identifier = self.consume_identifier(h)?;
             method = Method::Symbolic(identifier)
+        }
         self.consume_whitespace(false)?;
         let mut arguments = Vec::new();
         self.consume_string(b"(")?;
         self.consume_whitespace(false)?;
         if !self.has_string(b")") {
             while self.source.next().is_some() {
                 arguments.push(self.consume_expression(h)?);
                 self.consume_whitespace(false)?;
                 if self.has_string(b")") {
                     break;
+                }
                 self.consume_string(b",")?;
                 self.consume_whitespace(false)?
+            }
+        }
         self.consume_string(b")")?;
         Ok(h.alloc_call_expression(|this| CallExpression {
             this,
             position,
             method,
             arguments,
             declaration: None,
         }))
+    }
     fn consume_variable_expression(
         &mut self,
         h: &mut Heap,
     ) -> Result<VariableExpressionId, ParseError> {
         let position = self.source.pos();
         let identifier = self.consume_identifier(h)?;
         Ok(h.alloc_variable_expression(|this| VariableExpression {
             this,
             position,
             identifier,
             declaration: None,
         }))
+    }
     // ====================
     // Statements
     // ====================
     fn consume_statement(&mut self, h: &mut Heap) -> Result<StatementId, ParseError> {
         if self.level >= MAX_LEVEL {
             return Err(self.source.error("Too deeply nested statement"));
+        }
         self.level += 1;
         let result = self.consume_statement_impl(h);
         self.level -= 1;
         result
+    }
     fn has_label(&mut self) -> bool {
         /* To prevent ambiguity with expression statements consisting
         only of an identifier, we look ahead and match the colon
         that signals a labeled statement. */
         let backup = self.source.clone();
         let mut result = false;
         match self.consume_identifier_spilled() {
             Ok(_) => match self.consume_whitespace(false) {
                 Ok(_) => {
                     result = self.has_string(b":");
+                }
                 Err(_) => {}
             },
             Err(_) => {}
+        }
         *self.source = backup;
         return result;
+    }
     fn consume_statement_impl(&mut self, h: &mut Heap) -> Result<StatementId, ParseError> {
         if self.has_string(b"{") {
             Ok(self.consume_block_statement(h)?)
         } else if self.has_keyword(b"skip") {
             Ok(self.consume_skip_statement(h)?.upcast())
         } else if self.has_keyword(b"if") {
             Ok(self.consume_if_statement(h)?.upcast())
         } else if self.has_keyword(b"while") {
             Ok(self.consume_while_statement(h)?.upcast())
         } else if self.has_keyword(b"break") {
             Ok(self.consume_break_statement(h)?.upcast())
         } else if self.has_keyword(b"continue") {
             Ok(self.consume_continue_statement(h)?.upcast())
         } else if self.has_keyword(b"synchronous") {
             Ok(self.consume_synchronous_statement(h)?.upcast())
         } else if self.has_keyword(b"return") {
             Ok(self.consume_return_statement(h)?.upcast())
         } else if self.has_keyword(b"assert") {
             Ok(self.consume_assert_statement(h)?.upcast())
         } else if self.has_keyword(b"goto") {
             Ok(self.consume_goto_statement(h)?.upcast())
         } else if self.has_keyword(b"new") {
             Ok(self.consume_new_statement(h)?.upcast())
         } else if self.has_keyword(b"put") {
             Ok(self.consume_put_statement(h)?.upcast())
         } else if self.has_label() {
             Ok(self.consume_labeled_statement(h)?.upcast())
         } else {
             Ok(self.consume_expression_statement(h)?.upcast())
+        }
+    }
     fn has_local_statement(&mut self) -> bool {
         /* To avoid ambiguity, we look ahead to find either the
         channel keyword that signals a variable declaration, or
         a type annotation followed by another identifier.
         Example:
           my_type[] x = {5}; // memory statement
           my_var[5] = x; // assignment expression, expression statement
         Note how both the local and the assignment
         start with arbitrary identifier followed by [. */
         if self.has_keyword(b"channel") {
             return true;
+        }
         if self.has_statement_keyword() {
             return false;
+        }
         let backup = self.source.clone();
         let mut result = false;
         match self.consume_type_annotation_spilled() {
             Ok(_) => match self.consume_whitespace(false) {
                 Ok(_) => {
                     result = self.has_identifier();
+                }
                 Err(_) => {}
             },
             Err(_) => {}
+        }
         *self.source = backup;
         return result;
+    }
     fn consume_block_statement(&mut self, h: &mut Heap) -> Result<StatementId, ParseError> {
         let position = self.source.pos();
         let mut statements = Vec::new();
         self.consume_string(b"{")?;
         self.consume_whitespace(false)?;
         while self.has_local_statement() {
             statements.push(self.consume_local_statement(h)?.upcast());
             self.consume_whitespace(false)?;
+        }
         while !self.has_string(b"}") {
             statements.push(self.consume_statement(h)?);
             self.consume_whitespace(false)?;
+        }
         self.consume_string(b"}")?;
         if statements.len() == 0 {
             Ok(h.alloc_skip_statement(|this| SkipStatement { this, position, next: None }).upcast())
         } else {
             Ok(h.alloc_block_statement(|this| BlockStatement {
                 this,
                 position,
                 statements,
                 parent_scope: None,
                 locals: Vec::new(),
                 labels: Vec::new(),
             })
             .upcast())
+        }
+    }
     fn consume_local_statement(&mut self, h: &mut Heap) -> Result<LocalStatementId, ParseError> {
         if self.has_keyword(b"channel") {
             Ok(self.consume_channel_statement(h)?.upcast())
         } else {
             Ok(self.consume_memory_statement(h)?.upcast())
+        }
+    }
     fn consume_channel_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<ChannelStatementId, ParseError> {
         let position = self.source.pos();
         self.consume_keyword(b"channel")?;
         self.consume_whitespace(true)?;
         let from_annotation = self.create_type_annotation_output(h)?;
         let from_identifier = self.consume_identifier(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b"->")?;
         self.consume_whitespace(false)?;
         let to_annotation = self.create_type_annotation_input(h)?;
         let to_identifier = self.consume_identifier(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         let from = h.alloc_local(|this| Local {
             this,
             position,
             type_annotation: from_annotation,
             identifier: from_identifier,
         });
         let to = h.alloc_local(|this| Local {
             this,
             position,
             type_annotation: to_annotation,
             identifier: to_identifier,
         });
         Ok(h.alloc_channel_statement(|this| ChannelStatement {
             this,
             position,
             from,
             to,
             next: None,
         }))
+    }
     fn consume_memory_statement(&mut self, h: &mut Heap) -> Result<MemoryStatementId, ParseError> {
         let position = self.source.pos();
         let type_annotation = self.consume_type_annotation(h)?;
         self.consume_whitespace(true)?;
         let identifier = self.consume_identifier(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b"=")?;
         self.consume_whitespace(false)?;
         let initial = self.consume_expression(h)?;
         let variable = h.alloc_local(|this| Local { this, position, type_annotation, identifier });
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_memory_statement(|this| MemoryStatement {
             this,
             position,
             variable,
             initial,
             next: None,
         }))
+    }
     fn consume_labeled_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<LabeledStatementId, ParseError> {
         let position = self.source.pos();
         let label = self.consume_identifier(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b":")?;
         self.consume_whitespace(false)?;
         let body = self.consume_statement(h)?;
         Ok(h.alloc_labeled_statement(|this| LabeledStatement {
             this,
             position,
             label,
             body,
             in_sync: None,
         }))
+    }
     fn consume_skip_statement(&mut self, h: &mut Heap) -> Result<SkipStatementId, ParseError> {
         let position = self.source.pos();
         self.consume_keyword(b"skip")?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_skip_statement(|this| SkipStatement { this, position, next: None }))
+    }
     fn consume_if_statement(&mut self, h: &mut Heap) -> Result<IfStatementId, ParseError> {
         let position = self.source.pos();
         self.consume_keyword(b"if")?;
         self.consume_whitespace(false)?;
         let test = self.consume_paren_expression(h)?;
         self.consume_whitespace(false)?;
         let true_body = self.consume_statement(h)?;
         self.consume_whitespace(false)?;
         let false_body;
         if self.has_keyword(b"else") {
             self.consume_keyword(b"else")?;
             self.consume_whitespace(false)?;
             false_body = self.consume_statement(h)?;
         } else {
             false_body = h
                 .alloc_skip_statement(|this| SkipStatement { this, position, next: None })
                 .upcast();
+        }
         Ok(h.alloc_if_statement(|this| IfStatement { this, position, test, true_body, false_body }))
+    }
     fn consume_while_statement(&mut self, h: &mut Heap) -> Result<WhileStatementId, ParseError> {
         let position = self.source.pos();
         self.consume_keyword(b"while")?;
         self.consume_whitespace(false)?;
         let test = self.consume_paren_expression(h)?;
         self.consume_whitespace(false)?;
         let body = self.consume_statement(h)?;
         Ok(h.alloc_while_statement(|this| WhileStatement {
             this,
             position,
             test,
             body,
             next: None,
             in_sync: None,
         }))
+    }
     fn consume_break_statement(&mut self, h: &mut Heap) -> Result<BreakStatementId, ParseError> {
         let position = self.source.pos();
         self.consume_keyword(b"break")?;
         self.consume_whitespace(false)?;
         let label;
         if self.has_identifier() {
             label = Some(self.consume_identifier(h)?);
             self.consume_whitespace(false)?;
         } else {
             label = None;
+        }
         self.consume_string(b";")?;
         Ok(h.alloc_break_statement(|this| BreakStatement { this, position, label, target: None }))
+    }
     fn consume_continue_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<ContinueStatementId, ParseError> {
         let position = self.source.pos();
         self.consume_keyword(b"continue")?;
         self.consume_whitespace(false)?;
         let label;
         if self.has_identifier() {
             label = Some(self.consume_identifier(h)?);
             self.consume_whitespace(false)?;
         } else {
             label = None;
+        }
         self.consume_string(b";")?;
         Ok(h.alloc_continue_statement(|this| ContinueStatement {
             this,
             position,
             label,
             target: None,
         }))
+    }
     fn consume_synchronous_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<SynchronousStatementId, ParseError> {
         let position = self.source.pos();
         self.consume_keyword(b"synchronous")?;
         self.consume_whitespace(false)?;
         let mut parameters = Vec::new();
         if self.has_string(b"(") {
             self.consume_parameters(h, &mut parameters)?;
             self.consume_whitespace(false)?;
         } else if !self.has_keyword(b"skip") && !self.has_string(b"{") {
             return Err(self.source.error("Expected block statement"));
+        }
         let body = self.consume_statement(h)?;
         Ok(h.alloc_synchronous_statement(|this| SynchronousStatement {
             this,
             position,
             parameters,
             body,
             parent_scope: None,
         }))
+    }
     fn consume_return_statement(&mut self, h: &mut Heap) -> Result<ReturnStatementId, ParseError> {
         let position = self.source.pos();
         self.consume_keyword(b"return")?;
         self.consume_whitespace(false)?;
         let expression;
         if self.has_string(b"(") {
             expression = self.consume_paren_expression(h)?;
         } else {
             expression = self.consume_expression(h)?;
+        }
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_return_statement(|this| ReturnStatement { this, position, expression }))
+    }
     fn consume_assert_statement(&mut self, h: &mut Heap) -> Result<AssertStatementId, ParseError> {
         let position = self.source.pos();
         self.consume_keyword(b"assert")?;
         self.consume_whitespace(false)?;
         let expression;
         if self.has_string(b"(") {
             expression = self.consume_paren_expression(h)?;
         } else {
             expression = self.consume_expression(h)?;
+        }
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_assert_statement(|this| AssertStatement {
             this,
             position,
             expression,
             next: None,
         }))
+    }
     fn consume_goto_statement(&mut self, h: &mut Heap) -> Result<GotoStatementId, ParseError> {
         let position = self.source.pos();
         self.consume_keyword(b"goto")?;
         self.consume_whitespace(false)?;
         let label = self.consume_identifier(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_goto_statement(|this| GotoStatement { this, position, label, target: None }))
+    }
     fn consume_new_statement(&mut self, h: &mut Heap) -> Result<NewStatementId, ParseError> {
         let position = self.source.pos();
         self.consume_keyword(b"new")?;
         self.consume_whitespace(false)?;
         let expression = self.consume_call_expression(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_new_statement(|this| NewStatement { this, position, expression, next: None }))
+    }
     fn consume_put_statement(&mut self, h: &mut Heap) -> Result<PutStatementId, ParseError> {
         let position = self.source.pos();
         self.consume_keyword(b"put")?;
         self.consume_whitespace(false)?;
         self.consume_string(b"(")?;
         let port = self.consume_expression(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b",")?;
         self.consume_whitespace(false)?;
         let message = self.consume_expression(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b")")?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_put_statement(|this| PutStatement { this, position, port, message, next: None }))
+    }
     fn consume_expression_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<ExpressionStatementId, ParseError> {
         let position = self.source.pos();
         let expression = self.consume_expression(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_expression_statement(|this| ExpressionStatement {
             this,
             position,
             expression,
             next: None,
         }))
+    }
     // ====================
     // Symbol definitions
     // ====================
     fn has_symbol_definition(&self) -> bool {
         self.has_keyword(b"composite")
             || self.has_keyword(b"primitive")
             || self.has_type_keyword()
             || self.has_identifier()
+    }
     fn consume_symbol_definition(&mut self, h: &mut Heap) -> Result<DefinitionId, ParseError> {
         if self.has_keyword(b"composite") || self.has_keyword(b"primitive") {
             Ok(self.consume_component_definition(h)?.upcast())
         } else {
             Ok(self.consume_function_definition(h)?.upcast())
+        }
+    }
     fn consume_component_definition(&mut self, h: &mut Heap) -> Result<ComponentId, ParseError> {
         if self.has_keyword(b"composite") {
             Ok(self.consume_composite_definition(h)?.upcast())
         } else {
             Ok(self.consume_primitive_definition(h)?.upcast())
+        }
+    }
     fn consume_composite_definition(&mut self, h: &mut Heap) -> Result<CompositeId, ParseError> {
         let position = self.source.pos();
         self.consume_keyword(b"composite")?;
         self.consume_whitespace(true)?;
         let identifier = self.consume_identifier(h)?;
         self.consume_whitespace(false)?;
         let mut parameters = Vec::new();
         self.consume_parameters(h, &mut parameters)?;
         self.consume_whitespace(false)?;
         let body = self.consume_block_statement(h)?;
         Ok(h.alloc_composite(|this| Composite { this, position, identifier, parameters, body }))
+    }
     fn consume_primitive_definition(&mut self, h: &mut Heap) -> Result<PrimitiveId, ParseError> {
         let position = self.source.pos();
         self.consume_keyword(b"primitive")?;
         self.consume_whitespace(true)?;
         let identifier = self.consume_identifier(h)?;
         self.consume_whitespace(false)?;
         let mut parameters = Vec::new();
         self.consume_parameters(h, &mut parameters)?;
         self.consume_whitespace(false)?;
         let body = self.consume_block_statement(h)?;
         Ok(h.alloc_primitive(|this| Primitive { this, position, identifier, parameters, body }))
+    }
     fn consume_function_definition(&mut self, h: &mut Heap) -> Result<FunctionId, ParseError> {
         let position = self.source.pos();
         let return_type = self.consume_type_annotation(h)?;
         self.consume_whitespace(true)?;
         let identifier = self.consume_identifier(h)?;
         self.consume_whitespace(false)?;
         let mut parameters = Vec::new();
         self.consume_parameters(h, &mut parameters)?;
         self.consume_whitespace(false)?;
         let body = self.consume_block_statement(h)?;
         Ok(h.alloc_function(|this| Function {
             this,
             position,
             return_type,
             identifier,
             parameters,
             body,
         }))
+    }
     fn has_pragma(&self) -> bool {
         if let Some(c) = self.source.next() {
             c == b'#'
         } else {
             false
+        }
+    }
     fn consume_pragma(&mut self, h: &mut Heap) -> Result<PragmaId, ParseError> {
         let position = self.source.pos();
         let next = self.source.next();
         if next != Some(b'#') {
             return Err(self.source.error("Expected pragma"));
+        }
         self.source.consume();
         if !is_vchar(self.source.next()) {
             return Err(self.source.error("Expected pragma"));
+        }
         let value = self.consume_line()?;
         Ok(h.alloc_pragma(|this| Pragma { this, position, value }))
+    }
     fn has_import(&self) -> bool {
         self.has_keyword(b"import")
+    }
     fn consume_import(&mut self, h: &mut Heap) -> Result<ImportId, ParseError> {
         let position = self.source.pos();
         self.consume_keyword(b"import")?;
         self.consume_whitespace(true)?;
         let mut value = Vec::new();
         let mut ident = self.consume_ident()?;
         value.append(&mut ident);
         while self.has_string(b".") {
             self.consume_string(b".")?;
             value.push(b'.');
             ident = self.consume_ident()?;
             value.append(&mut ident);
+        }
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_import(|this| Import { this, position, value }))
+    }
     pub fn consume_protocol_description(&mut self, h: &mut Heap) -> Result<RootId, ParseError> {
         let position = self.source.pos();
         let mut pragmas = Vec::new();
         let mut imports = Vec::new();
         let mut definitions = Vec::new();
         self.consume_whitespace(false)?;
         while self.has_pragma() {
             let pragma = self.consume_pragma(h)?;
             pragmas.push(pragma);
             self.consume_whitespace(false)?;
+        }
         while self.has_import() {
             let import = self.consume_import(h)?;
             imports.push(import);
             self.consume_whitespace(false)?;
+        }
         // do-while block
         while {
             let def = self.consume_symbol_definition(h)?;
             definitions.push(def);
             self.consume_whitespace(false)?;
             self.has_symbol_definition()
         } {}
         // end of file
         if !self.source.is_eof() {
             return Err(self.source.error("Expected end of file"));
+        }
         Ok(h.alloc_protocol_description(|this| Root {
             this,
             position,
             pragmas,
             imports,
             definitions,
             declarations: Vec::new(),
         }))
+    }
+}
 #[cfg(test)]
 mod tests {
     use crate::protocol::ast::Expression::*;
     use crate::protocol::{ast, lexer::*};
 // #[cfg(test)]
 // mod tests {
 //     use crate::protocol::ast::Expression::*;
 //     use crate::protocol::{ast, lexer::*};
     #[test]
     fn test_lowercase() {
         assert_eq!(lowercase(b'a'), b'a');
         assert_eq!(lowercase(b'A'), b'a');
         assert_eq!(lowercase(b'z'), b'z');
         assert_eq!(lowercase(b'Z'), b'z');
+    }
 //     #[test]
 //     fn test_lowercase() {
 //         assert_eq!(lowercase(b'a'), b'a');
 //         assert_eq!(lowercase(b'A'), b'a');
 //         assert_eq!(lowercase(b'z'), b'z');
 //         assert_eq!(lowercase(b'Z'), b'z');
 //     }
     #[test]
     fn test_basic_expression() {
         let mut h = Heap::new();
         let mut is = InputSource::from_string("a+b;").unwrap();
         let mut lex = Lexer::new(&mut is);
         match lex.consume_expression(&mut h) {
             Ok(expr) => {
                 println!("{:?}", expr);
                 if let Binary(bin) = &h[expr] {
                     if let Variable(left) = &h[bin.left] {
                         if let Variable(right) = &h[bin.right] {
                             assert_eq!("a", format!("{}", h[left.identifier]));
                             assert_eq!("b", format!("{}", h[right.identifier]));
                             assert_eq!(Some(b';'), is.next());
                             return;
+                        }
+                    }
+                }
                 assert!(false);
+            }
             Err(err) => {
                 err.print(&is);
                 assert!(false);
+            }
+        }
+    }
 //     #[test]
 //     fn test_basic_expression() {
 //         let mut h = Heap::new();
 //         let mut is = InputSource::from_string("a+b;").unwrap();
 //         let mut lex = Lexer::new(&mut is);
 //         match lex.consume_expression(&mut h) {
 //             Ok(expr) => {
 //                 println!("{:?}", expr);
 //                 if let Binary(bin) = &h[expr] {
 //                     if let Variable(left) = &h[bin.left] {
 //                         if let Variable(right) = &h[bin.right] {
 //                             assert_eq!("a", format!("{}", h[left.identifier]));
 //                             assert_eq!("b", format!("{}", h[right.identifier]));
 //                             assert_eq!(Some(b';'), is.next());
 //                             return;
 //                         }
 //                     }
 //                 }
 //                 assert!(false);
 //             }
 //             Err(err) => {
 //                 err.print(&is);
 //                 assert!(false);
 //             }
 //         }
 //     }
     #[test]
     fn test_paren_expression() {
         let mut h = Heap::new();
         let mut is = InputSource::from_string("(true)").unwrap();
         let mut lex = Lexer::new(&mut is);
         match lex.consume_paren_expression(&mut h) {
             Ok(expr) => {
                 println!("{:#?}", expr);
                 if let Constant(con) = &h[expr] {
                     if let ast::Constant::True = con.value {
                         return;
+                    }
+                }
                 assert!(false);
+            }
             Err(err) => {
                 err.print(&is);
                 assert!(false);
+            }
+        }
+    }
 //     #[test]
 //     fn test_paren_expression() {
 //         let mut h = Heap::new();
 //         let mut is = InputSource::from_string("(true)").unwrap();
 //         let mut lex = Lexer::new(&mut is);
 //         match lex.consume_paren_expression(&mut h) {
 //             Ok(expr) => {
 //                 println!("{:#?}", expr);
 //                 if let Constant(con) = &h[expr] {
 //                     if let ast::Constant::True = con.value {
 //                         return;
 //                     }
 //                 }
 //                 assert!(false);
 //             }
 //             Err(err) => {
 //                 err.print(&is);
 //                 assert!(false);
 //             }
 //         }
 //     }
     #[test]
     fn test_expression() {
         let mut h = Heap::new();
         let mut is = InputSource::from_string("(x(1+5,get(y))-w[5])+z++\n").unwrap();
         let mut lex = Lexer::new(&mut is);
         match lex.consume_expression(&mut h) {
             Ok(expr) => {
                 println!("{:#?}", expr);
+            }
             Err(err) => {
                 err.print(&is);
                 assert!(false);
+            }
+        }
+    }
 //     #[test]
 //     fn test_expression() {
 //         let mut h = Heap::new();
 //         let mut is = InputSource::from_string("(x(1+5,get(y))-w[5])+z++\n").unwrap();
 //         let mut lex = Lexer::new(&mut is);
 //         match lex.consume_expression(&mut h) {
 //             Ok(expr) => {
 //                 println!("{:#?}", expr);
 //             }
 //             Err(err) => {
 //                 err.print(&is);
 //                 assert!(false);
 //             }
 //         }
 //     }
     #[test]
     fn test_basic_statement() {
         let mut h = Heap::new();
         let mut is = InputSource::from_string("while (true) { skip; }").unwrap();
         let mut lex = Lexer::new(&mut is);
         match lex.consume_statement(&mut h) {
             Ok(stmt) => {
                 println!("{:#?}", stmt);
                 if let Statement::While(w) = &h[stmt] {
                     if let Expression::Constant(_) = h[w.test] {
                         if let Statement::Block(_) = h[w.body] {
                             return;
+                        }
+                    }
+                }
                 assert!(false);
+            }
             Err(err) => {
                 err.print(&is);
                 assert!(false);
+            }
+        }
+    }
 //     #[test]
 //     fn test_basic_statement() {
 //         let mut h = Heap::new();
 //         let mut is = InputSource::from_string("while (true) { skip; }").unwrap();
 //         let mut lex = Lexer::new(&mut is);
 //         match lex.consume_statement(&mut h) {
 //             Ok(stmt) => {
 //                 println!("{:#?}", stmt);
 //                 if let Statement::While(w) = &h[stmt] {
 //                     if let Expression::Constant(_) = h[w.test] {
 //                         if let Statement::Block(_) = h[w.body] {
 //                             return;
 //                         }
 //                     }
 //                 }
 //                 assert!(false);
 //             }
 //             Err(err) => {
 //                 err.print(&is);
 //                 assert!(false);
 //             }
 //         }
 //     }
     #[test]
     fn test_statement() {
         let mut h = Heap::new();
         let mut is = InputSource::from_string(
             "label: while (true) { if (x++ > y[0]) break label; else continue; }\n",
+        )
         .unwrap();
         let mut lex = Lexer::new(&mut is);
         match lex.consume_statement(&mut h) {
             Ok(stmt) => {
                 println!("{:#?}", stmt);
+            }
             Err(err) => {
                 err.print(&is);
                 assert!(false);
+            }
+        }
+    }
+}
 //     #[test]
 //     fn test_statement() {
 //         let mut h = Heap::new();
 //         let mut is = InputSource::from_string(
 //             "label: while (true) { if (x++ > y[0]) break label; else continue; }\n",
 //         )
 //         .unwrap();
 //         let mut lex = Lexer::new(&mut is);
 //         match lex.consume_statement(&mut h) {
 //             Ok(stmt) => {
 //                 println!("{:#?}", stmt);
 //             }
 //             Err(err) => {
 //                 err.print(&is);
 //                 assert!(false);
 //             }
 //         }
 //     }
 // }

src/protocol/mod.rs

➞

Show inline comments

 mod arena;
 mod ast;
 mod eval;
 pub mod inputsource;
 mod lexer;
 mod library;
 mod parser;
 use crate::common::*;
 use crate::protocol::ast::*;
 use crate::protocol::eval::*;
 use crate::protocol::inputsource::*;
 use crate::protocol::parser::*;
 #[derive(serde::Serialize, serde::Deserialize)]
-pub struct ProtocolDescriptionImpl {
+pub struct ProtocolDescription {
     heap: Heap,
     source: InputSource,
     root: RootId,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ComponentState {
     prompt: Prompt,
+}
 pub enum EvalContext<'a> {
     Nonsync(&'a mut NonsyncContext<'a>),
     Sync(&'a mut SyncContext<'a>),
     None,
+}
 //////////////////////////////////////////////
-impl std::fmt::Debug for ProtocolDescriptionImpl {
+impl std::fmt::Debug for ProtocolDescription {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "Protocol")
+    }
+}
 impl ProtocolDescription for ProtocolDescriptionImpl {
     type S = ComponentStateImpl;
     fn parse(buffer: &[u8]) -> Result<Self, String> {
 impl ProtocolDescription {
     pub fn parse(buffer: &[u8]) -> Result<Self, String> {
         let mut heap = Heap::new();
         let mut source = InputSource::from_buffer(buffer).unwrap();
         let mut parser = Parser::new(&mut source);
         match parser.parse(&mut heap) {
             Ok(root) => {
-                return Ok(ProtocolDescriptionImpl { heap, source, root });
+                return Ok(ProtocolDescription { heap, source, root });
+            }
             Err(err) => {
                 let mut vec: Vec<u8> = Vec::new();
                 err.write(&source, &mut vec).unwrap();
                 Err(String::from_utf8_lossy(&vec).to_string())
+            }
+        }
+    }
     fn component_polarities(&self, identifier: &[u8]) -> Result<Vec<Polarity>, MainComponentErr> {
     pub fn component_polarities(
         &self,
         identifier: &[u8],
     ) -> Result<Vec<Polarity>, AddComponentError> {
         use AddComponentError::*;
         let h = &self.heap;
         let root = &h[self.root];
         let def = root.get_definition_ident(h, identifier);
         if def.is_none() {
-            return Err(MainComponentErr::NoSuchComponent);
             return Err(NoSuchComponent);
+        }
         let def = &h[def.unwrap()];
         if !def.is_component() {
-            return Err(MainComponentErr::NoSuchComponent);
             return Err(NoSuchComponent);
+        }
         for &param in def.parameters().iter() {
             let param = &h[param];
             let type_annot = &h[param.type_annotation];
             if type_annot.the_type.array {
-                return Err(MainComponentErr::NonPortTypeParameters);
                 return Err(NonPortTypeParameters);
+            }
             match type_annot.the_type.primitive {
                 PrimitiveType::Input | PrimitiveType::Output => continue,
                 _ => {
-                    return Err(MainComponentErr::NonPortTypeParameters);
                     return Err(NonPortTypeParameters);
+                }
+            }
+        }
         let mut result = Vec::new();
         for &param in def.parameters().iter() {
             let param = &h[param];
             let type_annot = &h[param.type_annotation];
             let ptype = &type_annot.the_type.primitive;
             if ptype == &PrimitiveType::Input {
                 result.push(Polarity::Getter)
             } else if ptype == &PrimitiveType::Output {
                 result.push(Polarity::Putter)
             } else {
                 unreachable!()
+            }
+        }
         Ok(result)
+    }
     // expects port polarities to be correct
-    fn new_main_component(&self, identifier: &[u8], ports: &[Port]) -> ComponentStateImpl {
+    pub fn new_main_component(&self, identifier: &[u8], ports: &[PortId]) -> ComponentState {
         let mut args = Vec::new();
         for (&x, y) in ports.iter().zip(self.component_polarities(identifier).unwrap()) {
             match y {
                 Polarity::Getter => args.push(Value::Input(InputValue(x))),
                 Polarity::Putter => args.push(Value::Output(OutputValue(x))),
+            }
+        }
         let h = &self.heap;
         let root = &h[self.root];
         let def = root.get_definition_ident(h, identifier).unwrap();
-        ComponentStateImpl { prompt: Prompt::new(h, def, &args) }
+        ComponentState { prompt: Prompt::new(h, def, &args) }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ComponentStateImpl {
     prompt: Prompt,
+}
 impl ComponentState for ComponentStateImpl {
     type D = ProtocolDescriptionImpl;
     fn pre_sync_run<C: MonoContext<D = ProtocolDescriptionImpl, S = Self>>(
         &mut self,
         context: &mut C,
         pd: &ProtocolDescriptionImpl,
     ) -> MonoBlocker {
         let mut context = EvalContext::Mono(context);
 impl ComponentState {
     pub fn nonsync_run<'a: 'b, 'b>(
         &'a mut self,
         context: &'b mut NonsyncContext<'b>,
         pd: &'a ProtocolDescription,
     ) -> NonsyncBlocker {
         let mut context = EvalContext::Nonsync(context);
         loop {
             let result = self.prompt.step(&pd.heap, &mut context);
             match result {
                 // In component definitions, there are no return statements
                 Ok(_) => unreachable!(),
                 Err(cont) => match cont {
                     EvalContinuation::Stepping => continue,
                     EvalContinuation::Inconsistent => return MonoBlocker::Inconsistent,
                     EvalContinuation::Terminal => return MonoBlocker::ComponentExit,
                     EvalContinuation::SyncBlockStart => return MonoBlocker::SyncBlockStart,
                     EvalContinuation::Inconsistent => return NonsyncBlocker::Inconsistent,
                     EvalContinuation::Terminal => return NonsyncBlocker::ComponentExit,
                     EvalContinuation::SyncBlockStart => return NonsyncBlocker::SyncBlockStart,
                     // Not possible to end sync block if never entered one
                     EvalContinuation::SyncBlockEnd => unreachable!(),
                     EvalContinuation::NewComponent(decl, args) => {
                         // Look up definition (TODO for now, assume it is a definition)
                         let h = &pd.heap;
                         let def = h[decl].as_defined().definition;
-                        let init_state = ComponentStateImpl { prompt: Prompt::new(h, def, &args) };
+                        let init_state = ComponentState { prompt: Prompt::new(h, def, &args) };
                         context.new_component(&args, init_state);
                         // Continue stepping
                         continue;
+                    }
                     // Outside synchronous blocks, no fires/get/put happens
                     EvalContinuation::BlockFires(_) => unreachable!(),
                     EvalContinuation::BlockGet(_) => unreachable!(),
                     EvalContinuation::Put(_, _) => unreachable!(),
                 },
+            }
+        }
+    }
     fn sync_run<C: PolyContext<D = ProtocolDescriptionImpl>>(
         &mut self,
         context: &mut C,
         pd: &ProtocolDescriptionImpl,
     ) -> PolyBlocker {
         let mut context = EvalContext::Poly(context);
     pub fn sync_run<'a: 'b, 'b>(
         &'a mut self,
         context: &'b mut SyncContext<'b>,
         pd: &'a ProtocolDescription,
     ) -> SyncBlocker {
         let mut context = EvalContext::Sync(context);
         loop {
             let result = self.prompt.step(&pd.heap, &mut context);
             match result {
                 // Inside synchronous blocks, there are no return statements
                 Ok(_) => unreachable!(),
                 Err(cont) => match cont {
                     EvalContinuation::Stepping => continue,
-                    EvalContinuation::Inconsistent => return PolyBlocker::Inconsistent,
+                    EvalContinuation::Inconsistent => return SyncBlocker::Inconsistent,
                     // First need to exit synchronous block before definition may end
                     EvalContinuation::Terminal => unreachable!(),
                     // No nested synchronous blocks
                     EvalContinuation::SyncBlockStart => unreachable!(),
-                    EvalContinuation::SyncBlockEnd => return PolyBlocker::SyncBlockEnd,
+                    EvalContinuation::SyncBlockEnd => return SyncBlocker::SyncBlockEnd,
                     // Not possible to create component in sync block
                     EvalContinuation::NewComponent(_, _) => unreachable!(),
                     EvalContinuation::BlockFires(port) => match port {
                         Value::Output(OutputValue(port)) => {
-                            return PolyBlocker::CouldntCheckFiring(port);
+                            return SyncBlocker::CouldntCheckFiring(port);
+                        }
                         Value::Input(InputValue(port)) => {
-                            return PolyBlocker::CouldntCheckFiring(port);
+                            return SyncBlocker::CouldntCheckFiring(port);
+                        }
                         _ => unreachable!(),
                     },
                     EvalContinuation::BlockGet(port) => match port {
                         Value::Output(OutputValue(port)) => {
-                            return PolyBlocker::CouldntReadMsg(port);
+                            return SyncBlocker::CouldntReadMsg(port);
+                        }
                         Value::Input(InputValue(port)) => {
-                            return PolyBlocker::CouldntReadMsg(port);
+                            return SyncBlocker::CouldntReadMsg(port);
+                        }
                         _ => unreachable!(),
                     },
                     EvalContinuation::Put(port, message) => {
                         let value;
                         match port {
                             Value::Output(OutputValue(port_value)) => {
                                 value = port_value;
+                            }
                             Value::Input(InputValue(port_value)) => {
                                 value = port_value;
+                            }
                             _ => unreachable!(),
+                        }
                         let payload;
                         match message {
                             Value::Message(MessageValue(None)) => {
                                 // Putting a null message is inconsistent
-                                return PolyBlocker::Inconsistent;
+                                return SyncBlocker::Inconsistent;
+                            }
                             Value::Message(MessageValue(Some(buffer))) => {
                                 // Create a copy of the payload
                                 payload = buffer.clone();
+                            }
                             _ => unreachable!(),
+                        }
-                        return PolyBlocker::PutMsg(value, payload);
+                        return SyncBlocker::PutMsg(value, payload);
+                    }
                 },
+            }
+        }
+    }
+}
 pub enum EvalContext<'a> {
     Mono(&'a mut dyn MonoContext<D = ProtocolDescriptionImpl, S = ComponentStateImpl>),
     Poly(&'a mut dyn PolyContext<D = ProtocolDescriptionImpl>),
     None,
+}
 impl EvalContext<'_> {
     // fn random(&mut self) -> LongValue {
     //     match self {
     //         EvalContext::None => unreachable!(),
     //         EvalContext::Mono(_context) => todo!(),
     //         EvalContext::Poly(_) => unreachable!(),
     //         EvalContext::Nonsync(_context) => todo!(),
     //         EvalContext::Sync(_) => unreachable!(),
     //     }
     // }
-    fn new_component(&mut self, args: &[Value], init_state: ComponentStateImpl) -> () {
+    fn new_component(&mut self, args: &[Value], init_state: ComponentState) -> () {
         match self {
             EvalContext::None => unreachable!(),
-            EvalContext::Mono(context) => {
+            EvalContext::Nonsync(context) => {
                 let mut moved_ports = HashSet::new();
                 for arg in args.iter() {
                     match arg {
                         Value::Output(OutputValue(port)) => {
                             moved_ports.insert(*port);
+                        }
                         Value::Input(InputValue(port)) => {
                             moved_ports.insert(*port);
+                        }
                         _ => {}
+                    }
+                }
                 context.new_component(moved_ports, init_state)
+            }
-            EvalContext::Poly(_) => unreachable!(),
+            EvalContext::Sync(_) => unreachable!(),
+        }
+    }
     fn new_channel(&mut self) -> [Value; 2] {
         match self {
             EvalContext::None => unreachable!(),
-            EvalContext::Mono(context) => {
+            EvalContext::Nonsync(context) => {
                 let [from, to] = context.new_channel();
                 let from = Value::Output(OutputValue(from));
                 let to = Value::Input(InputValue(to));
                 return [from, to];
+            }
-            EvalContext::Poly(_) => unreachable!(),
+            EvalContext::Sync(_) => unreachable!(),
+        }
+    }
     fn fires(&mut self, port: Value) -> Option<Value> {
         match self {
             EvalContext::None => unreachable!(),
             EvalContext::Mono(_) => unreachable!(),
             EvalContext::Poly(context) => match port {
             EvalContext::Nonsync(_) => unreachable!(),
             EvalContext::Sync(context) => match port {
                 Value::Output(OutputValue(port)) => context.is_firing(port).map(Value::from),
                 Value::Input(InputValue(port)) => context.is_firing(port).map(Value::from),
                 _ => unreachable!(),
             },
+        }
+    }
     fn get(&mut self, port: Value) -> Option<Value> {
         match self {
             EvalContext::None => unreachable!(),
             EvalContext::Mono(_) => unreachable!(),
             EvalContext::Poly(context) => match port {
             EvalContext::Nonsync(_) => unreachable!(),
             EvalContext::Sync(context) => match port {
                 Value::Output(OutputValue(port)) => {
                     context.read_msg(port).map(Value::receive_message)
+                }
                 Value::Input(InputValue(port)) => {
                     context.read_msg(port).map(Value::receive_message)
+                }
                 _ => unreachable!(),
             },
+        }
+    }
+}

src/protocol/parser.rs

➞

Show inline comments

@@ @@ -810,1074 +810,1076 @@ impl Visitor for BuildSymbolDeclarations { @@
             .alloc_defined_declaration(|this| DefinedDeclaration { this, definition, signature })
             .upcast();
         self.checked_add(h, decl)?;
         Ok(())
+    }
+}
 struct LinkCallExpressions {
     pd: Option<RootId>,
     composite: bool,
     new_statement: bool,
+}
 impl LinkCallExpressions {
     fn new() -> Self {
         LinkCallExpressions { pd: None, composite: false, new_statement: false }
+    }
     fn get_declaration(
         &self,
         h: &Heap,
         id: SourceIdentifierId,
     ) -> Result<DeclarationId, ParseError> {
         match h[self.pd.unwrap()].get_declaration(h, id.upcast()) {
             Some(id) => Ok(id),
             None => Err(ParseError::new(h[id].position, "Unresolved method")),
+        }
+    }
+}
 impl Visitor for LinkCallExpressions {
     fn visit_protocol_description(&mut self, h: &mut Heap, pd: RootId) -> VisitorResult {
         self.pd = Some(pd);
         recursive_protocol_description(self, h, pd)?;
         self.pd = None;
         Ok(())
+    }
     fn visit_composite_definition(&mut self, h: &mut Heap, def: CompositeId) -> VisitorResult {
         assert!(!self.composite);
         self.composite = true;
         recursive_composite_definition(self, h, def)?;
         self.composite = false;
         Ok(())
+    }
     fn visit_new_statement(&mut self, h: &mut Heap, stmt: NewStatementId) -> VisitorResult {
         assert!(self.composite);
         assert!(!self.new_statement);
         self.new_statement = true;
         recursive_new_statement(self, h, stmt)?;
         self.new_statement = false;
         Ok(())
+    }
     fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {
         if let Method::Symbolic(id) = h[expr].method {
             let decl = self.get_declaration(h, id)?;
             if self.new_statement && h[decl].is_function() {
                 return Err(ParseError::new(h[id].position, "Illegal call expression"));
+            }
             if !self.new_statement && h[decl].is_component() {
                 return Err(ParseError::new(h[id].position, "Illegal call expression"));
+            }
             // Set the corresponding declaration of the call
             h[expr].declaration = Some(decl);
+        }
         // A new statement's call expression may have as arguments function calls
         let old = self.new_statement;
         self.new_statement = false;
         recursive_call_expression(self, h, expr)?;
         self.new_statement = old;
         Ok(())
+    }
+}
 struct BuildScope {
     scope: Option<Scope>,
+}
 impl BuildScope {
     fn new() -> Self {
         BuildScope { scope: None }
+    }
+}
 impl Visitor for BuildScope {
     fn visit_symbol_definition(&mut self, h: &mut Heap, def: DefinitionId) -> VisitorResult {
         assert!(self.scope.is_none());
         self.scope = Some(Scope::Definition(def));
         recursive_symbol_definition(self, h, def)?;
         self.scope = None;
         Ok(())
+    }
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         assert!(!self.scope.is_none());
         let old = self.scope;
         // First store the current scope
         h[stmt].parent_scope = self.scope;
         // Then move scope down to current block
         self.scope = Some(Scope::Block(stmt));
         recursive_block_statement(self, h, stmt)?;
         // Move scope back up
         self.scope = old;
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         assert!(!self.scope.is_none());
         let old = self.scope;
         // First store the current scope
         h[stmt].parent_scope = self.scope;
         // Then move scope down to current sync
         self.scope = Some(Scope::Synchronous(stmt));
         recursive_synchronous_statement(self, h, stmt)?;
         // Move scope back up
         self.scope = old;
         Ok(())
+    }
     fn visit_expression(&mut self, h: &mut Heap, expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 struct ResolveVariables {
     scope: Option<Scope>,
+}
 impl ResolveVariables {
     fn new() -> Self {
         ResolveVariables { scope: None }
+    }
     fn get_variable(&self, h: &Heap, id: SourceIdentifierId) -> Result<VariableId, ParseError> {
         if let Some(var) = self.find_variable(h, id) {
             Ok(var)
         } else {
             Err(ParseError::new(h[id].position, "Unresolved variable"))
+        }
+    }
     fn find_variable(&self, h: &Heap, id: SourceIdentifierId) -> Option<VariableId> {
         ResolveVariables::find_variable_impl(h, self.scope, id)
+    }
     fn find_variable_impl(
         h: &Heap,
         scope: Option<Scope>,
         id: SourceIdentifierId,
     ) -> Option<VariableId> {
         if let Some(scope) = scope {
             // The order in which we check for variables is important:
             // otherwise, two variables with the same name are shadowed.
             if let Some(var) = ResolveVariables::find_variable_impl(h, scope.parent_scope(h), id) {
                 Some(var)
             } else {
                 scope.get_variable(h, id)
+            }
         } else {
             None
+        }
+    }
+}
 impl Visitor for ResolveVariables {
     fn visit_symbol_definition(&mut self, h: &mut Heap, def: DefinitionId) -> VisitorResult {
         assert!(self.scope.is_none());
         self.scope = Some(Scope::Definition(def));
         recursive_symbol_definition(self, h, def)?;
         self.scope = None;
         Ok(())
+    }
     fn visit_variable_declaration(&mut self, h: &mut Heap, decl: VariableId) -> VisitorResult {
         // This is only called for parameters of definitions and synchronous statements,
         // since the local variables of block statements are still empty
         // the moment it is traversed. After resolving variables, this
         // function is also called for every local variable declaration.
         // We want to make sure that the resolved variable is the variable declared itself;
         // otherwise, there is some variable defined in the parent scope. This check
         // imposes that the order in which find_variable looks is significant!
         let id = h[decl].identifier();
         let check_same = self.find_variable(h, id);
         if let Some(check_same) = check_same {
             if check_same != decl {
                 return Err(ParseError::new(h[id].position, "Declared variable clash"));
+            }
+        }
         recursive_variable_declaration(self, h, decl)
+    }
     fn visit_memory_statement(&mut self, h: &mut Heap, stmt: MemoryStatementId) -> VisitorResult {
         assert!(!self.scope.is_none());
         let var = h[stmt].variable;
         let id = h[var].identifier;
         // First check whether variable with same identifier is in scope
         let check_duplicate = self.find_variable(h, id);
         if !check_duplicate.is_none() {
             return Err(ParseError::new(h[id].position, "Declared variable clash"));
+        }
         // Then check the expression's variables (this should not refer to own variable)
         recursive_memory_statement(self, h, stmt)?;
         // Finally, we may add the variable to the scope, which is guaranteed to be a block
+        {
             let mut block = &mut h[self.scope.unwrap().to_block()];
             block.locals.push(var);
+        }
         Ok(())
+    }
     fn visit_channel_statement(&mut self, h: &mut Heap, stmt: ChannelStatementId) -> VisitorResult {
         assert!(!self.scope.is_none());
         // First handle the from variable
+        {
             let var = h[stmt].from;
             let id = h[var].identifier;
             let check_duplicate = self.find_variable(h, id);
             if !check_duplicate.is_none() {
                 return Err(ParseError::new(h[id].position, "Declared variable clash"));
+            }
             let mut block = &mut h[self.scope.unwrap().to_block()];
             block.locals.push(var);
+        }
         // Then handle the to variable (which may not be the same as the from)
+        {
             let var = h[stmt].to;
             let id = h[var].identifier;
             let check_duplicate = self.find_variable(h, id);
             if !check_duplicate.is_none() {
                 return Err(ParseError::new(h[id].position, "Declared variable clash"));
+            }
             let mut block = &mut h[self.scope.unwrap().to_block()];
             block.locals.push(var);
+        }
         Ok(())
+    }
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         assert!(!self.scope.is_none());
         let old = self.scope;
         self.scope = Some(Scope::Block(stmt));
         recursive_block_statement(self, h, stmt)?;
         self.scope = old;
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         assert!(!self.scope.is_none());
         let old = self.scope;
         self.scope = Some(Scope::Synchronous(stmt));
         recursive_synchronous_statement(self, h, stmt)?;
         self.scope = old;
         Ok(())
+    }
     fn visit_variable_expression(
         &mut self,
         h: &mut Heap,
         expr: VariableExpressionId,
     ) -> VisitorResult {
         let var = self.get_variable(h, h[expr].identifier)?;
         h[expr].declaration = Some(var);
         Ok(())
+    }
+}
 struct UniqueStatementId(StatementId);
 struct LinkStatements {
     prev: Option<UniqueStatementId>,
+}
 impl LinkStatements {
     fn new() -> Self {
         LinkStatements { prev: None }
+    }
+}
 impl Visitor for LinkStatements {
     fn visit_symbol_definition(&mut self, h: &mut Heap, def: DefinitionId) -> VisitorResult {
         assert!(self.prev.is_none());
         recursive_symbol_definition(self, h, def)?;
         // Clear out last statement
         self.prev = None;
         Ok(())
+    }
     fn visit_statement(&mut self, h: &mut Heap, stmt: StatementId) -> VisitorResult {
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(stmt);
+        }
         recursive_statement(self, h, stmt)
+    }
     fn visit_local_statement(&mut self, _h: &mut Heap, stmt: LocalStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {
         recursive_labeled_statement(self, h, stmt)
+    }
     fn visit_skip_statement(&mut self, _h: &mut Heap, stmt: SkipStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_if_statement(&mut self, h: &mut Heap, stmt: IfStatementId) -> VisitorResult {
         // We allocate a pseudo-statement, which combines both branches into one next statement
         let position = h[stmt].position;
         let pseudo =
             h.alloc_end_if_statement(|this| EndIfStatement { this, position, next: None }).upcast();
         assert!(self.prev.is_none());
         self.visit_statement(h, h[stmt].true_body)?;
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(pseudo);
+        }
         assert!(self.prev.is_none());
         self.visit_statement(h, h[stmt].false_body)?;
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(pseudo);
+        }
         // Use the pseudo-statement as the statement where to update the next pointer
         self.prev = Some(UniqueStatementId(pseudo));
         Ok(())
+    }
     fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {
         // We allocate a pseudo-statement, to which the break statement finds its target
         let position = h[stmt].position;
         let pseudo =
             h.alloc_end_while_statement(|this| EndWhileStatement { this, position, next: None });
         // Update the while's next statement to point to the pseudo-statement
         h[stmt].next = Some(pseudo);
         assert!(self.prev.is_none());
         self.visit_statement(h, h[stmt].body)?;
         // The body's next statement loops back to the while statement itself
         // Note: continue statements also loop back to the while statement itself
         if let Some(UniqueStatementId(prev)) = std::mem::replace(&mut self.prev, None) {
             h[prev].link_next(stmt.upcast());
+        }
         // Use the while statement as the statement where the next pointer is updated
         self.prev = Some(UniqueStatementId(pseudo.upcast()));
         Ok(())
+    }
     fn visit_break_statement(&mut self, _h: &mut Heap, _stmt: BreakStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_continue_statement(
         &mut self,
         _h: &mut Heap,
         _stmt: ContinueStatementId,
     ) -> VisitorResult {
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         // Allocate a pseudo-statement, that is added for helping the evaluator to issue a command
         // that marks the end of the synchronous block. Every evaluation has to pause at this
         // point, only to resume later when the thread is selected as unique thread to continue.
         let position = h[stmt].position;
         let pseudo = h
             .alloc_end_synchronous_statement(|this| EndSynchronousStatement {
                 this,
                 position,
                 next: None,
             })
             .upcast();
         assert!(self.prev.is_none());
         self.visit_statement(h, h[stmt].body)?;
         // The body's next statement points to the pseudo element
         if let Some(UniqueStatementId(prev)) = std::mem::replace(&mut self.prev, None) {
             h[prev].link_next(pseudo);
+        }
         // Use the pseudo-statement as the statement where the next pointer is updated
         self.prev = Some(UniqueStatementId(pseudo));
         Ok(())
+    }
     fn visit_return_statement(&mut self, h: &mut Heap, stmt: ReturnStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_assert_statement(&mut self, h: &mut Heap, stmt: AssertStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_goto_statement(&mut self, _h: &mut Heap, _stmt: GotoStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_new_statement(&mut self, h: &mut Heap, stmt: NewStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_put_statement(&mut self, h: &mut Heap, stmt: PutStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_expression_statement(
         &mut self,
         h: &mut Heap,
         stmt: ExpressionStatementId,
     ) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_expression(&mut self, h: &mut Heap, expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 struct BuildLabels {
     block: Option<BlockStatementId>,
     sync_enclosure: Option<SynchronousStatementId>,
+}
 impl BuildLabels {
     fn new() -> Self {
         BuildLabels { block: None, sync_enclosure: None }
+    }
+}
 impl Visitor for BuildLabels {
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         assert_eq!(self.block, h[stmt].parent_block(h));
         let old = self.block;
         self.block = Some(stmt);
         recursive_block_statement(self, h, stmt)?;
         self.block = old;
         Ok(())
+    }
     fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {
         assert!(!self.block.is_none());
         // Store label in current block (on the fly)
         h[self.block.unwrap()].labels.push(stmt);
         // Update synchronous scope of label
         h[stmt].in_sync = self.sync_enclosure;
         recursive_labeled_statement(self, h, stmt)
+    }
     fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {
         h[stmt].in_sync = self.sync_enclosure;
         recursive_while_statement(self, h, stmt)
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         assert!(self.sync_enclosure.is_none());
         self.sync_enclosure = Some(stmt);
         recursive_synchronous_statement(self, h, stmt)?;
         self.sync_enclosure = None;
         Ok(())
+    }
     fn visit_expression(&mut self, h: &mut Heap, expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 struct ResolveLabels {
     block: Option<BlockStatementId>,
     while_enclosure: Option<WhileStatementId>,
     sync_enclosure: Option<SynchronousStatementId>,
+}
 impl ResolveLabels {
     fn new() -> Self {
         ResolveLabels { block: None, while_enclosure: None, sync_enclosure: None }
+    }
     fn check_duplicate_impl(
         h: &Heap,
         block: Option<BlockStatementId>,
         stmt: LabeledStatementId,
     ) -> VisitorResult {
         if let Some(block) = block {
             // Checking the parent first is important. Otherwise, labels
             // overshadow previously defined labels: and this is illegal!
             ResolveLabels::check_duplicate_impl(h, h[block].parent_block(h), stmt)?;
             // For the current block, check for a duplicate.
             for &other_stmt in h[block].labels.iter() {
                 if other_stmt == stmt {
                     continue;
                 } else {
                     if h[h[other_stmt].label] == h[h[stmt].label] {
                         return Err(ParseError::new(h[stmt].position, "Duplicate label"));
+                    }
+                }
+            }
+        }
         Ok(())
+    }
     fn check_duplicate(&self, h: &Heap, stmt: LabeledStatementId) -> VisitorResult {
         ResolveLabels::check_duplicate_impl(h, self.block, stmt)
+    }
     fn get_target(
         &self,
         h: &Heap,
         id: SourceIdentifierId,
     ) -> Result<LabeledStatementId, ParseError> {
         if let Some(stmt) = ResolveLabels::find_target(h, self.block, id) {
             Ok(stmt)
         } else {
             Err(ParseError::new(h[id].position, "Unresolved label"))
+        }
+    }
     fn find_target(
         h: &Heap,
         block: Option<BlockStatementId>,
         id: SourceIdentifierId,
     ) -> Option<LabeledStatementId> {
         if let Some(block) = block {
             // It does not matter in what order we find the labels.
             // If there are duplicates: that is checked elsewhere.
             for &stmt in h[block].labels.iter() {
                 if h[h[stmt].label] == h[id] {
                     return Some(stmt);
+                }
+            }
             if let Some(stmt) = ResolveLabels::find_target(h, h[block].parent_block(h), id) {
                 return Some(stmt);
+            }
+        }
         None
+    }
+}
 impl Visitor for ResolveLabels {
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         assert_eq!(self.block, h[stmt].parent_block(h));
         let old = self.block;
         self.block = Some(stmt);
         recursive_block_statement(self, h, stmt)?;
         self.block = old;
         Ok(())
+    }
     fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {
         assert!(!self.block.is_none());
         self.check_duplicate(h, stmt)?;
         recursive_labeled_statement(self, h, stmt)
+    }
     fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {
         let old = self.while_enclosure;
         self.while_enclosure = Some(stmt);
         recursive_while_statement(self, h, stmt)?;
         self.while_enclosure = old;
         Ok(())
+    }
     fn visit_break_statement(&mut self, h: &mut Heap, stmt: BreakStatementId) -> VisitorResult {
         let the_while;
         if let Some(label) = h[stmt].label {
             let target = self.get_target(h, label)?;
             let target = &h[h[target].body];
             if !target.is_while() {
                 return Err(ParseError::new(
                     h[stmt].position,
                     "Illegal break: target not a while statement",
                 ));
+            }
             the_while = target.as_while();
         // TODO: check if break is nested under while
         } else {
             if self.while_enclosure.is_none() {
                 return Err(ParseError::new(
                     h[stmt].position,
                     "Illegal break: no surrounding while statement",
                 ));
+            }
             the_while = &h[self.while_enclosure.unwrap()];
             // break is always nested under while, by recursive vistor
+        }
         if the_while.in_sync != self.sync_enclosure {
             return Err(ParseError::new(
                 h[stmt].position,
                 "Illegal break: synchronous statement escape",
             ));
+        }
         h[stmt].target = the_while.next;
         Ok(())
+    }
     fn visit_continue_statement(
         &mut self,
         h: &mut Heap,
         stmt: ContinueStatementId,
     ) -> VisitorResult {
         let the_while;
         if let Some(label) = h[stmt].label {
             let target = self.get_target(h, label)?;
             let target = &h[h[target].body];
             if !target.is_while() {
                 return Err(ParseError::new(
                     h[stmt].position,
                     "Illegal continue: target not a while statement",
                 ));
+            }
             the_while = target.as_while();
         // TODO: check if continue is nested under while
         } else {
             if self.while_enclosure.is_none() {
                 return Err(ParseError::new(
                     h[stmt].position,
                     "Illegal continue: no surrounding while statement",
                 ));
+            }
             the_while = &h[self.while_enclosure.unwrap()];
             // continue is always nested under while, by recursive vistor
+        }
         if the_while.in_sync != self.sync_enclosure {
             return Err(ParseError::new(
                 h[stmt].position,
                 "Illegal continue: synchronous statement escape",
             ));
+        }
         h[stmt].target = Some(the_while.this);
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         assert!(self.sync_enclosure.is_none());
         self.sync_enclosure = Some(stmt);
         recursive_synchronous_statement(self, h, stmt)?;
         self.sync_enclosure = None;
         Ok(())
+    }
     fn visit_goto_statement(&mut self, h: &mut Heap, stmt: GotoStatementId) -> VisitorResult {
         let target = self.get_target(h, h[stmt].label)?;
         if h[target].in_sync != self.sync_enclosure {
             return Err(ParseError::new(
                 h[stmt].position,
                 "Illegal goto: synchronous statement escape",
             ));
+        }
         h[stmt].target = Some(target);
         Ok(())
+    }
     fn visit_expression(&mut self, h: &mut Heap, expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 struct AssignableExpressions {
     assignable: bool,
+}
 impl AssignableExpressions {
     fn new() -> Self {
         AssignableExpressions { assignable: false }
+    }
     fn error(&self, position: InputPosition) -> VisitorResult {
         Err(ParseError::new(position, "Unassignable expression"))
+    }
+}
 impl Visitor for AssignableExpressions {
     fn visit_assignment_expression(
         &mut self,
         h: &mut Heap,
         expr: AssignmentExpressionId,
     ) -> VisitorResult {
         if self.assignable {
             self.error(h[expr].position)
         } else {
             self.assignable = true;
             self.visit_expression(h, h[expr].left)?;
             self.assignable = false;
             self.visit_expression(h, h[expr].right)
+        }
+    }
     fn visit_conditional_expression(
         &mut self,
         h: &mut Heap,
         expr: ConditionalExpressionId,
     ) -> VisitorResult {
         if self.assignable {
             self.error(h[expr].position)
         } else {
             recursive_conditional_expression(self, h, expr)
+        }
+    }
     fn visit_binary_expression(&mut self, h: &mut Heap, expr: BinaryExpressionId) -> VisitorResult {
         if self.assignable {
             self.error(h[expr].position)
         } else {
             recursive_binary_expression(self, h, expr)
+        }
+    }
     fn visit_unary_expression(&mut self, h: &mut Heap, expr: UnaryExpressionId) -> VisitorResult {
         if self.assignable {
             self.error(h[expr].position)
         } else {
             match h[expr].operation {
                 UnaryOperation::PostDecrement
                 | UnaryOperation::PreDecrement
                 | UnaryOperation::PostIncrement
                 | UnaryOperation::PreIncrement => {
                     self.assignable = true;
                     recursive_unary_expression(self, h, expr)?;
                     self.assignable = false;
                     Ok(())
+                }
                 _ => recursive_unary_expression(self, h, expr),
+            }
+        }
+    }
     fn visit_indexing_expression(
         &mut self,
         h: &mut Heap,
         expr: IndexingExpressionId,
     ) -> VisitorResult {
         let old = self.assignable;
         self.assignable = false;
         recursive_indexing_expression(self, h, expr)?;
         self.assignable = old;
         Ok(())
+    }
     fn visit_slicing_expression(
         &mut self,
         h: &mut Heap,
         expr: SlicingExpressionId,
     ) -> VisitorResult {
         let old = self.assignable;
         self.assignable = false;
         recursive_slicing_expression(self, h, expr)?;
         self.assignable = old;
         Ok(())
+    }
     fn visit_select_expression(&mut self, h: &mut Heap, expr: SelectExpressionId) -> VisitorResult {
         if h[expr].field.is_length() && self.assignable {
             return self.error(h[expr].position);
+        }
         let old = self.assignable;
         self.assignable = false;
         recursive_select_expression(self, h, expr)?;
         self.assignable = old;
         Ok(())
+    }
     fn visit_array_expression(&mut self, h: &mut Heap, expr: ArrayExpressionId) -> VisitorResult {
         if self.assignable {
             self.error(h[expr].position)
         } else {
             recursive_array_expression(self, h, expr)
+        }
+    }
     fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {
         if self.assignable {
             self.error(h[expr].position)
         } else {
             recursive_call_expression(self, h, expr)
+        }
+    }
     fn visit_constant_expression(
         &mut self,
         h: &mut Heap,
         expr: ConstantExpressionId,
     ) -> VisitorResult {
         if self.assignable {
             self.error(h[expr].position)
         } else {
             Ok(())
+        }
+    }
     fn visit_variable_expression(
         &mut self,
         h: &mut Heap,
         expr: VariableExpressionId,
     ) -> VisitorResult {
         Ok(())
+    }
+}
 struct IndexableExpressions {
     indexable: bool,
+}
 impl IndexableExpressions {
     fn new() -> Self {  IndexableExpressions { indexable: false }  }
     fn new() -> Self {
         IndexableExpressions { indexable: false }
+    }
     fn error(&self, position: InputPosition) -> VisitorResult {
         Err(ParseError::new(position, "Unindexable expression"))
+    }
+}
 impl Visitor for IndexableExpressions {
     fn visit_assignment_expression(
         &mut self,
         h: &mut Heap,
         expr: AssignmentExpressionId,
     ) -> VisitorResult {
         if self.indexable {
             self.error(h[expr].position)
         } else {
             recursive_assignment_expression(self, h, expr)
+        }
+    }
     fn visit_conditional_expression(
         &mut self,
         h: &mut Heap,
         expr: ConditionalExpressionId,
     ) -> VisitorResult {
         let old = self.indexable;
         self.indexable = false;
         self.visit_expression(h, h[expr].test)?;
         self.indexable = old;
         self.visit_expression(h, h[expr].true_expression)?;
         self.visit_expression(h, h[expr].false_expression)
+    }
     fn visit_binary_expression(&mut self, h: &mut Heap, expr: BinaryExpressionId) -> VisitorResult {
         if self.indexable && h[expr].operation != BinaryOperator::Concatenate {
             self.error(h[expr].position)
         } else {
             recursive_binary_expression(self, h, expr)
+        }
+    }
     fn visit_unary_expression(&mut self, h: &mut Heap, expr: UnaryExpressionId) -> VisitorResult {
         if self.indexable {
             self.error(h[expr].position)
         } else {
             recursive_unary_expression(self, h, expr)
+        }
+    }
     fn visit_indexing_expression(
         &mut self,
         h: &mut Heap,
         expr: IndexingExpressionId,
     ) -> VisitorResult {
         let old = self.indexable;
         self.indexable = true;
         self.visit_expression(h, h[expr].subject)?;
         self.indexable = false;
         self.visit_expression(h, h[expr].index)?;
         self.indexable = old;
         Ok(())
+    }
     fn visit_slicing_expression(
         &mut self,
         h: &mut Heap,
         expr: SlicingExpressionId,
     ) -> VisitorResult {
         let old = self.indexable;
         self.indexable = true;
         self.visit_expression(h, h[expr].subject)?;
         self.indexable = false;
         self.visit_expression(h, h[expr].from_index)?;
         self.visit_expression(h, h[expr].to_index)?;
         self.indexable = old;
         Ok(())
+    }
     fn visit_select_expression(&mut self, h: &mut Heap, expr: SelectExpressionId) -> VisitorResult {
         let old = self.indexable;
         self.indexable = false;
         recursive_select_expression(self, h, expr)?;
         self.indexable = old;
         Ok(())
+    }
     fn visit_array_expression(&mut self, h: &mut Heap, expr: ArrayExpressionId) -> VisitorResult {
         let old = self.indexable;
         self.indexable = false;
         recursive_array_expression(self, h, expr)?;
         self.indexable = old;
         Ok(())
+    }
     fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {
         let old = self.indexable;
         self.indexable = false;
         recursive_call_expression(self, h, expr)?;
         self.indexable = old;
         Ok(())
+    }
     fn visit_constant_expression(
         &mut self,
         h: &mut Heap,
         expr: ConstantExpressionId,
     ) -> VisitorResult {
         if self.indexable {
             self.error(h[expr].position)
         } else {
             Ok(())
+        }
+    }
+}
 struct SelectableExpressions {
     selectable: bool,
+}
 impl SelectableExpressions {
     fn new() -> Self {
         SelectableExpressions { selectable: false }
+    }
     fn error(&self, position: InputPosition) -> VisitorResult {
         Err(ParseError::new(position, "Unselectable expression"))
+    }
+}
 impl Visitor for SelectableExpressions {
     fn visit_assignment_expression(
         &mut self,
         h: &mut Heap,
         expr: AssignmentExpressionId,
     ) -> VisitorResult {
         // left-hand side of assignment can be skipped
         let old = self.selectable;
         self.selectable = false;
         self.visit_expression(h, h[expr].right)?;
         self.selectable = old;
         Ok(())
+    }
     fn visit_conditional_expression(
         &mut self,
         h: &mut Heap,
         expr: ConditionalExpressionId,
     ) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         self.visit_expression(h, h[expr].test)?;
         self.selectable = old;
         self.visit_expression(h, h[expr].true_expression)?;
         self.visit_expression(h, h[expr].false_expression)
+    }
     fn visit_binary_expression(&mut self, h: &mut Heap, expr: BinaryExpressionId) -> VisitorResult {
         if self.selectable && h[expr].operation != BinaryOperator::Concatenate {
             self.error(h[expr].position)
         } else {
             recursive_binary_expression(self, h, expr)
+        }
+    }
     fn visit_unary_expression(&mut self, h: &mut Heap, expr: UnaryExpressionId) -> VisitorResult {
         if self.selectable {
             self.error(h[expr].position)
         } else {
             recursive_unary_expression(self, h, expr)
+        }
+    }
     fn visit_indexing_expression(
         &mut self,
         h: &mut Heap,
         expr: IndexingExpressionId,
     ) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         recursive_indexing_expression(self, h, expr)?;
         self.selectable = old;
         Ok(())
+    }
     fn visit_slicing_expression(
         &mut self,
         h: &mut Heap,
         expr: SlicingExpressionId,
     ) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         recursive_slicing_expression(self, h, expr)?;
         self.selectable = old;
         Ok(())
+    }
     fn visit_select_expression(&mut self, h: &mut Heap, expr: SelectExpressionId) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         recursive_select_expression(self, h, expr)?;
         self.selectable = old;
         Ok(())
+    }
     fn visit_array_expression(&mut self, h: &mut Heap, expr: ArrayExpressionId) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         recursive_array_expression(self, h, expr)?;
         self.selectable = old;
         Ok(())
+    }
     fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {
         let old = self.selectable;
         self.selectable = false;
         recursive_call_expression(self, h, expr)?;
         self.selectable = old;
         Ok(())
+    }
     fn visit_constant_expression(
         &mut self,
         h: &mut Heap,
         expr: ConstantExpressionId,
     ) -> VisitorResult {
         if self.selectable {
             self.error(h[expr].position)
         } else {
             Ok(())
+        }
+    }
+}
 pub struct Parser<'a> {
     source: &'a mut InputSource,
+}
 impl<'a> Parser<'a> {
     pub fn new(source: &'a mut InputSource) -> Self {
         Parser { source }
+    }
     pub fn parse(&mut self, h: &mut Heap) -> Result<RootId, ParseError> {
         let mut lex = Lexer::new(self.source);
         let pd = lex.consume_protocol_description(h)?;
         NestedSynchronousStatements::new().visit_protocol_description(h, pd)?;
         ChannelStatementOccurrences::new().visit_protocol_description(h, pd)?;
         FunctionStatementReturns::new().visit_protocol_description(h, pd)?;
         ComponentStatementReturnNew::new().visit_protocol_description(h, pd)?;
         CheckBuiltinOccurrences::new().visit_protocol_description(h, pd)?;
         BuildSymbolDeclarations::new().visit_protocol_description(h, pd)?;
         LinkCallExpressions::new().visit_protocol_description(h, pd)?;
         BuildScope::new().visit_protocol_description(h, pd)?;
         ResolveVariables::new().visit_protocol_description(h, pd)?;
         LinkStatements::new().visit_protocol_description(h, pd)?;
         BuildLabels::new().visit_protocol_description(h, pd)?;
         ResolveLabels::new().visit_protocol_description(h, pd)?;
         AssignableExpressions::new().visit_protocol_description(h, pd)?;
         IndexableExpressions::new().visit_protocol_description(h, pd)?;
         SelectableExpressions::new().visit_protocol_description(h, pd)?;
         Ok(pd)
+    }
+}
 #[cfg(test)]
 mod tests {
     extern crate test_generator;
     use std::fs::File;
     use std::io::Read;
     use std::path::Path;
     use test_generator::test_resources;
     use super::*;
     #[test_resources("testdata/parser/positive/*.pdl")]
     fn batch1(resource: &str) {
         let path = Path::new(resource);
         let mut heap = Heap::new();
         let mut source = InputSource::from_file(&path).unwrap();
         let mut parser = Parser::new(&mut source);
         match parser.parse(&mut heap) {
             Ok(_) => {}
             Err(err) => {
                 println!("{}", err.display(&source));
                 println!("{:?}", err);
                 assert!(false);
+            }
+        }
+    }
     #[test_resources("testdata/parser/negative/*.pdl")]
     fn batch2(resource: &str) {
         let path = Path::new(resource);
         let expect = path.with_extension("txt");
         let mut heap = Heap::new();
         let mut source = InputSource::from_file(&path).unwrap();
         let mut parser = Parser::new(&mut source);
         match parser.parse(&mut heap) {
             Ok(pd) => {
                 println!("{:?}", heap[pd]);
                 println!("Expected parse error:");
                 let mut cev: Vec<u8> = Vec::new();
                 let mut f = File::open(expect).unwrap();
                 f.read_to_end(&mut cev).unwrap();
                 println!("{}", String::from_utf8_lossy(&cev));
                 assert!(false);
+            }
             Err(err) => {
                 println!("{:?}", err);
                 let mut vec: Vec<u8> = Vec::new();
                 err.write(&source, &mut vec).unwrap();
                 println!("{}", String::from_utf8_lossy(&vec));
                 let mut cev: Vec<u8> = Vec::new();
                 let mut f = File::open(expect).unwrap();
                 f.read_to_end(&mut cev).unwrap();
                 println!("{}", String::from_utf8_lossy(&cev));
                 assert_eq!(vec, cev);
+            }
+        }
+    }
+}
 // #[cfg(test)]
 // mod tests {
 //     extern crate test_generator;
 //     use std::fs::File;
 //     use std::io::Read;
 //     use std::path::Path;
 //     use test_generator::test_resources;
 //     use super::*;
 //     #[test_resources("testdata/parser/positive/*.pdl")]
 //     fn batch1(resource: &str) {
 //         let path = Path::new(resource);
 //         let mut heap = Heap::new();
 //         let mut source = InputSource::from_file(&path).unwrap();
 //         let mut parser = Parser::new(&mut source);
 //         match parser.parse(&mut heap) {
 //             Ok(_) => {}
 //             Err(err) => {
 //                 println!("{}", err.display(&source));
 //                 println!("{:?}", err);
 //                 assert!(false);
 //             }
 //         }
 //     }
 //     #[test_resources("testdata/parser/negative/*.pdl")]
 //     fn batch2(resource: &str) {
 //         let path = Path::new(resource);
 //         let expect = path.with_extension("txt");
 //         let mut heap = Heap::new();
 //         let mut source = InputSource::from_file(&path).unwrap();
 //         let mut parser = Parser::new(&mut source);
 //         match parser.parse(&mut heap) {
 //             Ok(pd) => {
 //                 println!("{:?}", heap[pd]);
 //                 println!("Expected parse error:");
 //                 let mut cev: Vec<u8> = Vec::new();
 //                 let mut f = File::open(expect).unwrap();
 //                 f.read_to_end(&mut cev).unwrap();
 //                 println!("{}", String::from_utf8_lossy(&cev));
 //                 assert!(false);
 //             }
 //             Err(err) => {
 //                 println!("{:?}", err);
 //                 let mut vec: Vec<u8> = Vec::new();
 //                 err.write(&source, &mut vec).unwrap();
 //                 println!("{}", String::from_utf8_lossy(&vec));
 //                 let mut cev: Vec<u8> = Vec::new();
 //                 let mut f = File::open(expect).unwrap();
 //                 f.read_to_end(&mut cev).unwrap();
 //                 println!("{}", String::from_utf8_lossy(&cev));
 //                 assert_eq!(vec, cev);
 //             }
 //         }
 //     }
 // }

src/runtime/actors.rs

➞

Show inline comments

 use crate::common::*;
 use crate::runtime::{endpoint::*, *};
 #[derive(Debug, Clone)]
 pub(crate) struct MonoN {
     pub ports: HashSet<Port>,
     pub result: Option<(usize, HashMap<Port, Payload>)>,
     pub ports: HashSet<PortId>,
     pub result: Option<(usize, HashMap<PortId, Payload>)>,
+}
 #[derive(Debug)]
 pub(crate) struct PolyN {
-    pub ports: HashSet<Port>,
+    pub ports: HashSet<PortId>,
     pub branches: HashMap<Predicate, BranchN>,
+}
 #[derive(Debug, Clone)]
 pub(crate) struct BranchN {
     pub to_get: HashSet<Port>,
     pub gotten: HashMap<Port, Payload>,
     pub to_get: HashSet<PortId>,
     pub gotten: HashMap<PortId, Payload>,
     pub sync_batch_index: usize,
+}
 #[derive(Debug, Clone)]
 pub struct MonoP {
     pub state: ProtocolS,
-    pub ports: HashSet<Port>,
+    pub ports: HashSet<PortId>,
+}
 #[derive(Debug)]
 pub(crate) struct PolyP {
     pub incomplete: HashMap<Predicate, BranchP>,
     pub complete: HashMap<Predicate, BranchP>,
-    pub ports: HashSet<Port>,
+    pub ports: HashSet<PortId>,
+}
 #[derive(Debug, Clone)]
 pub(crate) struct BranchP {
     pub blocking_on: Option<Port>,
     pub outbox: HashMap<Port, Payload>,
     pub inbox: HashMap<Port, Payload>,
     pub blocking_on: Option<PortId>,
     pub outbox: HashMap<PortId, Payload>,
     pub inbox: HashMap<PortId, Payload>,
     pub state: ProtocolS,
+}
 //////////////////////////////////////////////////////////////////
 impl PolyP {
     pub(crate) fn poly_run(
         &mut self,
         m_ctx: PolyPContext,
         protocol_description: &ProtocolD,
     ) -> Result<SyncRunResult, EndpointErr> {
         let to_run: Vec<_> = self.incomplete.drain().collect();
         self.poly_run_these_branches(m_ctx, protocol_description, to_run)
+    }
     pub(crate) fn poly_run_these_branches(
         &mut self,
         mut m_ctx: PolyPContext,
         protocol_description: &ProtocolD,
         mut to_run: Vec<(Predicate, BranchP)>,
     ) -> Result<SyncRunResult, EndpointErr> {
         use SyncRunResult as Srr;
         log!(&mut m_ctx.inner.logger, "~ Running branches for PolyP {:?}!", m_ctx.my_subtree_id,);
         'to_run_loop: while let Some((mut predicate, mut branch)) = to_run.pop() {
             let mut r_ctx = BranchPContext {
                 m_ctx: m_ctx.reborrow(),
                 ports: &self.ports,
                 predicate: &predicate,
                 inbox: &branch.inbox,
             };
             use PolyBlocker as Sb;
             let blocker = branch.state.sync_run(&mut r_ctx, protocol_description);
             log!(
                 &mut r_ctx.m_ctx.inner.logger,
                 "~ ... ran PolyP {:?} with branch pred {:?} to blocker {:?}",
                 r_ctx.m_ctx.my_subtree_id,
                 &predicate,
                 &blocker
             );
             match blocker {
                 Sb::Inconsistent => {} // DROP
                 Sb::CouldntReadMsg(port) => {
                     assert!(self.ports.contains(&port));
                     let channel_id =
                         r_ctx.m_ctx.inner.endpoint_exts.get(port).unwrap().info.channel_id;
                     log!(
                         &mut r_ctx.m_ctx.inner.logger,
                         "~ ... {:?} couldnt read msg for port {:?}. has inbox {:?}",
                         r_ctx.m_ctx.my_subtree_id,
                         channel_id,
                         &branch.inbox,
                     );
                     if predicate.replace_assignment(channel_id, true) != Some(false) {
                         // don't rerun now. Rerun at next `sync_run`
                         log!(&mut m_ctx.inner.logger, "~ ... Delay {:?}", m_ctx.my_subtree_id,);
                         branch.blocking_on = Some(port);
                         self.incomplete.insert(predicate, branch);
                     } else {
                         log!(&mut m_ctx.inner.logger, "~ ... Drop {:?}", m_ctx.my_subtree_id,);
+                    }
                     // ELSE DROP
+                }
                 Sb::CouldntCheckFiring(port) => {
                     assert!(self.ports.contains(&port));
                     let channel_id =
                         r_ctx.m_ctx.inner.endpoint_exts.get(port).unwrap().info.channel_id;
                     // split the branch!
                     let branch_f = branch.clone();
                     let mut predicate_f = predicate.clone();
                     if predicate_f.replace_assignment(channel_id, false).is_some() {
                         panic!("OI HANS QUERY FIRST!");
+                    }
                     assert!(predicate.replace_assignment(channel_id, true).is_none());
                     to_run.push((predicate, branch));
                     to_run.push((predicate_f, branch_f));
+                }
                 Sb::SyncBlockEnd => {
                     let ControllerInner { logger, endpoint_exts, .. } = m_ctx.inner;
                     log!(
                         logger,
                         "~ ... ran {:?} reached SyncBlockEnd with pred {:?} ...",
                         m_ctx.my_subtree_id,
                         &predicate,
                     );
                     // come up with the predicate for this local solution
                     for port in self.ports.iter() {
                         let channel_id = endpoint_exts.get(*port).unwrap().info.channel_id;
                         let fired =
                             branch.inbox.contains_key(port) || branch.outbox.contains_key(port);
                         match predicate.query(channel_id) {
                             Some(true) => {
                                 if !fired {
                                     // This branch should have fired but didn't!
                                     log!(
                                         logger,
                                         "~ ... ... should have fired {:?} and didn't! pruning!",
                                         channel_id,
                                     );
                                     continue 'to_run_loop;
+                                }
+                            }
                             Some(false) => {
                                 if fired {
                                     println!(
                                         "pred {:#?} in {:#?} out {:#?}",
                                         &predicate,
                                         branch.inbox.get(port),
                                         branch.outbox.get(port)
                                     );
                                     panic!("channel_id {:?} fired (based on outbox/inbox) but the predicate had Some(false)!" ,channel_id)
+                                }
+                            }
                             None => {
                                 predicate.replace_assignment(channel_id, false);
                                 if fired {
                                     println!(
                                         "pred {:#?} in {:#?} out {:#?}",
                                         &predicate,
                                         branch.inbox.get(port),
                                         branch.outbox.get(port)
                                     );
                                     panic!("channel_id {:?} fired (based on outbox/inbox) but the predicate had None!" ,channel_id)
+                                }
+                            }
+                        }
+                    }
                     log!(logger, "~ ... ... and finished just fine!",);
                     m_ctx.solution_storage.submit_and_digest_subtree_solution(
                         &mut m_ctx.inner.logger,
                         m_ctx.my_subtree_id,
                         predicate.clone(),
                     );
                     self.complete.insert(predicate, branch);
+                }
                 Sb::PutMsg(port, payload) => {
                     assert!(self.ports.contains(&port));
                     let EndpointExt { info, endpoint } =
                         m_ctx.inner.endpoint_exts.get_mut(port).unwrap();
                     if predicate.replace_assignment(info.channel_id, true) != Some(false) {
                         branch.outbox.insert(port, payload.clone());
                         let msg = CommMsgContents::SendPayload {
                             payload_predicate: predicate.clone(),
                             payload,
+                        }
                         .into_msg(m_ctx.inner.round_index);
                         log!(
                             &mut m_ctx.inner.logger,
                             "~ ... ... PolyP sending msg {:?} to {:?} ({:?}) now!",
                             &msg,
                             port,
                             (info.channel_id.controller_id, info.channel_id.channel_index),
                         );
                         endpoint.send(msg)?;
                         to_run.push((predicate, branch));
+                    }
                     // ELSE DROP
+                }
+            }
+        }
         // all in self.incomplete most recently returned Blocker::CouldntReadMsg
         Ok(if self.incomplete.is_empty() {
             if self.complete.is_empty() {
                 Srr::NoBranches
             } else {
                 Srr::AllBranchesComplete
+            }
         } else {
             Srr::BlockingForRecv
         })
+    }
     pub(crate) fn poly_recv_run(
         &mut self,
         m_ctx: PolyPContext,
         protocol_description: &ProtocolD,
-        port: Port,
+        port: PortId,
         payload_predicate: Predicate,
         payload: Payload,
     ) -> Result<SyncRunResult, EndpointErr> {
         // try exact match
         let to_run = if self.complete.contains_key(&payload_predicate) {
             // exact match with stopped machine
             log!(
                 &mut m_ctx.inner.logger,
                 "... poly_recv_run matched stopped machine exactly! nothing to do here",
             );
             vec![]
         } else if let Some(mut branch) = self.incomplete.remove(&payload_predicate) {
             // exact match with running machine
             log!(
                 &mut m_ctx.inner.logger,
                 "... poly_recv_run matched running machine exactly! pred is {:?}",
                 &payload_predicate
             );
             branch.inbox.insert(port, payload);
             if branch.blocking_on == Some(port) {
                 branch.blocking_on = None;
                 vec![(payload_predicate, branch)]
             } else {
                 vec![]
+            }
         } else {
             log!(
                 &mut m_ctx.inner.logger,
                 "... poly_recv_run didn't have any exact matches... Let's try feed it to all branches",
             );
             let mut incomplete2 = HashMap::<_, _>::default();
             let to_run = self
                 .incomplete
                 .drain()
                 .filter_map(|(old_predicate, mut branch)| {
                     use CommonSatResult as Csr;
                     match old_predicate.common_satisfier(&payload_predicate) {
                         Csr::FormerNotLatter | Csr::Equivalent => {
                             log!(
                                 &mut m_ctx.inner.logger,
                                 "... poly_recv_run This branch is compatible unaltered! branch pred: {:?}",
                                 &old_predicate
                             );
                             // old_predicate COVERS the assumptions of payload_predicate
                             if let Some(prev_payload) = branch.inbox.get(&port) {
                                 // Incorrect to receive two distinct messages in same branch!
                                 assert_eq!(prev_payload, &payload);
+                            }
                             branch.inbox.insert(port, payload.clone());
                             if branch.blocking_on == Some(port) {
                                 // run.
                                 branch.blocking_on = None;
                                 Some((old_predicate, branch))
                             } else {
                                 // don't bother running. its awaiting something else
                                 incomplete2.insert(old_predicate, branch);
                                 None
+                            }
+                        }
                         Csr::New(new) => {
                             log!(
                                 &mut m_ctx.inner.logger,
                                 "... poly_recv_run payloadpred {:?} and branchpred {:?} satisfied by new pred {:?}. FORKING",
                                 &payload_predicate,
                                 &old_predicate,
                                 &new,
                             );
                             // payload_predicate has new assumptions. FORK!
                             let mut payload_branch = branch.clone();
                             if let Some(prev_payload) = payload_branch.inbox.get(&port) {
                                 // Incorrect to receive two distinct messages in same branch!
                                 assert_eq!(prev_payload, &payload);
+                            }
                             payload_branch.inbox.insert(port, payload.clone());
                             // put the original back untouched
                             incomplete2.insert(old_predicate, branch);
                             if payload_branch.blocking_on == Some(port) {
                                 // run the fork
                                 payload_branch.blocking_on = None;
                                 Some((new, payload_branch))
                             } else {
                                 // don't bother running. its awaiting something else
                                 incomplete2.insert(new, payload_branch);
                                 None
+                            }
+                        }
                         Csr::LatterNotFormer => {
                             log!(
                                 &mut m_ctx.inner.logger,
                                 "... poly_recv_run payloadpred {:?} subsumes branch pred {:?}. FORKING",
                                 &old_predicate,
                                 &payload_predicate,
                             );
                             // payload_predicate has new assumptions. FORK!
                             let mut payload_branch = branch.clone();
                             if let Some(prev_payload) = payload_branch.inbox.get(&port) {
                                 // Incorrect to receive two distinct messages in same branch!
                                 assert_eq!(prev_payload, &payload);
+                            }
                             payload_branch.inbox.insert(port, payload.clone());
                             // put the original back untouched
                             incomplete2.insert(old_predicate.clone(), branch);
                             if payload_branch.blocking_on == Some(port) {
                                 // run the fork
                                 payload_branch.blocking_on = None;
                                 Some((payload_predicate.clone(), payload_branch))
                             } else {
                                 // don't bother running. its awaiting something else
                                 incomplete2.insert(payload_predicate.clone(), payload_branch);
                                 None
+                            }
+                        }
                         Csr::Nonexistant => {
                             log!(
                                 &mut m_ctx.inner.logger,
                                 "... poly_recv_run SKIPPING because branchpred={:?}. payloadpred={:?}",
                                 &old_predicate,
                                 &payload_predicate,
                             );
                             // predicates contradict
                             incomplete2.insert(old_predicate, branch);
                             None
+                        }
+                    }
                 })
                 .collect();
             std::mem::swap(&mut self.incomplete, &mut incomplete2);
             to_run
         };
         log!(
             &mut m_ctx.inner.logger,
             "... DONE FEEDING BRANCHES. {} branches to run!",
             to_run.len(),
         );
         self.poly_run_these_branches(m_ctx, protocol_description, to_run)
+    }
     pub(crate) fn choose_mono(&self, decision: &Predicate) -> Option<MonoP> {
         self.complete
             .iter()
             .find(|(p, _)| decision.satisfies(p))
             .map(|(_, branch)| MonoP { state: branch.state.clone(), ports: self.ports.clone() })
+    }
+}
 impl PolyN {
     pub fn sync_recv(
         &mut self,
-        port: Port,
+        port: PortId,
         logger: &mut String,
         payload: Payload,
         payload_predicate: Predicate,
         solution_storage: &mut SolutionStorage,
     ) {
         let mut branches2: HashMap<_, _> = Default::default();
         for (old_predicate, mut branch) in self.branches.drain() {
             use CommonSatResult as Csr;
             let case = old_predicate.common_satisfier(&payload_predicate);
             let mut report_if_solution =
                 |branch: &BranchN, pred: &Predicate, logger: &mut String| {
                     if branch.to_get.is_empty() {
                         log!(logger, "Native reporting solution with inbox {:#?}", &branch.gotten);
                         solution_storage.submit_and_digest_subtree_solution(
                             logger,
                             SubtreeId::PolyN,
                             pred.clone(),
                         );
+                    }
                 };
             log!(
                 logger,
                 "Feeding msg {:?} {:?} to native branch with pred {:?}. Predicate case {:?}",
                 &payload_predicate,
                 &payload,
                 &old_predicate,
                 &case
             );
             match case {
                 Csr::Nonexistant => { /* skip branch */ }
                 Csr::LatterNotFormer | Csr::Equivalent => {
                     // Feed the message to this branch in-place. no need to modify pred.
                     if branch.to_get.remove(&port) {
                         branch.gotten.insert(port, payload.clone());
                         report_if_solution(&branch, &old_predicate, logger);
+                    }
+                }
                 Csr::FormerNotLatter => {
                     // create a new branch with the payload_predicate.
                     let mut forked = branch.clone();
                     if forked.to_get.remove(&port) {
                         forked.gotten.insert(port, payload.clone());
                         report_if_solution(&forked, &payload_predicate, logger);
                         branches2.insert(payload_predicate.clone(), forked);
+                    }
+                }
                 Csr::New(new) => {
                     // create a new branch with the newly-created predicate
                     let mut forked = branch.clone();
                     if forked.to_get.remove(&port) {
                         forked.gotten.insert(port, payload.clone());
                         report_if_solution(&forked, &new, logger);
                         branches2.insert(new.clone(), forked);
+                    }
+                }
+            }
             // unlike PolyP machines, Native branches do NOT become inconsistent
             branches2.insert(old_predicate, branch);
+        }
         log!(logger, "Native now has branches {:#?}", &branches2);
         std::mem::swap(&mut branches2, &mut self.branches);
+    }
     pub fn choose_mono(&self, decision: &Predicate) -> Option<MonoN> {
         self.branches
             .iter()
             .find(|(p, branch)| branch.to_get.is_empty() && decision.satisfies(p))
             .map(|(_, branch)| {
                 let BranchN { gotten, sync_batch_index, .. } = branch.clone();
                 MonoN { ports: self.ports.clone(), result: Some((sync_batch_index, gotten)) }
             })
+    }
+}

src/runtime/communication.rs

➞

Show inline comments

 use crate::common::*;
 use crate::runtime::{actors::*, endpoint::*, errors::*, *};
 impl Controller {
     fn end_round_with_decision(&mut self, decision: Decision) -> Result<(), SyncErr> {
         log!(&mut self.inner.logger, "ENDING ROUND WITH DECISION! {:?}", &decision);
         let ret = match &decision {
             Decision::Success(predicate) => {
                 // overwrite MonoN/P
                 self.inner.mono_n = {
                     let poly_n = self.ephemeral.poly_n.take().unwrap();
                     poly_n.choose_mono(predicate).unwrap_or_else(|| {
                         panic!(
                             "Ending round with decision pred {:#?} but poly_n has branches {:#?}. My log is... {}",
                             &predicate, &poly_n.branches, &self.inner.logger
                         );
                     })
                 };
                 self.inner.mono_ps.clear();
                 self.inner.mono_ps.extend(
                     self.ephemeral
                         .poly_ps
                         .drain(..)
                         .map(|poly_p| poly_p.choose_mono(predicate).unwrap()),
                 );
                 Ok(())
+            }
             Decision::Failure => Err(SyncErr::Timeout),
         };
         let announcement = CommMsgContents::Announce { decision }.into_msg(self.inner.round_index);
         for &child_port in self.inner.family.children_ports.iter() {
             log!(
                 &mut self.inner.logger,
                 "Forwarding {:?} to child with port {:?}",
                 &announcement,
                 child_port
             );
             self.inner
                 .endpoint_exts
                 .get_mut(child_port)
                 .expect("eefef")
                 .endpoint
                 .send(announcement.clone())?;
+        }
         self.inner.round_index += 1;
         self.ephemeral.clear();
         ret
+    }
     // Drain self.ephemeral.solution_storage and handle the new locals. Return decision if one is found
     fn handle_locals_maybe_decide(&mut self) -> Result<bool, SyncErr> {
         if let Some(parent_port) = self.inner.family.parent_port {
             // I have a parent -> I'm not the leader
             let parent_endpoint =
                 &mut self.inner.endpoint_exts.get_mut(parent_port).expect("huu").endpoint;
             for partial_oracle in self.ephemeral.solution_storage.iter_new_local_make_old() {
                 let msg =
                     CommMsgContents::Elaborate { partial_oracle }.into_msg(self.inner.round_index);
                 log!(&mut self.inner.logger, "Sending {:?} to parent {:?}", &msg, parent_port);
                 parent_endpoint.send(msg)?;
+            }
             Ok(false)
         } else {
             // I have no parent -> I'm the leader
             assert!(self.inner.family.parent_port.is_none());
             let maybe_predicate = self.ephemeral.solution_storage.iter_new_local_make_old().next();
             Ok(if let Some(predicate) = maybe_predicate {
                 let decision = Decision::Success(predicate);
                 log!(&mut self.inner.logger, "DECIDE ON {:?} AS LEADER!", &decision);
                 self.end_round_with_decision(decision)?;
                 true
             } else {
                 false
             })
+        }
+    }
     fn kick_off_native(
         &mut self,
         sync_batches: impl Iterator<Item = SyncBatch>,
     ) -> Result<PolyN, EndpointErr> {
         let MonoN { ports, .. } = self.inner.mono_n.clone();
         let Self { inner: ControllerInner { endpoint_exts, round_index, .. }, .. } = self;
         let mut branches = HashMap::<_, _>::default();
         for (sync_batch_index, SyncBatch { puts, gets }) in sync_batches.enumerate() {
             let port_to_channel_id = |port| endpoint_exts.get(port).unwrap().info.channel_id;
             let all_ports = ports.iter().copied();
             let all_channel_ids = all_ports.map(port_to_channel_id);
             let mut predicate = Predicate::new_trivial();
             // assign TRUE for puts and gets
             let true_ports = puts.keys().chain(gets.iter()).copied();
             let true_channel_ids = true_ports.clone().map(port_to_channel_id);
             predicate.batch_assign_nones(true_channel_ids, true);
             // assign FALSE for all in interface not assigned true
             predicate.batch_assign_nones(all_channel_ids.clone(), false);
             if branches.contains_key(&predicate) {
                 // TODO what do I do with redundant predicates?
                 unimplemented!(
                     "Duplicate predicate {:#?}!\nHaving multiple batches with the same
                     predicate requires the support of oracle boolean variables",
                     &predicate,
+                )
+            }
             let branch = BranchN { to_get: gets, gotten: Default::default(), sync_batch_index };
             for (port, payload) in puts {
                 log!(
                     &mut self.inner.logger,
                     "... ... Initial native put msg {:?} pred {:?} batch {:?}",
                     &payload,
                     &predicate,
                     sync_batch_index,
                 );
                 let msg =
                     CommMsgContents::SendPayload { payload_predicate: predicate.clone(), payload }
                         .into_msg(*round_index);
                 endpoint_exts.get_mut(port).unwrap().endpoint.send(msg)?;
+            }
             log!(
                 &mut self.inner.logger,
                 "... Initial native branch batch index={} with pred {:?}",
                 sync_batch_index,
                 &predicate
             );
             if branch.to_get.is_empty() {
                 self.ephemeral.solution_storage.submit_and_digest_subtree_solution(
                     &mut self.inner.logger,
                     SubtreeId::PolyN,
                     predicate.clone(),
                 );
+            }
             branches.insert(predicate, branch);
+        }
         Ok(PolyN { ports, branches })
+    }
     pub fn sync_round(
         &mut self,
         deadline: Option<Instant>,
         sync_batches: Option<impl Iterator<Item = SyncBatch>>,
     ) -> Result<(), SyncErr> {
         if let Some(e) = self.unrecoverable_error {
             return Err(e.clone());
+        }
         self.sync_round_inner(deadline, sync_batches).map_err(move |e| match e {
             SyncErr::Timeout => e, // this isn't unrecoverable
             _ => {
                 // Must set unrecoverable error! and tear down our net channels
                 self.unrecoverable_error = Some(e);
                 self.ephemeral.clear();
                 self.inner.endpoint_exts = Default::default();
+                e
+            }
         })
+    }
     // Runs a synchronous round until all the actors are in decided state OR 1+ are inconsistent.
     // If a native requires setting up, arg `sync_batches` is Some, and those are used as the sync batches.
     fn sync_round_inner(
         &mut self,
         mut deadline: Option<Instant>,
         sync_batches: Option<impl Iterator<Item = SyncBatch>>,
     ) -> Result<(), SyncErr> {
         log!(
             &mut self.inner.logger,
             "~~~~~~~~ SYNC ROUND STARTS! ROUND={} ~~~~~~~~~",
             self.inner.round_index
         );
         assert!(self.ephemeral.is_clear());
         assert!(self.unrecoverable_error.is_none());
         // 1. Run the Mono for each Mono actor (stored in `self.mono_ps`).
         //    Some actors are dropped. some new actors are created.
         //    Ultimately, we have 0 Mono actors and a list of unnamed sync_actors
         self.ephemeral.mono_ps.extend(self.inner.mono_ps.iter().cloned());
         log!(&mut self.inner.logger, "Got {} MonoP's to run!", self.ephemeral.mono_ps.len());
         while let Some(mut mono_p) = self.ephemeral.mono_ps.pop() {
             let mut m_ctx = MonoPContext {
                 ports: &mut mono_p.ports,
                 mono_ps: &mut self.ephemeral.mono_ps,
                 inner: &mut self.inner,
             };
             // cross boundary into crate::protocol
             let blocker = mono_p.state.pre_sync_run(&mut m_ctx, &self.protocol_description);
             log!(&mut self.inner.logger, "... MonoP's pre_sync_run got blocker {:?}", &blocker);
             match blocker {
                 MonoBlocker::Inconsistent => return Err(SyncErr::Inconsistent),
                 MonoBlocker::ComponentExit => drop(mono_p),
                 MonoBlocker::SyncBlockStart => self.ephemeral.poly_ps.push(mono_p.into()),
+            }
+        }
         log!(
             &mut self.inner.logger,
             "Finished running all MonoPs! Have {} PolyPs waiting",
             self.ephemeral.poly_ps.len()
         );
         // 3. define the mapping from port -> actor
         //    this is needed during the event loop to determine which actor
         //    should receive the incoming message.
         //    TODO: store and update this mapping rather than rebuilding it each round.
-        let port_to_holder: HashMap<Port, PolyId> = {
+        let port_to_holder: HashMap<PortId, PolyId> = {
             use PolyId::*;
             let n = self.inner.mono_n.ports.iter().map(move |&e| (e, N));
             let p = self
                 .ephemeral
                 .poly_ps
                 .iter()
                 .enumerate()
                 .flat_map(|(index, m)| m.ports.iter().map(move |&e| (e, P { index })));
             n.chain(p).collect()
         };
         log!(
             &mut self.inner.logger,
             "SET OF PolyPs and MonoPs final! port lookup map is {:?}",
             &port_to_holder
         );
         // 4. Create the solution storage. it tracks the solutions of "subtrees"
         //    of the controller in the overlay tree.
         self.ephemeral.solution_storage.reset({
             let n = std::iter::once(SubtreeId::PolyN);
             let m = (0..self.ephemeral.poly_ps.len()).map(|index| SubtreeId::PolyP { index });
             let c = self
                 .inner
                 .family
                 .children_ports
                 .iter()
                 .map(|&port| SubtreeId::ChildController { port });
             let subtree_id_iter = n.chain(m).chain(c);
             log!(
                 &mut self.inner.logger,
                 "Solution Storage has subtree Ids: {:?}",
                 &subtree_id_iter.clone().collect::<Vec<_>>()
             );
             subtree_id_iter
         });
         // 5. kick off the synchronous round of the native actor if it exists
         log!(&mut self.inner.logger, "Kicking off native's synchronous round...");
         self.ephemeral.poly_n = if let Some(sync_batches) = sync_batches {
             // using if let because of nested ? operator
             // TODO check that there are 1+ branches or NO SOLUTION
             let poly_n = self.kick_off_native(sync_batches)?;
             log!(
                 &mut self.inner.logger,
                 "PolyN kicked off, and has branches with predicates... {:?}",
                 poly_n.branches.keys().collect::<Vec<_>>()
             );
             Some(poly_n)
         } else {
             log!(&mut self.inner.logger, "NO NATIVE COMPONENT");
             None
         };
         // 6. Kick off the synchronous round of each protocol actor
         //    If just one actor becomes inconsistent now, there can be no solution!
         //    TODO distinguish between completed and not completed poly_p's?
         log!(&mut self.inner.logger, "Kicking off {} PolyP's.", self.ephemeral.poly_ps.len());
         for (index, poly_p) in self.ephemeral.poly_ps.iter_mut().enumerate() {
             let my_subtree_id = SubtreeId::PolyP { index };
             let m_ctx = PolyPContext {
                 my_subtree_id,
                 inner: &mut self.inner,
                 solution_storage: &mut self.ephemeral.solution_storage,
             };
             use SyncRunResult as Srr;
             let blocker = poly_p.poly_run(m_ctx, &self.protocol_description)?;
             log!(&mut self.inner.logger, "... PolyP's poly_run got blocker {:?}", &blocker);
             match blocker {
                 Srr::NoBranches => return Err(SyncErr::Inconsistent),
                 Srr::AllBranchesComplete | Srr::BlockingForRecv => (),
+            }
+        }
         log!(&mut self.inner.logger, "All Poly machines have been kicked off!");
         // 7. `solution_storage` may have new solutions for this controller
         //    handle their discovery. LEADER => announce, otherwise => send to parent
+        {
             let peeked = self.ephemeral.solution_storage.peek_new_locals().collect::<Vec<_>>();
             log!(
                 &mut self.inner.logger,
                 "Got {} controller-local solutions before a single RECV: {:?}",
                 peeked.len(),
                 peeked
             );
+        }
         if self.handle_locals_maybe_decide()? {
             return Ok(());
+        }
         // 4. Receive incoming messages until the DECISION is made OR some unrecoverable error
         log!(&mut self.inner.logger, "`No decision yet`. Time to recv messages");
         self.undelay_all();
         'recv_loop: loop {
             log!(&mut self.inner.logger, "`POLLING` with deadline {:?}...", deadline);
             let received = match deadline {
                 None => {
                     // we have personally timed out. perform a "long" poll.
                     self.recv(Instant::now() + Duration::from_secs(10))?.expect("DRIED UP")
+                }
                 Some(d) => match self.recv(d)? {
                     // we have not yet timed out. performed a time-limited poll
                     Some(received) => received,
                     None => {
                         // timed out! send a FAILURE message to the sink,
                         // and henceforth don't time out on polling.
                         deadline = None;
                         match self.inner.family.parent_port {
                             None => {
                                 // I am the sink! announce failure and return.
                                 return self.end_round_with_decision(Decision::Failure);
+                            }
                             Some(parent_port) => {
                                 // I am not the sink! send a failure message.
                                 let announcement = Msg::CommMsg(CommMsg {
                                     round_index: self.inner.round_index,
                                     contents: CommMsgContents::Failure,
                                 });
                                 log!(
                                     &mut self.inner.logger,
                                     "Forwarding {:?} to parent with port {:?}",
                                     &announcement,
                                     parent_port
                                 );
                                 self.inner
                                     .endpoint_exts
                                     .get_mut(parent_port)
                                     .expect("ss")
                                     .endpoint
                                     .send(announcement.clone())?;
                                 continue; // poll some more
+                            }
+                        }
+                    }
                 },
             };
             log!(&mut self.inner.logger, "::: message {:?}...", &received);
             let current_content = match received.msg {
                 Msg::SetupMsg(s) => {
                     // This occurs in the event the connector was malformed during connect()
                     println!("WASNT EXPECTING {:?}", s);
                     return Err(SyncErr::UnexpectedSetupMsg);
+                }
                 Msg::CommMsg(CommMsg { round_index, .. })
                     if round_index < self.inner.round_index =>
+                {
                     // Old message! Can safely discard
                     log!(&mut self.inner.logger, "...and its OLD! :(");
                     drop(received);
                     continue 'recv_loop;
+                }
                 Msg::CommMsg(CommMsg { round_index, .. })
                     if round_index > self.inner.round_index =>
+                {
                     // Message from a next round. Keep for later!
                     log!(&mut self.inner.logger, "... DELAY! :(");
                     self.delay(received);
                     continue 'recv_loop;
+                }
                 Msg::CommMsg(CommMsg { contents, round_index }) => {
                     log!(
                         &mut self.inner.logger,
                         "... its a round-appropriate CommMsg with port {:?}",
                         received.recipient
                     );
                     assert_eq!(round_index, self.inner.round_index);
                     contents
+                }
             };
             match current_content {
                 CommMsgContents::Failure => match self.inner.family.parent_port {
                     Some(parent_port) => {
                         let announcement = Msg::CommMsg(CommMsg {
                             round_index: self.inner.round_index,
                             contents: CommMsgContents::Failure,
                         });
                         log!(
                             &mut self.inner.logger,
                             "Forwarding {:?} to parent with port {:?}",
                             &announcement,
                             parent_port
                         );
                         self.inner
                             .endpoint_exts
                             .get_mut(parent_port)
                             .expect("ss")
                             .endpoint
                             .send(announcement.clone())?;
+                    }
                     None => return self.end_round_with_decision(Decision::Failure),
                 },
                 CommMsgContents::Elaborate { partial_oracle } => {
                     // Child controller submitted a subtree solution.
                     if !self.inner.family.children_ports.contains(&received.recipient) {
                         return Err(SyncErr::ElaborateFromNonChild);
+                    }
                     let subtree_id = SubtreeId::ChildController { port: received.recipient };
                     log!(
                         &mut self.inner.logger,
                         "Received elaboration from child for subtree {:?}: {:?}",
                         subtree_id,
                         &partial_oracle
                     );
                     self.ephemeral.solution_storage.submit_and_digest_subtree_solution(
                         &mut self.inner.logger,
                         subtree_id,
                         partial_oracle,
                     );
                     if self.handle_locals_maybe_decide()? {
                         return Ok(());
+                    }
+                }
                 CommMsgContents::Announce { decision } => {
                     if self.inner.family.parent_port != Some(received.recipient) {
                         return Err(SyncErr::AnnounceFromNonParent);
+                    }
                     log!(
                         &mut self.inner.logger,
                         "Received ANNOUNCEMENT from from parent {:?}: {:?}",
                         received.recipient,
                         &decision
                     );
                     return self.end_round_with_decision(decision);
+                }
                 CommMsgContents::SendPayload { payload_predicate, payload } => {
                     // check that we expect to be able to receive payloads from this sender
                     assert_eq!(
                         Getter,
                         self.inner.endpoint_exts.get(received.recipient).unwrap().info.polarity
                     );
                     // message for some actor. Feed it to the appropriate actor
                     // and then give them another chance to run.
                     let subtree_id = port_to_holder.get(&received.recipient);
                     log!(
                         &mut self.inner.logger,
                         "Received SendPayload for subtree {:?} with pred {:?} and payload {:?}",
                         subtree_id,
                         &payload_predicate,
                         &payload
                     );
                     let channel_id = self
                         .inner
                         .endpoint_exts
                         .get(received.recipient)
                         .expect("UEHFU")
                         .info
                         .channel_id;
                     if payload_predicate.query(channel_id) != Some(true) {
                         // sender didn't preserve the invariant
                         return Err(SyncErr::PayloadPremiseExcludesTheChannel(channel_id));
+                    }
                     match subtree_id {
                         None => {
                             // this happens when a message is sent to a component that has exited.
                             // It's safe to drop this message;
                             // The sender branch will certainly not be part of the solution
+                        }
                         Some(PolyId::N) => {
                             // Message for NativeMachine
                             self.ephemeral.poly_n.as_mut().unwrap().sync_recv(
                                 received.recipient,
                                 &mut self.inner.logger,
                                 payload,
                                 payload_predicate,
                                 &mut self.ephemeral.solution_storage,
                             );
                             if self.handle_locals_maybe_decide()? {
                                 return Ok(());
+                            }
+                        }
                         Some(PolyId::P { index }) => {
                             // Message for protocol actor
                             let poly_p = &mut self.ephemeral.poly_ps[*index];
                             let m_ctx = PolyPContext {
                                 my_subtree_id: SubtreeId::PolyP { index: *index },
                                 inner: &mut self.inner,
                                 solution_storage: &mut self.ephemeral.solution_storage,
                             };
                             use SyncRunResult as Srr;
                             let blocker = poly_p.poly_recv_run(
                                 m_ctx,
                                 &self.protocol_description,
                                 received.recipient,
                                 payload_predicate,
                                 payload,
                             )?;
                             log!(
                                 &mut self.inner.logger,
                                 "... Fed the msg to PolyP {:?} and ran it to blocker {:?}",
                                 subtree_id,
                                 blocker
                             );
                             match blocker {
                                 Srr::NoBranches => return Err(SyncErr::Inconsistent),
                                 Srr::BlockingForRecv | Srr::AllBranchesComplete => {
+                                    {
                                         let peeked = self
                                             .ephemeral
                                             .solution_storage
                                             .peek_new_locals()
                                             .collect::<Vec<_>>();
                                         log!(
                                             &mut self.inner.logger,
                                             "Got {} new controller-local solutions from RECV: {:?}",
                                             peeked.len(),
                                             peeked
                                         );
+                                    }
                                     if self.handle_locals_maybe_decide()? {
                                         return Ok(());
+                                    }
+                                }
+                            }
+                        }
                     };
+                }
+            }
+        }
+    }
+}
 impl ControllerEphemeral {
     fn is_clear(&self) -> bool {
         self.solution_storage.is_clear()
             && self.poly_n.is_none()
             && self.poly_ps.is_empty()
             && self.mono_ps.is_empty()
             && self.port_to_holder.is_empty()
+    }
     fn clear(&mut self) {
         self.solution_storage.clear();
         self.poly_n.take();
         self.poly_ps.clear();
         self.port_to_holder.clear();
+    }
+}
 impl Into<PolyP> for MonoP {
     fn into(self) -> PolyP {
         PolyP {
             complete: Default::default(),
             incomplete: hashmap! {
                 Predicate::new_trivial() =>
                 BranchP {
                     state: self.state,
                     inbox: Default::default(),
                     outbox: Default::default(),
                     blocking_on: None,
+                }
             },
             ports: self.ports,
+        }
+    }
+}
 impl From<EndpointErr> for SyncErr {
     fn from(e: EndpointErr) -> SyncErr {
         SyncErr::EndpointErr(e)
+    }
+}
 impl MonoContext for MonoPContext<'_> {
     type D = ProtocolD;
     type S = ProtocolS;
-    fn new_component(&mut self, moved_ports: HashSet<Port>, init_state: Self::S) {
+    fn new_component(&mut self, moved_ports: HashSet<PortId>, init_state: Self::S) {
         log!(
             &mut self.inner.logger,
             "!! MonoContext callback to new_component with ports {:?}!",
             &moved_ports,
         );
         if moved_ports.is_subset(self.ports) {
             self.ports.retain(|x| !moved_ports.contains(x));
             self.mono_ps.push(MonoP { state: init_state, ports: moved_ports });
         } else {
             panic!("MachineP attempting to move alien port!");
+        }
+    }
-    fn new_channel(&mut self) -> [Port; 2] {
+    fn new_channel(&mut self) -> [PortId; 2] {
         let [a, b] = Endpoint::new_memory_pair();
         let channel_id = self.inner.channel_id_stream.next();
         let mut clos = |endpoint, polarity| {
             let endpoint_ext =
                 EndpointExt { info: EndpointInfo { polarity, channel_id }, endpoint };
             let port = self.inner.endpoint_exts.alloc(endpoint_ext);
             let endpoint = &self.inner.endpoint_exts.get(port).unwrap().endpoint;
-            let token = Port::to_token(port);
+            let token = PortId::to_token(port);
             self.inner
                 .messenger_state
                 .poll
                 .register(endpoint, token, Ready::readable(), PollOpt::edge())
                 .expect("AAGAGGGGG");
             self.ports.insert(port);
             port
         };
         let [kp, kg] = [clos(a, Putter), clos(b, Getter)];
         log!(
             &mut self.inner.logger,
             "!! MonoContext callback to new_channel. returning ports {:?}!",
             [kp, kg],
         );
         [kp, kg]
+    }
     fn new_random(&mut self) -> u64 {
         type Bytes8 = [u8; std::mem::size_of::<u64>()];
         let mut bytes = Bytes8::default();
         getrandom::getrandom(&mut bytes).unwrap();
         let val = unsafe { std::mem::transmute::<Bytes8, _>(bytes) };
         log!(
             &mut self.inner.logger,
             "!! MonoContext callback to new_random. returning val {:?}!",
             val,
         );
         val
+    }
+}
 impl SolutionStorage {
     fn is_clear(&self) -> bool {
         self.subtree_id_to_index.is_empty()
             && self.subtree_solutions.is_empty()
             && self.old_local.is_empty()
             && self.new_local.is_empty()
+    }
     fn clear(&mut self) {
         self.subtree_id_to_index.clear();
         self.subtree_solutions.clear();
         self.old_local.clear();
         self.new_local.clear();
+    }
     pub(crate) fn reset(&mut self, subtree_ids: impl Iterator<Item = SubtreeId>) {
         self.subtree_id_to_index.clear();
         self.subtree_solutions.clear();
         self.old_local.clear();
         self.new_local.clear();
         for key in subtree_ids {
             self.subtree_id_to_index.insert(key, self.subtree_solutions.len());
             self.subtree_solutions.push(Default::default())
+        }
+    }
     pub(crate) fn peek_new_locals(&self) -> impl Iterator<Item = &Predicate> + '_ {
         self.new_local.iter()
+    }
     pub(crate) fn iter_new_local_make_old(&mut self) -> impl Iterator<Item = Predicate> + '_ {
         let Self { old_local, new_local, .. } = self;
         new_local.drain().map(move |local| {
             old_local.insert(local.clone());
             local
         })
+    }
     pub(crate) fn submit_and_digest_subtree_solution(
         &mut self,
         logger: &mut String,
         subtree_id: SubtreeId,
         predicate: Predicate,
     ) {
         log!(logger, "NEW COMPONENT SOLUTION {:?} {:?}", subtree_id, &predicate);
         let index = self.subtree_id_to_index[&subtree_id];
         let left = 0..index;
         let right = (index + 1)..self.subtree_solutions.len();
         let Self { subtree_solutions, new_local, old_local, .. } = self;
         let was_new = subtree_solutions[index].insert(predicate.clone());
         if was_new {
             let set_visitor = left.chain(right).map(|index| &subtree_solutions[index]);
             Self::elaborate_into_new_local_rec(
                 logger,
                 predicate,
                 set_visitor,
                 old_local,
                 new_local,
             );
+        }
+    }
     fn elaborate_into_new_local_rec<'a, 'b>(
         logger: &mut String,
         partial: Predicate,
         mut set_visitor: impl Iterator<Item = &'b HashSet<Predicate>> + Clone,
         old_local: &'b HashSet<Predicate>,
         new_local: &'a mut HashSet<Predicate>,
     ) {
         if let Some(set) = set_visitor.next() {
             // incomplete solution. keep traversing
             for pred in set.iter() {
                 if let Some(elaborated) = pred.union_with(&partial) {
                     Self::elaborate_into_new_local_rec(
                         logger,
                         elaborated,
                         set_visitor.clone(),
                         old_local,
                         new_local,
+                    )
+                }
+            }
         } else {
             // recursive stop condition. `partial` is a local subtree solution
             if !old_local.contains(&partial) {
                 // ... and it hasn't been found before
                 log!(logger, "... storing NEW LOCAL SOLUTION {:?}", &partial);
                 new_local.insert(partial);
+            }
+        }
+    }
+}
 impl PolyContext for BranchPContext<'_, '_> {
     type D = ProtocolD;
-    fn is_firing(&mut self, port: Port) -> Option<bool> {
+    fn is_firing(&mut self, port: PortId) -> Option<bool> {
         assert!(self.ports.contains(&port));
         let channel_id = self.m_ctx.inner.endpoint_exts.get(port).unwrap().info.channel_id;
         let val = self.predicate.query(channel_id);
         log!(
             &mut self.m_ctx.inner.logger,
             "!! PolyContext callback to is_firing by {:?}! returning {:?}",
             self.m_ctx.my_subtree_id,
             val,
         );
         val
+    }
-    fn read_msg(&mut self, port: Port) -> Option<&Payload> {
+    fn read_msg(&mut self, port: PortId) -> Option<&Payload> {
         assert!(self.ports.contains(&port));
         let val = self.inbox.get(&port);
         log!(
             &mut self.m_ctx.inner.logger,
             "!! PolyContext callback to read_msg by {:?}! returning {:?}",
             self.m_ctx.my_subtree_id,
             val,
         );
         val
+    }
+}

src/runtime/errors.rs

➞

Show inline comments

 use crate::common::*;
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum PortBindErr {
     AlreadyConnected,
     IndexOutOfBounds,
     NotConfigured,
     ParseErr,
     AlreadyConfigured,
+}
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum ReadGottenErr {
     NotConnected,
     IndexOutOfBounds,
     WrongPolarity,
     NoPreviousRound,
     DidNotGet,
+}
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum PortOpErr {
     IndexOutOfBounds,
     NotConnected,
     WrongPolarity,
     DuplicateOperation,
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ConfigErr {
     AlreadyConnected,
     ParseErr(String),
     AlreadyConfigured,
     NoSuchComponent,
     NonPortTypeParameters,
+}
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum ConnectErr {
     PortNotBound { native_index: usize },
     NotConfigured,
     AlreadyConnected,
     MetaProtocolDeviation,
     Disconnected,
     PollInitFailed,
     MessengerRecvErr(MessengerRecvErr),
     Timeout,
     PollingFailed,
     PolarityMatched(SocketAddr),
     AcceptFailed(SocketAddr),
     PassiveConnectFailed(SocketAddr),
     BindFailed(SocketAddr),
+}
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum PollDeadlineErr {
     PollingFailed,
     Timeout,
+}
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum EndpointErr {
     Disconnected,
     MetaProtocolDeviation,
+}
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum SyncErr {
     NotConnected,
     MessengerRecvErr(MessengerRecvErr),
     Inconsistent,
     Timeout,
     ElaborateFromNonChild,
     AnnounceFromNonParent,
     PayloadPremiseExcludesTheChannel(ChannelId),
     UnexpectedSetupMsg,
     EndpointErr(EndpointErr),
     EvalErr(EvalErr),
+}
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum EvalErr {
     ComponentExitWhileBranching,
+}
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum MessengerRecvErr {
     PollingFailed,
-    EndpointErr(Port, EndpointErr),
+    EndpointErr(PortId, EndpointErr),
+}
 impl From<MainComponentErr> for ConfigErr {
     fn from(e: MainComponentErr) -> Self {
         use ConfigErr as C;
         use MainComponentErr as M;
         match e {
             M::NoSuchComponent => C::NoSuchComponent,
             M::NonPortTypeParameters => C::NonPortTypeParameters,
             _ => todo!(),
+        }
+    }
+}

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

0 comments (0 inline, 0 general)