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

Changeset - 8da6a7632169

Parent rev.

Child rev.

[Not reviewed]

0 6 0

MH - 4 years ago 2021-03-28 12:31:53
contact@maxhenger.nl

added a test, pending bugfix

6 files changed with 343 insertions and 24 deletions:

src/protocol/inputsource.rs

src/protocol/parser/type_resolver.rs

src/protocol/tests/mod.rs

src/protocol/tests/parser_inference.rs

158

src/protocol/tests/parser_validation.rs

src/protocol/tests/utils.rs

164

0 comments (0 inline, 0 general)

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(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct InputSource {
     pub(crate) filename: String,
     pub(crate) input: Vec<u8>,
     line: usize,
     column: usize,
     offset: usize,
+}
 static STD_LIB_PDL: &'static [u8] = b"
 primitive forward(in<msg> i, out<msg> o) {
     while(true) synchronous put(o, get(i));
+}
 primitive sync(in<msg> i, out<msg> o) {
     while(true) synchronous if(fires(i)) put(o, get(i));
+}
 primitive alternator(in<msg> i, out<msg> l, out<msg> r) {
     while(true) {
         synchronous if(fires(i)) put(l, get(i));
         synchronous if(fires(i)) put(r, get(i));
+    }
+}
 primitive replicator(in<msg> i, out<msg> l, out<msg> r) {
     while(true) synchronous {
         if(fires(i)) {
             msg m = get(i);
             put(l, m);
             put(r, m);
+        }
+    }
+}
 primitive merger(in<msg> l, in<msg> r, out<msg> o) {
     while(true) synchronous {
         if(fires(l))      put(o, get(l));
         else if(fires(r)) 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 = Vec::new();
         reader.read_to_end(&mut vec)?;
         vec.extend(STD_LIB_PDL.to_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 seek(&mut self, pos: InputPosition) {
         debug_assert!(pos.offset < self.input.len());
         self.line = pos.line;
         self.column = pos.column;
         self.offset = pos.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> {
         let offset_pos = self.offset + pos;
         if offset_pos < self.input.len() {
             Some(self.input[offset_pos])
         } else {
             None
+        }
+    }
     pub fn has(&self, to_compare: &[u8]) -> bool {
         if self.offset + to_compare.len() <= self.input.len() {
             for idx in 0..to_compare.len() {
                 if to_compare[idx] != self.input[self.offset + idx] {
                     return false;
+                }
+            }
             true
         } else {
             false
+        }
+    }
     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, serde::Serialize, serde::Deserialize)]
 pub struct InputPosition {
     line: usize,
     column: usize,
     offset: usize,
+    pub(crate) 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() }
+    }
     pub(crate) fn col(&self) -> usize { self.column }
+}
 impl Default for InputPosition {
     fn default() -> Self {
         Self{ line: 1, column: 1, offset: 0 }
+    }
+}
 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)]
 pub enum ParseErrorType {
     Info,
     Error
+}
 #[derive(Debug)]
 pub struct ParseErrorStatement {
     pub(crate) error_type: ParseErrorType,
     pub(crate) position: InputPosition,
     pub(crate) filename: String,
     pub(crate) context: String,
     pub(crate) message: String,
+}
 impl ParseErrorStatement {
     fn from_source(error_type: ParseErrorType, source: &InputSource, position: InputPosition, msg: &str) -> Self {
         // Seek line start and end
         let line_start = position.offset - (position.column - 1);
         let mut line_end = position.offset;
         while line_end < source.input.len() && source.input[line_end] != b'\n' {
             line_end += 1;
+        }
         // Compensate for '\r\n'
         if line_end > line_start && source.input[line_end - 1] == b'\r' {
             line_end -= 1;
+        }
         Self{
             error_type,
             position,
             filename: source.filename.clone(),
             context: String::from_utf8_lossy(&source.input[line_start..line_end]).to_string(),
             message: msg.to_string()
+        }
+    }
+}
 impl fmt::Display for ParseErrorStatement {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Write message
         match self.error_type {
             ParseErrorType::Info => write!(f, " INFO: ")?,
             ParseErrorType::Error => write!(f, "ERROR: ")?,
+        }
         writeln!(f, "{}", &self.message)?;
         // Write originating file/line/column
         if self.filename.is_empty() {
             writeln!(f, " +- at {}:{}", self.position.line, self.position.column)?;
         } else {
             writeln!(f, " +- at {}:{}:{}", self.filename, self.position.line, self.position.column)?;
+        }
         // Write source context
         writeln!(f, " | ")?;
         writeln!(f, " | {}", self.context)?;
         // Write underline indicating where the error ocurred
         debug_assert!(self.position.column <= self.context.chars().count());
         let mut arrow = String::with_capacity(self.context.len() + 3);
         arrow.push_str(" | ");
         let mut char_col = 1;
         for char in self.context.chars() {
             if char_col == self.position.column { break; }
             if char == '\t' {
                 arrow.push('\t');
             } else {
                 arrow.push(' ');
+            }
             char_col += 1;
+        }
         arrow.push('^');
         writeln!(f, "{}", arrow)?;
         Ok(())
+    }
+}
 #[derive(Debug)]
 pub struct ParseError2 {
     pub(crate) statements: Vec<ParseErrorStatement>
+}
 impl fmt::Display for ParseError2 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if self.statements.is_empty() {
             return Ok(())
+        }
         self.statements[0].fmt(f)?;
         for statement in self.statements.iter().skip(1) {
             writeln!(f)?;
             statement.fmt(f)?;
+        }
         Ok(())
+    }
+}
 impl ParseError2 {
     pub fn empty() -> Self {
         Self{ statements: Vec::new() }
+    }
     pub fn new_error(source: &InputSource, position: InputPosition, msg: &str) -> Self {
         Self{ statements: vec!(ParseErrorStatement::from_source(ParseErrorType::Error, source, position, msg))}
+    }
     pub fn with_prefixed(mut self, error_type: ParseErrorType, source: &InputSource, position: InputPosition, msg: &str) -> Self {
         self.statements.insert(0, ParseErrorStatement::from_source(error_type, source, position, msg));
         self
+    }
     pub fn with_postfixed(mut self, error_type: ParseErrorType, source: &InputSource, position: InputPosition, msg: &str) -> Self {
         self.statements.push(ParseErrorStatement::from_source(error_type, source, position, msg));
         self
+    }
     pub fn with_postfixed_info(self, source: &InputSource, position: InputPosition, msg: &str) -> Self {
         self.with_postfixed(ParseErrorType::Info, source, position, msg)
+    }
+}
 #[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::*;
 //     #[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();
 //     }
 // }

src/protocol/parser/type_resolver.rs

➞

Show inline comments

@@ @@ -274,770 +274,775 @@ impl InferenceType { @@
     // TODO: @performance, might all be done inline in the type inference methods
     fn recompute_is_done(&mut self) {
         self.is_done = self.parts.iter().all(|v| v.is_concrete());
+    }
     /// Seeks a body marker starting at the specified position. If a marker is
     /// found then its value and the index of the type subtree that follows it
     /// is returned.
     fn find_body_marker(&self, mut start_idx: usize) -> Option<(usize, usize)> {
         while start_idx < self.parts.len() {
             if let InferenceTypePart::MarkerBody(marker) = &self.parts[start_idx] {
                 return Some((*marker, start_idx + 1))
+            }
             start_idx += 1;
+        }
         None
+    }
     /// Returns an iterator over all body markers and the partial type tree that
     /// follows those markers. If it is a problem that `InferenceType` is
     /// borrowed by the iterator, then use `find_body_marker`.
     fn body_marker_iter(&self) -> InferenceTypeMarkerIter {
         InferenceTypeMarkerIter::new(&self.parts)
+    }
     /// Given that the `parts` are a depth-first serialized tree of types, this
     /// function finds the subtree anchored at a specific node. The returned
     /// index is exclusive.
     fn find_subtree_end_idx(parts: &[InferenceTypePart], start_idx: usize) -> usize {
         let mut depth = 1;
         let mut idx = start_idx;
         while idx < parts.len() {
             depth += parts[idx].depth_change();
             if depth == 0 {
                 return idx + 1;
+            }
             idx += 1;
+        }
         // If here, then the inference type is malformed
         unreachable!();
+    }
     /// Call that attempts to infer the part at `to_infer.parts[to_infer_idx]`
     /// using the subtree at `template.parts[template_idx]`. Will return
     /// `Some(depth_change_due_to_traversal)` if type inference has been
     /// applied. In this case the indices will also be modified to point to the
     /// next part in both templates. If type inference has not (or: could not)
     /// be applied then `None` will be returned. Note that this might mean that
     /// the types are incompatible.
     ///
     /// As this is a helper functions, some assumptions: the parts are not
     /// exactly equal, and neither of them contains a marker. Also: only the
     /// `to_infer` parts are checked for inference. It might be that this
     /// function returns `None`, but that that `template` is still compatible
     /// with `to_infer`, e.g. when `template` has an `Unknown` part.
     fn infer_part_for_single_type(
         to_infer: &mut InferenceType, to_infer_idx: &mut usize,
         template_parts: &[InferenceTypePart], template_idx: &mut usize,
     ) -> Option<i32> {
         use InferenceTypePart as ITP;
         let to_infer_part = &to_infer.parts[*to_infer_idx];
         let template_part = &template_parts[*template_idx];
         // TODO: Maybe do this differently?
         let mut template_definition_marker = None;
         if *template_idx > 0 {
             if let ITP::MarkerDefinition(marker) = &template_parts[*template_idx - 1] {
                 template_definition_marker = Some(*marker)
+            }
+        }
         // Check for programmer mistakes
         debug_assert_ne!(to_infer_part, template_part);
         debug_assert!(!to_infer_part.is_marker(), "marker encountered in 'infer part'");
         debug_assert!(!template_part.is_marker(), "marker encountered in 'template part'");
         // Inference of a somewhat-specified type
         if to_infer_part.may_be_inferred_from(template_part) {
             let depth_change = to_infer_part.depth_change();
             debug_assert_eq!(depth_change, template_part.depth_change());
             if let Some(marker) = template_definition_marker {
                 to_infer.parts.insert(*to_infer_idx, ITP::MarkerDefinition(marker));
                 *to_infer_idx += 1;
+            }
             to_infer.parts[*to_infer_idx] = template_part.clone();
             *to_infer_idx += 1;
             *template_idx += 1;
             return Some(depth_change);
+        }
         // Inference of a completely unknown type
         if *to_infer_part == ITP::Unknown {
             // template part is different, so cannot be unknown, hence copy the
             // entire subtree
             let template_end_idx = Self::find_subtree_end_idx(template_parts, *template_idx);
             let erase_offset = if let Some(marker) = template_definition_marker {
                 to_infer.parts[*to_infer_idx] = ITP::MarkerDefinition(marker);
                 *to_infer_idx += 1;
             } else {
             };
             to_infer.parts.splice(
                 *to_infer_idx..*to_infer_idx + erase_offset,
                 template_parts[*template_idx..template_end_idx].iter().cloned()
             );
             *to_infer_idx += template_end_idx - *template_idx;
             *template_idx = template_end_idx;
             // Note: by definition the LHS was Unknown and the RHS traversed a
             // full subtree.
             return Some(-1);
+        }
         None
+    }
     /// Call that checks if the `to_check` part is compatible with the `infer`
     /// part. This is essentially a copy of `infer_part_for_single_type`, but
     /// without actually copying the type parts.
     fn check_part_for_single_type(
         to_check_parts: &[InferenceTypePart], to_check_idx: &mut usize,
         template_parts: &[InferenceTypePart], template_idx: &mut usize
     ) -> Option<i32> {
         use InferenceTypePart as ITP;
         let to_check_part = &to_check_parts[*to_check_idx];
         let template_part = &template_parts[*template_idx];
         // Checking programmer errors
         debug_assert_ne!(to_check_part, template_part);
         debug_assert!(!to_check_part.is_marker(), "marker encountered in 'to_check part'");
         debug_assert!(!template_part.is_marker(), "marker encountered in 'template part'");
         if to_check_part.may_be_inferred_from(template_part) {
             let depth_change = to_check_part.depth_change();
             debug_assert_eq!(depth_change, template_part.depth_change());
             *to_check_idx += 1;
             *template_idx += 1;
             return Some(depth_change);
+        }
         if *to_check_part == ITP::Unknown {
             *to_check_idx += 1;
             *template_idx = Self::find_subtree_end_idx(template_parts, *template_idx);
             // By definition LHS and RHS had depth change of -1
             return Some(-1);
+        }
         None
+    }
     /// Attempts to infer types between two `InferenceType` instances. This
     /// function is unsafe as it accepts pointers to work around Rust's
     /// borrowing rules. The caller must ensure that the pointers are distinct.
     unsafe fn infer_subtrees_for_both_types(
         type_a: *mut InferenceType, start_idx_a: usize,
         type_b: *mut InferenceType, start_idx_b: usize
     ) -> DualInferenceResult {
         debug_assert!(!std::ptr::eq(type_a, type_b), "encountered pointers to the same inference type");
         let type_a = &mut *type_a;
         let type_b = &mut *type_b;
         let mut modified_a = false;
         let mut modified_b = false;
         let mut idx_a = start_idx_a;
         let mut idx_b = start_idx_b;
         let mut depth = 1;
         while depth > 0 {
             // Advance indices if we encounter markers or equal parts
             let part_a = &type_a.parts[idx_a];
             let part_b = &type_b.parts[idx_b];
             if part_a == part_b {
                 let depth_change = part_a.depth_change();
                 depth += depth_change;
                 debug_assert_eq!(depth_change, part_b.depth_change());
                 idx_a += 1;
                 idx_b += 1;
                 continue;
+            }
             if part_a.is_marker() { idx_a += 1; continue; }
             if part_b.is_marker() { idx_b += 1; continue; }
             // Types are not equal and are both not markers
             if let Some(depth_change) = Self::infer_part_for_single_type(type_a, &mut idx_a, &type_b.parts, &mut idx_b) {
                 depth += depth_change;
                 modified_a = true;
                 continue;
+            }
             if let Some(depth_change) = Self::infer_part_for_single_type(type_b, &mut idx_b, &type_a.parts, &mut idx_a) {
                 depth += depth_change;
                 modified_b = true;
                 continue;
+            }
             // And can also not be inferred in any way: types must be incompatible
             return DualInferenceResult::Incompatible;
+        }
         if modified_a { type_a.recompute_is_done(); }
         if modified_b { type_b.recompute_is_done(); }
         // If here then we completely inferred the subtrees.
         match (modified_a, modified_b) {
             (false, false) => DualInferenceResult::Neither,
             (false, true) => DualInferenceResult::Second,
             (true, false) => DualInferenceResult::First,
             (true, true) => DualInferenceResult::Both
+        }
+    }
     /// Attempts to infer the first subtree based on the template. Like
     /// `infer_subtrees_for_both_types`, but now only applying inference to
     /// `to_infer` based on the type information in `template`.
     /// Secondary use is to make sure that a type follows a certain template.
     fn infer_subtree_for_single_type(
         to_infer: &mut InferenceType, mut to_infer_idx: usize,
         template: &[InferenceTypePart], mut template_idx: usize,
     ) -> SingleInferenceResult {
         let mut modified = false;
         let mut depth = 1;
         while depth > 0 {
             let to_infer_part = &to_infer.parts[to_infer_idx];
             let template_part = &template[template_idx];
             if to_infer_part == template_part {
                 let depth_change = to_infer_part.depth_change();
                 depth += depth_change;
                 debug_assert_eq!(depth_change, template_part.depth_change());
                 to_infer_idx += 1;
                 template_idx += 1;
                 continue;
+            }
             if to_infer_part.is_marker() { to_infer_idx += 1; continue; }
             if template_part.is_marker() { template_idx += 1; continue; }
             // Types are not equal and not markers. So check if we can infer
             // anything
             if let Some(depth_change) = Self::infer_part_for_single_type(
                 to_infer, &mut to_infer_idx, template, &mut template_idx
             ) {
                 depth += depth_change;
                 modified = true;
                 continue;
+            }
             // We cannot infer anything, but the template may still be
             // compatible with the type we're inferring
             if let Some(depth_change) = Self::check_part_for_single_type(
                 template, &mut template_idx, &to_infer.parts, &mut to_infer_idx
             ) {
                 depth += depth_change;
                 continue;
+            }
             return SingleInferenceResult::Incompatible
+        }
         return if modified {
             to_infer.recompute_is_done();
             SingleInferenceResult::Modified
         } else {
             SingleInferenceResult::Unmodified
+        }
+    }
     /// Checks if both types are compatible, doesn't perform any inference
     fn check_subtrees(
         type_parts_a: &[InferenceTypePart], start_idx_a: usize,
         type_parts_b: &[InferenceTypePart], start_idx_b: usize
     ) -> bool {
         let mut depth = 1;
         let mut idx_a = start_idx_a;
         let mut idx_b = start_idx_b;
         while depth > 0 {
             let part_a = &type_parts_a[idx_a];
             let part_b = &type_parts_b[idx_b];
             if part_a == part_b {
                 let depth_change = part_a.depth_change();
                 depth += depth_change;
                 debug_assert_eq!(depth_change, part_b.depth_change());
                 idx_a += 1;
                 idx_b += 1;
                 continue;
+            }
             if part_a.is_marker() { idx_a += 1; continue; }
             if part_b.is_marker() { idx_b += 1; continue; }
             if let Some(depth_change) = Self::check_part_for_single_type(
                 type_parts_a, &mut idx_a, type_parts_b, &mut idx_b
             ) {
                 depth += depth_change;
                 continue;
+            }
             if let Some(depth_change) = Self::check_part_for_single_type(
                 type_parts_b, &mut idx_b, type_parts_a, &mut idx_a
             ) {
                 depth += depth_change;
                 continue;
+            }
             return false;
+        }
         true
+    }
     /// Performs the conversion of the inference type into a concrete type.
     /// By calling this function you must make sure that no unspecified types
     /// (e.g. Unknown or IntegerLike) exist in the type.
     fn write_concrete_type(&self, concrete_type: &mut ConcreteType) {
         use InferenceTypePart as ITP;
         use ConcreteTypePart as CTP;
         // Make sure inference type is specified but concrete type is not yet specified
         debug_assert!(!self.parts.is_empty());
         debug_assert!(concrete_type.parts.is_empty());
         concrete_type.parts.reserve(self.parts.len());
         let mut idx = 0;
         while idx < self.parts.len() {
             let part = &self.parts[idx];
             let converted_part = match part {
                 ITP::MarkerDefinition(marker) => {
                     // Outer markers are converted to regular markers, we
                     // completely remove the type subtree that follows it
                     idx = InferenceType::find_subtree_end_idx(&self.parts, idx + 1);
                     concrete_type.parts.push(CTP::Marker(*marker));
                     continue;
                 },
                 ITP::MarkerBody(_) => {
                     // Inner markers are removed when writing to the concrete
                     // type.
                     idx += 1;
                     continue;
                 },
                 ITP::Unknown | ITP::NumberLike | ITP::IntegerLike | ITP::ArrayLike | ITP::PortLike => {
                     unreachable!("Attempted to convert inference type part {:?} into concrete type", part);
                 },
                 ITP::Void => CTP::Void,
                 ITP::Message => CTP::Message,
                 ITP::Bool => CTP::Bool,
                 ITP::Byte => CTP::Byte,
                 ITP::Short => CTP::Short,
                 ITP::Int => CTP::Int,
                 ITP::Long => CTP::Long,
                 ITP::String => CTP::String,
                 ITP::Array => CTP::Array,
                 ITP::Slice => CTP::Slice,
                 ITP::Input => CTP::Input,
                 ITP::Output => CTP::Output,
                 ITP::Instance(id, num) => CTP::Instance(*id, *num),
             };
             concrete_type.parts.push(converted_part);
             idx += 1;
+        }
+    }
     /// Writes a human-readable version of the type to a string. Mostly a
     /// function for interior use.
     fn write_display_name(
         buffer: &mut String, heap: &Heap, parts: &[InferenceTypePart], mut idx: usize
     ) -> usize {
         use InferenceTypePart as ITP;
         match &parts[idx] {
             ITP::MarkerDefinition(_) | ITP::MarkerBody(_) => {
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1)
             ITP::MarkerDefinition(thing) => {
                 buffer.push_str(&format!("{{D:{}}}", *thing));
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
             },
             ITP::MarkerBody(thing) => {
                 buffer.push_str(&format!("{{B:{}}}", *thing));
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
             },
             ITP::Unknown => buffer.push_str("?"),
             ITP::NumberLike => buffer.push_str("num?"),
             ITP::IntegerLike => buffer.push_str("int?"),
             ITP::ArrayLike => {
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push_str("[?]");
             },
             ITP::PortLike => {
                 buffer.push_str("port?<");
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
+            }
             ITP::Void => buffer.push_str("void"),
             ITP::Bool => buffer.push_str("bool"),
             ITP::Byte => buffer.push_str("byte"),
             ITP::Short => buffer.push_str("short"),
             ITP::Int => buffer.push_str("int"),
             ITP::Long => buffer.push_str("long"),
             ITP::String => buffer.push_str("str"),
             ITP::Message => {
                 buffer.push_str("msg<");
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
             },
             ITP::Array => {
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push_str("[]");
             },
             ITP::Slice => {
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push_str("[..]");
             },
             ITP::Input => {
                 buffer.push_str("in<");
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
             },
             ITP::Output => {
                 buffer.push_str("out<");
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
             },
             ITP::Instance(definition_id, num_sub) => {
                 let definition = &heap[*definition_id];
                 buffer.push_str(&String::from_utf8_lossy(&definition.identifier().value));
                 if *num_sub > 0 {
                     buffer.push('<');
                     idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                     for _sub_idx in 1..*num_sub {
                         buffer.push_str(", ");
                         idx = Self::write_display_name(buffer, heap, parts, idx + 1);
+                    }
                     buffer.push('>');
+                }
             },
+        }
         idx
+    }
     /// Returns the display name of a (part of) the type tree. Will allocate a
     /// string.
     fn partial_display_name(heap: &Heap, parts: &[InferenceTypePart]) -> String {
         let mut buffer = String::with_capacity(parts.len() * 6);
         Self::write_display_name(&mut buffer, heap, parts, 0);
         buffer
+    }
     /// Returns the display name of the full type tree. Will allocate a string.
     fn display_name(&self, heap: &Heap) -> String {
         Self::partial_display_name(heap, &self.parts)
+    }
+}
 /// Iterator over the subtrees that follow a marker in an `InferenceType`
 /// instance. Returns immutable slices over the internal parts
 struct InferenceTypeMarkerIter<'a> {
     parts: &'a [InferenceTypePart],
     idx: usize,
+}
 impl<'a> InferenceTypeMarkerIter<'a> {
     fn new(parts: &'a [InferenceTypePart]) -> Self {
         Self{ parts, idx: 0 }
+    }
+}
 impl<'a> Iterator for InferenceTypeMarkerIter<'a> {
     type Item = (usize, &'a [InferenceTypePart]);
     fn next(&mut self) -> Option<Self::Item> {
         // Iterate until we find a marker
         while self.idx < self.parts.len() {
             if let InferenceTypePart::MarkerBody(marker) = self.parts[self.idx] {
                 // Found a marker, find the subtree end
                 let start_idx = self.idx + 1;
                 let end_idx = InferenceType::find_subtree_end_idx(self.parts, start_idx);
                 // Modify internal index, then return items
                 self.idx = end_idx;
                 return Some((marker, &self.parts[start_idx..end_idx]))
+            }
             self.idx += 1;
+        }
         None
+    }
+}
 #[derive(Debug, PartialEq, Eq)]
 enum DualInferenceResult {
     Neither,        // neither argument is clarified
     First,          // first argument is clarified using the second one
     Second,         // second argument is clarified using the first one
     Both,           // both arguments are clarified
     Incompatible,   // types are incompatible: programmer error
+}
 impl DualInferenceResult {
     fn modified_lhs(&self) -> bool {
         match self {
             DualInferenceResult::First | DualInferenceResult::Both => true,
             _ => false
+        }
+    }
     fn modified_rhs(&self) -> bool {
         match self {
             DualInferenceResult::Second | DualInferenceResult::Both => true,
             _ => false
+        }
+    }
+}
 #[derive(Debug, PartialEq, Eq)]
 enum SingleInferenceResult {
     Unmodified,
     Modified,
     Incompatible
+}
 enum DefinitionType{
     None,
     Component(ComponentId),
     Function(FunctionId),
+}
 pub(crate) struct ResolveQueueElement {
     pub(crate) root_id: RootId,
     pub(crate) definition_id: DefinitionId,
     pub(crate) monomorph_types: Vec<ConcreteType>,
+}
 pub(crate) type ResolveQueue = Vec<ResolveQueueElement>;
 /// This particular visitor will recurse depth-first into the AST and ensures
 /// that all expressions have the appropriate types.
 pub(crate) struct TypeResolvingVisitor {
     // Current definition we're typechecking.
     definition_type: DefinitionType,
     poly_vars: Vec<ConcreteType>,
     // Buffers for iteration over substatements and subexpressions
     stmt_buffer: Vec<StatementId>,
     expr_buffer: Vec<ExpressionId>,
     // Mapping from parser type to inferred type. We attempt to continue to
     // specify these types until we're stuck or we've fully determined the type.
     var_types: HashMap<VariableId, VarData>,      // types of variables
     expr_types: HashMap<ExpressionId, InferenceType>,   // types of expressions
     extra_data: HashMap<ExpressionId, ExtraData>,       // data for polymorph inference
     // Keeping track of which expressions need to be reinferred because the
     // expressions they're linked to made progression on an associated type
     expr_queued: HashSet<ExpressionId>,
+}
 // TODO: @rename used for calls and struct literals, maybe union literals?
 struct ExtraData {
     /// Progression of polymorphic variables (if any)
     poly_vars: Vec<InferenceType>,
     /// Progression of types of call arguments or struct members
     embedded: Vec<InferenceType>,
     returned: InferenceType,
+}
 struct VarData {
     /// Type of the variable
     var_type: InferenceType,
     /// VariableExpressions that use the variable
     used_at: Vec<ExpressionId>,
     /// For channel statements we link to the other variable such that when one
     /// channel's interior type is resolved, we can also resolve the other one.
     linked_var: Option<VariableId>,
+}
 impl VarData {
     fn new_channel(var_type: InferenceType, other_port: VariableId) -> Self {
         Self{ var_type, used_at: Vec::new(), linked_var: Some(other_port) }
+    }
     fn new_local(var_type: InferenceType) -> Self {
         Self{ var_type, used_at: Vec::new(), linked_var: None }
+    }
+}
 impl TypeResolvingVisitor {
     pub(crate) fn new() -> Self {
         TypeResolvingVisitor{
             definition_type: DefinitionType::None,
             poly_vars: Vec::new(),
             stmt_buffer: Vec::with_capacity(STMT_BUFFER_INIT_CAPACITY),
             expr_buffer: Vec::with_capacity(EXPR_BUFFER_INIT_CAPACITY),
             var_types: HashMap::new(),
             expr_types: HashMap::new(),
             extra_data: HashMap::new(),
             expr_queued: HashSet::new(),
+        }
+    }
     // TODO: @cleanup Unsure about this, maybe a pattern will arise after
     //  a while.
     pub(crate) fn queue_module_definitions(ctx: &Ctx, queue: &mut ResolveQueue) {
         let root_id = ctx.module.root_id;
         let root = &ctx.heap.protocol_descriptions[root_id];
         for definition_id in &root.definitions {
             let definition = &ctx.heap[*definition_id];
             match definition {
                 Definition::Function(definition) => {
                     if definition.poly_vars.is_empty() {
                         queue.push(ResolveQueueElement{
                             root_id,
                             definition_id: *definition_id,
                             monomorph_types: Vec::new(),
                         })
+                    }
                 },
                 Definition::Component(definition) => {
                     if definition.poly_vars.is_empty() {
                         queue.push(ResolveQueueElement{
                             root_id,
                             definition_id: *definition_id,
                             monomorph_types: Vec::new(),
                         })
+                    }
                 },
                 Definition::Enum(_) | Definition::Struct(_) => {},
+            }
+        }
+    }
     pub(crate) fn handle_module_definition(
         &mut self, ctx: &mut Ctx, queue: &mut ResolveQueue, element: ResolveQueueElement
     ) -> VisitorResult {
         // Visit the definition
         debug_assert_eq!(ctx.module.root_id, element.root_id);
         self.reset();
         self.poly_vars.clear();
         self.poly_vars.extend(element.monomorph_types.iter().cloned());
         self.visit_definition(ctx, element.definition_id)?;
         // Keep resolving types
         self.resolve_types(ctx, queue)?;
         Ok(())
+    }
     fn reset(&mut self) {
         self.definition_type = DefinitionType::None;
         self.poly_vars.clear();
         self.stmt_buffer.clear();
         self.expr_buffer.clear();
         self.var_types.clear();
         self.expr_types.clear();
         self.extra_data.clear();
         self.expr_queued.clear();
+    }
+}
 impl Visitor2 for TypeResolvingVisitor {
     // Definitions
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentId) -> VisitorResult {
         self.definition_type = DefinitionType::Component(id);
         let comp_def = &ctx.heap[id];
         debug_assert_eq!(comp_def.poly_vars.len(), self.poly_vars.len(), "component polyvars do not match imposed polyvars");
         debug_log!("{}", "-".repeat(50));
         debug_log!("Visiting component '{}': {}", &String::from_utf8_lossy(&comp_def.identifier.value), id.0.index);
         debug_log!("{}", "-".repeat(50));
         for param_id in comp_def.parameters.clone() {
             let param = &ctx.heap[param_id];
             let var_type = self.determine_inference_type_from_parser_type(ctx, param.parser_type, true);
             debug_assert!(var_type.is_done, "expected component arguments to be concrete types");
             self.var_types.insert(param_id.upcast(), VarData::new_local(var_type));
+        }
         let body_stmt_id = ctx.heap[id].body;
         self.visit_stmt(ctx, body_stmt_id)
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionId) -> VisitorResult {
         self.definition_type = DefinitionType::Function(id);
         let func_def = &ctx.heap[id];
         debug_assert_eq!(func_def.poly_vars.len(), self.poly_vars.len(), "function polyvars do not match imposed polyvars");
         debug_log!("{}", "-".repeat(50));
         debug_log!("Visiting function '{}': {}", &String::from_utf8_lossy(&func_def.identifier.value), id.0.index);
         debug_log!("{}", "-".repeat(50));
         for param_id in func_def.parameters.clone() {
             let param = &ctx.heap[param_id];
             let var_type = self.determine_inference_type_from_parser_type(ctx, param.parser_type, true);
             debug_assert!(var_type.is_done, "expected function arguments to be concrete types");
             self.var_types.insert(param_id.upcast(), VarData::new_local(var_type));
+        }
         let body_stmt_id = ctx.heap[id].body;
         self.visit_stmt(ctx, body_stmt_id)
+    }
     // Statements
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         // Transfer statements for traversal
         let block = &ctx.heap[id];
         for stmt_id in block.statements.clone() {
             self.visit_stmt(ctx, stmt_id)?;
+        }
         Ok(())
+    }
     fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {
         let memory_stmt = &ctx.heap[id];
         let local = &ctx.heap[memory_stmt.variable];
         let var_type = self.determine_inference_type_from_parser_type(ctx, local.parser_type, true);
         self.var_types.insert(memory_stmt.variable.upcast(), VarData::new_local(var_type));
         Ok(())
+    }
     fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {
         let channel_stmt = &ctx.heap[id];
         let from_local = &ctx.heap[channel_stmt.from];
         let from_var_type = self.determine_inference_type_from_parser_type(ctx, from_local.parser_type, true);
         self.var_types.insert(from_local.this.upcast(), VarData::new_channel(from_var_type, channel_stmt.to.upcast()));
         let to_local = &ctx.heap[channel_stmt.to];
         let to_var_type = self.determine_inference_type_from_parser_type(ctx, to_local.parser_type, true);
         self.var_types.insert(to_local.this.upcast(), VarData::new_channel(to_var_type, channel_stmt.from.upcast()));
         Ok(())
+    }
     fn visit_labeled_stmt(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> VisitorResult {
         let labeled_stmt = &ctx.heap[id];
         let substmt_id = labeled_stmt.body;
         self.visit_stmt(ctx, substmt_id)
+    }
     fn visit_if_stmt(&mut self, ctx: &mut Ctx, id: IfStatementId) -> VisitorResult {
         let if_stmt = &ctx.heap[id];
         let true_body_id = if_stmt.true_body;
         let false_body_id = if_stmt.false_body;
         let test_expr_id = if_stmt.test;
         self.visit_expr(ctx, test_expr_id)?;
         self.visit_stmt(ctx, true_body_id)?;
         self.visit_stmt(ctx, false_body_id)?;
         Ok(())
+    }
     fn visit_while_stmt(&mut self, ctx: &mut Ctx, id: WhileStatementId) -> VisitorResult {
         let while_stmt = &ctx.heap[id];
         let body_id = while_stmt.body;
         let test_expr_id = while_stmt.test;
@@ @@ -1479,1333 +1484,1338 @@ impl TypeResolvingVisitor { @@
         if progress_arg2 { self.queue_expr(arg2_expr_id); }
         Ok(())
+    }
     fn progress_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> Result<(), ParseError2> {
         // Note: test expression type is already enforced
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_expr_id = expr.true_expression;
         let arg2_expr_id = expr.false_expression;
         debug_log!("Conditional expr: {}", upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Arg1 type: {}", self.expr_types.get(&arg1_expr_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Arg2 type: {}", self.expr_types.get(&arg2_expr_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         let (progress_expr, progress_arg1, progress_arg2) = self.apply_equal3_constraint(
             ctx, upcast_id, arg1_expr_id, arg2_expr_id, 0
         )?;
         debug_log!(" * After:");
         debug_log!("   - Arg1 type [{}]: {}", progress_arg1, self.expr_types.get(&arg1_expr_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.expr_types.get(&arg2_expr_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Expr type [{}]: {}", progress_expr, self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg1 { self.queue_expr(arg1_expr_id); }
         if progress_arg2 { self.queue_expr(arg2_expr_id); }
         Ok(())
+    }
     fn progress_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> Result<(), ParseError2> {
         // Note: our expression type might be fixed by our parent, but we still
         // need to make sure it matches the type associated with our operation.
         use BinaryOperator as BO;
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_id = expr.left;
         let arg2_id = expr.right;
         debug_log!("Binary expr '{:?}': {}", expr.operation, upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Arg1 type: {}", self.expr_types.get(&arg1_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Arg2 type: {}", self.expr_types.get(&arg2_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         let (progress_expr, progress_arg1, progress_arg2) = match expr.operation {
             BO::Concatenate => {
                 // Arguments may be arrays/slices, output is always an array
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &ARRAY_TEMPLATE)?;
                 let progress_arg1 = self.apply_forced_constraint(ctx, arg1_id, &ARRAYLIKE_TEMPLATE)?;
                 let progress_arg2 = self.apply_forced_constraint(ctx, arg2_id, &ARRAYLIKE_TEMPLATE)?;
                 // If they're all arraylike, then we want the subtype to match
                 let (subtype_expr, subtype_arg1, subtype_arg2) =
                     self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 1)?;
                 (progress_expr || subtype_expr, progress_arg1 || subtype_arg1, progress_arg2 || subtype_arg2)
             },
             BO::LogicalOr | BO::LogicalAnd => {
                 // Forced boolean on all
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg1 = self.apply_forced_constraint(ctx, arg1_id, &BOOL_TEMPLATE)?;
                 let progress_arg2 = self.apply_forced_constraint(ctx, arg2_id, &BOOL_TEMPLATE)?;
                 (progress_expr, progress_arg1, progress_arg2)
             },
             BO::BitwiseOr | BO::BitwiseXor | BO::BitwiseAnd | BO::Remainder | BO::ShiftLeft | BO::ShiftRight => {
                 // All equal of integer type
                 let progress_base = self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg1, progress_arg2) =
                     self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg1, progress_base || progress_arg2)
             },
             BO::Equality | BO::Inequality => {
                 // Equal2 on args, forced boolean output
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let (progress_arg1, progress_arg2) =
                     self.apply_equal2_constraint(ctx, upcast_id, arg1_id, 0, arg2_id, 0)?;
                 (progress_expr, progress_arg1, progress_arg2)
             },
             BO::LessThan | BO::GreaterThan | BO::LessThanEqual | BO::GreaterThanEqual => {
                 // Equal2 on args with numberlike type, forced boolean output
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg_base = self.apply_forced_constraint(ctx, arg1_id, &NUMBERLIKE_TEMPLATE)?;
                 let (progress_arg1, progress_arg2) =
                     self.apply_equal2_constraint(ctx, upcast_id, arg1_id, 0, arg2_id, 0)?;
                 (progress_expr, progress_arg_base || progress_arg1, progress_arg_base || progress_arg2)
             },
             BO::Add | BO::Subtract | BO::Multiply | BO::Divide => {
                 // All equal of number type
                 let progress_base = self.apply_forced_constraint(ctx, upcast_id, &NUMBERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg1, progress_arg2) =
                     self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg1, progress_base || progress_arg2)
             },
         };
         debug_log!(" * After:");
         debug_log!("   - Arg1 type [{}]: {}", progress_arg1, self.expr_types.get(&arg1_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.expr_types.get(&arg2_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Expr type [{}]: {}", progress_expr, self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg1 { self.queue_expr(arg1_id); }
         if progress_arg2 { self.queue_expr(arg2_id); }
         Ok(())
+    }
     fn progress_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> Result<(), ParseError2> {
         use UnaryOperation as UO;
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg_id = expr.expression;
         debug_log!("Unary expr '{:?}': {}", expr.operation, upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Arg  type: {}", self.expr_types.get(&arg_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         let (progress_expr, progress_arg) = match expr.operation {
             UO::Positive | UO::Negative => {
                 // Equal types of numeric class
                 let progress_base = self.apply_forced_constraint(ctx, upcast_id, &NUMBERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg) =
                     self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, arg_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg)
             },
             UO::BitwiseNot | UO::PreIncrement | UO::PreDecrement | UO::PostIncrement | UO::PostDecrement => {
                 // Equal types of integer class
                 let progress_base = self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg) =
                     self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, arg_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg)
             },
             UO::LogicalNot => {
                 // Both booleans
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 (progress_expr, progress_arg)
+            }
         };
         debug_log!(" * After:");
         debug_log!("   - Arg  type [{}]: {}", progress_arg, self.expr_types.get(&arg_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Expr type [{}]: {}", progress_expr, self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg { self.queue_expr(arg_id); }
         Ok(())
+    }
     fn progress_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let subject_id = expr.subject;
         let index_id = expr.index;
         debug_log!("Indexing expr: {}", upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Subject type: {}", self.expr_types.get(&subject_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Index   type: {}", self.expr_types.get(&index_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Expr    type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         // Make sure subject is arraylike and index is integerlike
         let progress_subject_base = self.apply_forced_constraint(ctx, subject_id, &ARRAYLIKE_TEMPLATE)?;
         let progress_index = self.apply_forced_constraint(ctx, index_id, &INTEGERLIKE_TEMPLATE)?;
         // Make sure if output is of T then subject is Array<T>
         let (progress_expr, progress_subject) =
             self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, subject_id, 1)?;
         debug_log!(" * After:");
         debug_log!("   - Subject type [{}]: {}", progress_subject_base || progress_subject, self.expr_types.get(&subject_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Index   type [{}]: {}", progress_index, self.expr_types.get(&index_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Expr    type [{}]: {}", progress_expr, self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_subject_base || progress_subject { self.queue_expr(subject_id); }
         if progress_index { self.queue_expr(index_id); }
         Ok(())
+    }
     fn progress_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let subject_id = expr.subject;
         let from_id = expr.from_index;
         let to_id = expr.to_index;
         debug_log!("Slicing expr: {}", upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Subject type: {}", self.expr_types.get(&subject_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - FromIdx type: {}", self.expr_types.get(&from_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - ToIdx   type: {}", self.expr_types.get(&to_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Expr    type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         // Make sure subject is arraylike and indices are of equal integerlike
         let progress_subject_base = self.apply_forced_constraint(ctx, subject_id, &ARRAYLIKE_TEMPLATE)?;
         let progress_idx_base = self.apply_forced_constraint(ctx, from_id, &INTEGERLIKE_TEMPLATE)?;
         let (progress_from, progress_to) = self.apply_equal2_constraint(ctx, upcast_id, from_id, 0, to_id, 0)?;
         // Make sure if output is of T then subject is Array<T>
         let (progress_expr, progress_subject) =
             self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, subject_id, 1)?;
         debug_log!(" * After:");
         debug_log!("   - Subject type [{}]: {}", progress_subject_base || progress_subject, self.expr_types.get(&subject_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - FromIdx type [{}]: {}", progress_idx_base || progress_from, self.expr_types.get(&from_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - ToIdx   type [{}]: {}", progress_idx_base || progress_to, self.expr_types.get(&to_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Expr    type [{}]: {}", progress_expr, self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_subject_base || progress_subject { self.queue_expr(subject_id); }
         if progress_idx_base || progress_from { self.queue_expr(from_id); }
         if progress_idx_base || progress_to { self.queue_expr(to_id); }
         Ok(())
+    }
     fn progress_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         debug_log!("Select expr: {}", upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Subject type: {}", self.expr_types.get(&ctx.heap[id].subject).unwrap().display_name(&ctx.heap));
         debug_log!("   - Expr    type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         let expr = &mut ctx.heap[id];
         let subject_id = expr.subject;
         fn determine_inference_type_instance<'a>(types: &'a TypeTable, infer_type: &InferenceType) -> Result<Option<&'a DefinedType>, ()> {
             for part in &infer_type.parts {
                 if part.is_marker() || !part.is_concrete() {
                     continue;
+                }
                 // Part is concrete, check if it is an instance of something
                 if let InferenceTypePart::Instance(definition_id, _num_sub) = part {
                     // Lookup type definition and ensure the specified field
                     // name exists on the struct
                     let definition = types.get_base_definition(definition_id);
                     debug_assert!(definition.is_some());
                     let definition = definition.unwrap();
                     return Ok(Some(definition))
                 } else {
                     // Expected an instance of something
                     return Err(())
+                }
+            }
             // Nothing is concrete yet
             Ok(None)
+        }
         let (progress_subject, progress_expr) = match &mut expr.field {
             Field::Length => {
                 let progress_subject = self.apply_forced_constraint(ctx, subject_id, &ARRAYLIKE_TEMPLATE)?;
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?;
                 (progress_subject, progress_expr)
             },
             Field::Symbolic(field) => {
                 // Retrieve the struct definition id and field index if possible
                 // and not previously determined
                 if field.definition.is_none() {
                     // Not yet known, check if we can determine it
                     let subject_type = self.expr_types.get(&subject_id).unwrap();
                     let type_def = determine_inference_type_instance(&ctx.types, subject_type);
                     match type_def {
                         Ok(Some(type_def)) => {
                             // Subject type is known, check if it is a
                             // struct and the field exists on the struct
                             let struct_def = if let DefinedTypeVariant::Struct(struct_def) = &type_def.definition {
                                 struct_def
                             } else {
                                 return Err(ParseError2::new_error(
                                     &ctx.module.source, field.identifier.position,
                                     &format!(
                                         "Can only apply field access to structs, got a subject of type '{}'",
                                         subject_type.display_name(&ctx.heap)
+                                    )
                                 ));
                             };
                             for (field_def_idx, field_def) in struct_def.fields.iter().enumerate() {
                                 if field_def.identifier == field.identifier {
                                     // Set field definition and index
                                     field.definition = Some(type_def.ast_definition);
                                     field.field_idx = field_def_idx;
                                     break;
+                                }
+                            }
                             if field.definition.is_none() {
                                 let field_position = field.identifier.position;
                                 let ast_struct_def = ctx.heap[type_def.ast_definition].as_struct();
                                 return Err(ParseError2::new_error(
                                     &ctx.module.source, field_position,
                                     &format!(
                                         "This field does not exist on the struct '{}'",
                                         &String::from_utf8_lossy(&ast_struct_def.identifier.value)
+                                    )
                                 ))
+                            }
                             // Encountered definition and field index for the
                             // first time
                             self.insert_initial_select_polymorph_data(ctx, id);
                         },
                         Ok(None) => {
                             // Type of subject is not yet known, so we
                             // cannot make any progress yet
                             return Ok(())
                         },
                         Err(()) => {
                             return Err(ParseError2::new_error(
                                 &ctx.module.source, field.identifier.position,
                                 &format!(
                                     "Can only apply field access to structs, got a subject of type '{}'",
                                     subject_type.display_name(&ctx.heap)
+                                )
                             ));
+                        }
+                    }
+                }
                 // If here then field definition and index are known, and the
                 // initial type (based on the struct's definition) has been
                 // applied.
                 // Check to see if we can infer anything about the subject's and
                 // the field's polymorphic variables
                 let poly_data = self.extra_data.get_mut(&upcast_id).unwrap();
                 let mut poly_progress = HashSet::new();
                 // Apply to struct's type
                 let signature_type: *mut _ = &mut poly_data.embedded[0];
                 let subject_type: *mut _ = self.expr_types.get_mut(&subject_id).unwrap();
                 let (_, progress_subject) = Self::apply_equal2_signature_constraint(
                     ctx, upcast_id, Some(subject_id), poly_data, &mut poly_progress,
                     signature_type, 0, subject_type, 0
                 )?;
                 if progress_subject {
                     self.expr_queued.insert(subject_id);
+                }
                 // Apply to field's type
                 let signature_type: *mut _ = &mut poly_data.returned;
                 let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();
                 let (_, progress_expr) = Self::apply_equal2_signature_constraint(
                     ctx, upcast_id, None, poly_data, &mut poly_progress,
                     signature_type, 0, expr_type, 0
                 )?;
                 if progress_expr {
                     if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {
                         self.expr_queued.insert(parent_id);
+                    }
+                }
                 // Reapply progress in polymorphic variables to struct's type
                 let signature_type: *mut _ = &mut poly_data.embedded[0];
                 let subject_type: *mut _ = self.expr_types.get_mut(&subject_id).unwrap();
                 let progress_subject = Self::apply_equal2_polyvar_constraint(
+                let progress_subject = Self::apply_equal2_polyvar_constraint(&ctx.heap,
                     poly_data, &poly_progress, signature_type, subject_type
                 );
                 let signature_type: *mut _ = &mut poly_data.returned;
                 let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();
                 let progress_expr = Self::apply_equal2_polyvar_constraint(
+                let progress_expr = Self::apply_equal2_polyvar_constraint(&ctx.heap,
                     poly_data, &poly_progress, signature_type, expr_type
                 );
                 (progress_subject, progress_expr)
+            }
         };
         if progress_subject { self.queue_expr(subject_id); }
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         debug_log!(" * After:");
         debug_log!("   - Subject type [{}]: {}", progress_subject, self.expr_types.get(&subject_id).unwrap().display_name(&ctx.heap));
         debug_log!("   - Expr    type [{}]: {}", progress_expr, self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         Ok(())
+    }
     fn progress_array_expr(&mut self, ctx: &mut Ctx, id: ArrayExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let expr_elements = expr.elements.clone(); // TODO: @performance
         debug_log!("Array expr ({} elements): {}", expr_elements.len(), upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         // All elements should have an equal type
         let progress = self.apply_equal_n_constraint(ctx, upcast_id, &expr_elements)?;
         for (progress_arg, arg_id) in progress.iter().zip(expr_elements.iter()) {
             if *progress_arg {
                 self.queue_expr(*arg_id);
+            }
+        }
         // And the output should be an array of the element types
         let mut expr_progress = self.apply_forced_constraint(ctx, upcast_id, &ARRAY_TEMPLATE)?;
         if !expr_elements.is_empty() {
             let first_arg_id = expr_elements[0];
             let (inner_expr_progress, arg_progress) = self.apply_equal2_constraint(
                 ctx, upcast_id, upcast_id, 1, first_arg_id, 0
             )?;
             expr_progress = expr_progress || inner_expr_progress;
             // Note that if the array type progressed the type of the arguments,
             // then we should enqueue this progression function again
             // TODO: @fix Make apply_equal_n accept a start idx as well
             if arg_progress { self.queue_expr(upcast_id); }
+        }
         debug_log!(" * After:");
         debug_log!("   - Expr type [{}]: {}", expr_progress, self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         if expr_progress { self.queue_expr_parent(ctx, upcast_id); }
         Ok(())
+    }
     fn progress_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         debug_log!("Literal expr: {}", upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         let progress_expr = match &expr.value {
             Literal::Null => {
                 self.apply_forced_constraint(ctx, upcast_id, &MESSAGE_TEMPLATE)?
             },
             Literal::Integer(_) => {
                 self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?
             },
             Literal::True | Literal::False => {
                 self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?
             },
             Literal::Character(_) => todo!("character literals"),
             Literal::Struct(data) => {
                 let extra = self.extra_data.get_mut(&upcast_id).unwrap();
                 let mut poly_progress = HashSet::new();
                 debug_assert_eq!(extra.embedded.len(), data.fields.len());
                 debug_log!(" * During (inferring types from fields and struct type):");
                 // Mutually infer field signature/expression types
                 for (field_idx, field) in data.fields.iter().enumerate() {
                     let field_expr_id = field.value;
                     let signature_type: *mut _ = &mut extra.embedded[field_idx];
                     let field_type: *mut _ = self.expr_types.get_mut(&field_expr_id).unwrap();
                     let (_, progress_arg) = Self::apply_equal2_signature_constraint(
                         ctx, upcast_id, Some(field_expr_id), extra, &mut poly_progress,
                         signature_type, 0, field_type, 0
                     )?;
                     debug_log!(
                         "   - Field {} type | sig: {}, field: {}", field_idx,
                         unsafe{&*signature_type}.display_name(&ctx.heap),
                         unsafe{&*field_type}.display_name(&ctx.heap)
                     );
                     if progress_arg {
                         self.expr_queued.insert(field_expr_id);
+                    }
+                }
                 // Same for the type of the struct itself
                 let signature_type: *mut _ = &mut extra.returned;
                 let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();
                 let (_, progress_expr) = Self::apply_equal2_signature_constraint(
                     ctx, upcast_id, None, extra, &mut poly_progress,
                     signature_type, 0, expr_type, 0
                 )?;
                 debug_log!(
                     "   - Ret type | sig: {}, expr: {}",
                     unsafe{&*signature_type}.display_name(&ctx.heap),
                     unsafe{&*expr_type}.display_name(&ctx.heap)
                 );
                 if progress_expr {
                     // TODO: @cleanup, cannot call utility self.queue_parent thingo
                     if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {
                         self.expr_queued.insert(parent_id);
+                    }
+                }
                 // Check which expressions use the polymorphic arguments. If the
                 // polymorphic variables have been progressed then we try to
                 // progress them inside the expression as well.
                 debug_log!(" * During (reinferring from progressed polyvars):");
                 // For all field expressions
                 for field_idx in 0..extra.embedded.len() {
                     debug_assert_eq!(field_idx, data.fields[field_idx].field_idx, "confusing, innit?");
                     let signature_type: *mut _ = &mut extra.embedded[field_idx];
                     let field_expr_id = data.fields[field_idx].value;
                     let field_type: *mut _ = self.expr_types.get_mut(&field_expr_id).unwrap();
                     let progress_arg = Self::apply_equal2_polyvar_constraint(
+                    let progress_arg = Self::apply_equal2_polyvar_constraint(&ctx.heap,
                         extra, &poly_progress, signature_type, field_type
                     );
                     debug_log!(
                         "   - Field {} type | sig: {}, field: {}", field_idx,
                         unsafe{&*signature_type}.display_name(&ctx.heap),
                         unsafe{&*field_type}.display_name(&ctx.heap)
                     );
                     if progress_arg {
                         self.expr_queued.insert(field_expr_id);
+                    }
+                }
                 // For the return type
                 let signature_type: *mut _ = &mut extra.returned;
                 let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();
                 let progress_expr = Self::apply_equal2_polyvar_constraint(
+                let progress_expr = Self::apply_equal2_polyvar_constraint(&ctx.heap,
                     extra, &poly_progress, signature_type, expr_type
                 );
                 progress_expr
+            }
         };
         debug_log!(" * After:");
         debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         // TODO: FIX!!!!
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         Ok(())
+    }
     // TODO: @cleanup, see how this can be cleaned up once I implement
     //  polymorphic struct/enum/union literals. These likely follow the same
     //  pattern as here.
     fn progress_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let extra = self.extra_data.get_mut(&upcast_id).unwrap();
         debug_log!("Call expr '{}': {}", match &expr.method {
             Method::Create => String::from("create"),
             Method::Fires => String::from("fires"),
             Method::Get => String::from("get"),
             Method::Put => String::from("put"),
             Method::Symbolic(method) => String::from_utf8_lossy(&method.identifier.value).to_string()
         },upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         debug_log!(" * During (inferring types from arguments and return type):");
         // Check if we can make progress using the arguments and/or return types
         // while keeping track of the polyvars we've extended
         let mut poly_progress = HashSet::new();
         debug_assert_eq!(extra.embedded.len(), expr.arguments.len());
         for (arg_idx, arg_id) in expr.arguments.clone().into_iter().enumerate() {
             let signature_type: *mut _ = &mut extra.embedded[arg_idx];
             let argument_type: *mut _ = self.expr_types.get_mut(&arg_id).unwrap();
             let (_, progress_arg) = Self::apply_equal2_signature_constraint(
                 ctx, upcast_id, Some(arg_id), extra, &mut poly_progress,
                 signature_type, 0, argument_type, 0
             )?;
             debug_log!(
                 "   - Arg {} type | sig: {}, arg: {}", arg_idx,
                 unsafe{&*signature_type}.display_name(&ctx.heap),
                 unsafe{&*argument_type}.display_name(&ctx.heap));
             if progress_arg {
                 // Progressed argument expression
                 self.expr_queued.insert(arg_id);
+            }
+        }
         // Do the same for the return type
         let signature_type: *mut _ = &mut extra.returned;
         let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();
         let (_, progress_expr) = Self::apply_equal2_signature_constraint(
             ctx, upcast_id, None, extra, &mut poly_progress,
             signature_type, 0, expr_type, 0
         )?;
         debug_log!(
             "   - Ret type | sig: {}, expr: {}",
             unsafe{&*signature_type}.display_name(&ctx.heap),
             unsafe{&*expr_type}.display_name(&ctx.heap)
         );
         if progress_expr {
             // TODO: @cleanup, cannot call utility self.queue_parent thingo
             if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {
                 self.expr_queued.insert(parent_id);
+            }
+        }
         // If we did not have an error in the polymorph inference above, then
         // reapplying the polymorph type to each argument type and the return
         // type should always succeed.
         debug_log!(" * During (reinferring from progressed polyvars):");
         for (poly_idx, poly_var) in extra.poly_vars.iter().enumerate() {
             debug_log!("   - Poly {} | sig: {}", poly_idx, poly_var.display_name(&ctx.heap));
+        }
         // TODO: @performance If the algorithm is changed to be more "on demand
         //  argument re-evaluation", instead of "all-argument re-evaluation",
         //  then this is no longer true
         for arg_idx in 0..extra.embedded.len() {
             let signature_type: *mut _ = &mut extra.embedded[arg_idx];
             let arg_expr_id = expr.arguments[arg_idx];
             let arg_type: *mut _ = self.expr_types.get_mut(&arg_expr_id).unwrap();
             let progress_arg = Self::apply_equal2_polyvar_constraint(
+            let progress_arg = Self::apply_equal2_polyvar_constraint(&ctx.heap,
                 extra, &poly_progress,
                 signature_type, arg_type
             );
             debug_log!(
                 "   - Arg {} type | sig: {}, arg: {}", arg_idx,
                 unsafe{&*signature_type}.display_name(&ctx.heap),
                 unsafe{&*arg_type}.display_name(&ctx.heap)
             );
             if progress_arg {
                 self.expr_queued.insert(arg_expr_id);
+            }
+        }
         // Once more for the return type
         let signature_type: *mut _ = &mut extra.returned;
         let ret_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();
         let progress_ret = Self::apply_equal2_polyvar_constraint(
+        let progress_ret = Self::apply_equal2_polyvar_constraint(&ctx.heap,
             extra, &poly_progress, signature_type, ret_type
         );
         debug_log!(
             "   - Ret type | sig: {}, arg: {}",
             unsafe{&*signature_type}.display_name(&ctx.heap),
             unsafe{&*ret_type}.display_name(&ctx.heap)
         );
         if progress_ret {
             self.queue_expr_parent(ctx, upcast_id);
+        }
         debug_log!(" * After:");
         debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         Ok(())
+    }
     fn progress_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let var_expr = &ctx.heap[id];
         let var_id = var_expr.declaration.unwrap();
         debug_log!("Variable expr '{}': {}", &String::from_utf8_lossy(&ctx.heap[var_id].identifier().value), upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Var  type: {}", self.var_types.get(&var_id).unwrap().var_type.display_name(&ctx.heap));
         debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         // Retrieve shared variable type and expression type and apply inference
         let var_data = self.var_types.get_mut(&var_id).unwrap();
         let expr_type = self.expr_types.get_mut(&upcast_id).unwrap();
         let infer_res = unsafe{ InferenceType::infer_subtrees_for_both_types(
             &mut var_data.var_type as *mut _, 0, expr_type, 0
         ) };
         if infer_res == DualInferenceResult::Incompatible {
             let var_decl = &ctx.heap[var_id];
             return Err(ParseError2::new_error(
                 &ctx.module.source, var_decl.position(),
                 &format!(
                     "Conflicting types for this variable, previously assigned the type '{}'",
                     var_data.var_type.display_name(&ctx.heap)
+                )
             ).with_postfixed_info(
                 &ctx.module.source, var_expr.position,
                 &format!(
                     "But inferred to have incompatible type '{}' here",
                     expr_type.display_name(&ctx.heap)
+                )
             ))
+        }
         let progress_var = infer_res.modified_lhs();
         let progress_expr = infer_res.modified_rhs();
         if progress_var {
             // Let other variable expressions using this type progress as well
             for other_expr in var_data.used_at.iter() {
                 if *other_expr != upcast_id {
                     self.expr_queued.insert(*other_expr);
+                }
+            }
             // Let a linked port know that our type has updated
             if let Some(linked_id) = var_data.linked_var {
                 // Only perform one-way inference to prevent updating our type, this
                 // would lead to an inconsistency
                 let var_type: *mut _ = &mut var_data.var_type;
                 let link_data = self.var_types.get_mut(&linked_id).unwrap();
                 debug_assert!(
                     unsafe{&*var_type}.parts[0] == InferenceTypePart::Input ||
                     unsafe{&*var_type}.parts[0] == InferenceTypePart::Output
                 );
                 debug_assert!(
                     link_data.var_type.parts[0] == InferenceTypePart::Input ||
                     link_data.var_type.parts[0] == InferenceTypePart::Output
                 );
                 match InferenceType::infer_subtree_for_single_type(&mut link_data.var_type, 1, &unsafe{&*var_type}.parts, 1) {
                     SingleInferenceResult::Modified => {
                         for other_expr in &link_data.used_at {
                             self.expr_queued.insert(*other_expr);
+                        }
                     },
                     SingleInferenceResult::Unmodified => {},
                     SingleInferenceResult::Incompatible => {
                         let var_data = self.var_types.get(&var_id).unwrap();
                         let link_data = self.var_types.get(&linked_id).unwrap();
                         let var_decl = &ctx.heap[var_id];
                         let link_decl = &ctx.heap[linked_id];
                         return Err(ParseError2::new_error(
                             &ctx.module.source, var_decl.position(),
                             &format!(
                                 "Conflicting types for this variable, assigned the type '{}'",
                                 var_data.var_type.display_name(&ctx.heap)
+                            )
                         ).with_postfixed_info(
                             &ctx.module.source, link_decl.position(),
                             &format!(
                                 "Because it is incompatible with this variable, assigned the type '{}'",
                                 link_data.var_type.display_name(&ctx.heap)
+                            )
                         ));
+                    }
+                }
+            }
+        }
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         debug_log!(" * After:");
         debug_log!("   - Var  type [{}]: {}", progress_var, self.var_types.get(&var_id).unwrap().var_type.display_name(&ctx.heap));
         debug_log!("   - Expr type [{}]: {}", progress_expr, self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         Ok(())
+    }
     fn queue_expr_parent(&mut self, ctx: &Ctx, expr_id: ExpressionId) {
         if let ExpressionParent::Expression(parent_expr_id, _) = &ctx.heap[expr_id].parent() {
             self.expr_queued.insert(*parent_expr_id);
+        }
+    }
     fn queue_expr(&mut self, expr_id: ExpressionId) {
         self.expr_queued.insert(expr_id);
+    }
     /// Applies a forced type constraint: the type associated with the supplied
     /// expression will be molded into the provided "template". The template may
     /// be fully specified (e.g. a bool) or contain "inference" variables (e.g.
     /// an array of T)
     fn apply_forced_constraint(
         &mut self, ctx: &mut Ctx, expr_id: ExpressionId, template: &[InferenceTypePart]
     ) -> Result<bool, ParseError2> {
         debug_assert_expr_ids_unique_and_known!(self, expr_id);
         let expr_type = self.expr_types.get_mut(&expr_id).unwrap();
         match InferenceType::infer_subtree_for_single_type(expr_type, 0, template, 0) {
             SingleInferenceResult::Modified => Ok(true),
             SingleInferenceResult::Unmodified => Ok(false),
             SingleInferenceResult::Incompatible => Err(
                 self.construct_template_type_error(ctx, expr_id, template)
+            )
+        }
+    }
     fn apply_forced_constraint_types(
         to_infer: *mut InferenceType, to_infer_start_idx: usize,
         template: &[InferenceTypePart], template_start_idx: usize
     ) -> Result<bool, ()> {
         match InferenceType::infer_subtree_for_single_type(
             unsafe{ &mut *to_infer }, to_infer_start_idx,
             template, template_start_idx
         ) {
             SingleInferenceResult::Modified => Ok(true),
             SingleInferenceResult::Unmodified => Ok(false),
             SingleInferenceResult::Incompatible => Err(()),
+        }
+    }
     /// Applies a type constraint that expects the two provided types to be
     /// equal. We attempt to make progress in inferring the types. If the call
     /// is successful then the composition of all types are made equal.
     /// The "parent" `expr_id` is provided to construct errors.
     fn apply_equal2_constraint(
         &mut self, ctx: &Ctx, expr_id: ExpressionId,
         arg1_id: ExpressionId, arg1_start_idx: usize,
         arg2_id: ExpressionId, arg2_start_idx: usize
     ) -> Result<(bool, bool), ParseError2> {
         debug_assert_expr_ids_unique_and_known!(self, arg1_id, arg2_id);
         let arg1_type: *mut _ = self.expr_types.get_mut(&arg1_id).unwrap();
         let arg2_type: *mut _ = self.expr_types.get_mut(&arg2_id).unwrap();
         let infer_res = unsafe{ InferenceType::infer_subtrees_for_both_types(
             arg1_type, arg1_start_idx,
             arg2_type, arg2_start_idx
         ) };
         if infer_res == DualInferenceResult::Incompatible {
             return Err(self.construct_arg_type_error(ctx, expr_id, arg1_id, arg2_id));
+        }
         Ok((infer_res.modified_lhs(), infer_res.modified_rhs()))
+    }
     /// Applies an equal2 constraint between a signature type (e.g. a function
     /// argument or struct field) and an expression whose type should match that
     /// expression. If we make progress on the signature, then we try to see if
     /// any of the embedded polymorphic types can be progressed.
     ///
     /// `outer_expr_id` is the main expression we're progressing (e.g. a
     /// function call), while `expr_id` is the embedded expression we're
     /// matching against the signature. `expression_type` and
     /// `expression_start_idx` belong to `expr_id`.
     fn apply_equal2_signature_constraint(
         ctx: &Ctx, outer_expr_id: ExpressionId, expr_id: Option<ExpressionId>,
         polymorph_data: &mut ExtraData, polymorph_progress: &mut HashSet<usize>,
         signature_type: *mut InferenceType, signature_start_idx: usize,
         expression_type: *mut InferenceType, expression_start_idx: usize
     ) -> Result<(bool, bool), ParseError2> {
         // Safety: cannot mutually infer the same types
         //         polymorph_data containers may not be modified
         debug_assert_ptrs_distinct!(signature_type, expression_type);
         // Infer the signature and expression type
         let infer_res = unsafe {
             InferenceType::infer_subtrees_for_both_types(
                 signature_type, signature_start_idx,
                 expression_type, expression_start_idx
+            )
         };
         if infer_res == DualInferenceResult::Incompatible {
             // TODO: Check if I still need to use this
             let outer_position = ctx.heap[outer_expr_id].position();
             let (position_name, position) = match expr_id {
                 Some(expr_id) => ("argument's", ctx.heap[expr_id].position()),
                 None => ("type's", outer_position)
             };
             let (signature_display_type, expression_display_type) = unsafe { (
                 (&*signature_type).display_name(&ctx.heap),
                 (&*expression_type).display_name(&ctx.heap)
             ) };
             return Err(ParseError2::new_error(
                 &ctx.module.source, outer_position,
                 "Failed to fully resolve the types of this expression"
             ).with_postfixed_info(
                 &ctx.module.source, position,
                 &format!(
                     "Because the {} signature has been resolved to '{}', but the expression has been resolved to '{}'",
                     position_name, signature_display_type, expression_display_type
+                )
             ));
+        }
         // Try to see if we can progress any of the polymorphic variables
         let progress_sig = infer_res.modified_lhs();
         let progress_expr = infer_res.modified_rhs();
         if progress_sig {
             let signature_type = unsafe{&mut *signature_type};
             debug_assert!(
                 signature_type.has_body_marker,
                 "made progress on signature type, but it doesn't have a marker"
             );
             for (poly_idx, poly_section) in signature_type.body_marker_iter() {
                 let polymorph_type = &mut polymorph_data.poly_vars[poly_idx];
                 match Self::apply_forced_constraint_types(
                     polymorph_type, 0, poly_section, 0
                 ) {
                     Ok(true) => { polymorph_progress.insert(poly_idx); },
                     Ok(false) => {},
                     Err(()) => { return Err(Self::construct_poly_arg_error(ctx, polymorph_data, outer_expr_id))}
+                }
+            }
+        }
         Ok((progress_sig, progress_expr))
+    }
     /// Applies equal2 constraints on the signature type for each of the
     /// polymorphic variables. If the signature type is progressed then we
     /// progress the expression type as well.
     ///
     /// This function assumes that the polymorphic variables have already been
     /// progressed as far as possible by calling
     /// `apply_equal2_signature_constraint`. As such, we expect to not encounter
     /// any errors.
     ///
     /// This function returns true if the expression's type has been progressed
     fn apply_equal2_polyvar_constraint(
         heap: &Heap,
         polymorph_data: &ExtraData, polymorph_progress: &HashSet<usize>,
         signature_type: *mut InferenceType, expr_type: *mut InferenceType
     ) -> bool {
         // Safety: all pointers should be distinct
         //         polymorph_data contains may not be modified
         debug_assert_ptrs_distinct!(signature_type, expr_type);
         let signature_type = unsafe{&mut *signature_type};
         let expr_type = unsafe{&mut *expr_type};
         // Iterate through markers in signature type to try and make progress
         // on the polymorphic variable
         let mut seek_idx = 0;
         let mut modified_sig = false;
         while let Some((poly_idx, start_idx)) = signature_type.find_body_marker(seek_idx) {
             let end_idx = InferenceType::find_subtree_end_idx(&signature_type.parts, start_idx);
             if polymorph_progress.contains(&poly_idx) {
                 // Need to match subtrees
                 let polymorph_type = &polymorph_data.poly_vars[poly_idx];
                 debug_log!("   - DEBUG: Applying {} to '{}' from '{}'", polymorph_type.display_name(heap), InferenceType::partial_display_name(heap, &signature_type.parts[start_idx..]), signature_type.display_name(heap));
                 let modified_at_marker = Self::apply_forced_constraint_types(
                     signature_type, start_idx,
                     &polymorph_type.parts, 0
                 ).expect("no failure when applying polyvar constraints");
                 modified_sig = modified_sig || modified_at_marker;
+            }
             seek_idx = end_idx;
+        }
         // If we made any progress on the signature's type, then we also need to
         // apply it to the expression that is supposed to match the signature.
         if modified_sig {
             match InferenceType::infer_subtree_for_single_type(
                 expr_type, 0, &signature_type.parts, 0
             ) {
                 SingleInferenceResult::Modified => true,
                 SingleInferenceResult::Unmodified => false,
                 SingleInferenceResult::Incompatible =>
                     unreachable!("encountered failure while reapplying modified signature to expression after polyvar inference")
+            }
         } else {
             false
+        }
+    }
     /// Applies a type constraint that expects all three provided types to be
     /// equal. In case we can make progress in inferring the types then we
     /// attempt to do so. If the call is successful then the composition of all
     /// types is made equal.
     fn apply_equal3_constraint(
         &mut self, ctx: &Ctx, expr_id: ExpressionId,
         arg1_id: ExpressionId, arg2_id: ExpressionId,
         start_idx: usize
     ) -> Result<(bool, bool, bool), ParseError2> {
         // Safety: all expression IDs are always distinct, and we do not modify
         //  the container
         debug_assert_expr_ids_unique_and_known!(self, expr_id, arg1_id, arg2_id);
         let expr_type: *mut _ = self.expr_types.get_mut(&expr_id).unwrap();
         let arg1_type: *mut _ = self.expr_types.get_mut(&arg1_id).unwrap();
         let arg2_type: *mut _ = self.expr_types.get_mut(&arg2_id).unwrap();
         let expr_res = unsafe{
             InferenceType::infer_subtrees_for_both_types(expr_type, start_idx, arg1_type, start_idx)
         };
         if expr_res == DualInferenceResult::Incompatible {
             return Err(self.construct_expr_type_error(ctx, expr_id, arg1_id));
+        }
         let args_res = unsafe{
             InferenceType::infer_subtrees_for_both_types(arg1_type, start_idx, arg2_type, start_idx) };
         if args_res == DualInferenceResult::Incompatible {
             return Err(self.construct_arg_type_error(ctx, expr_id, arg1_id, arg2_id));
+        }
         // If all types are compatible, but the second call caused the arg1_type
         // to be expanded, then we must also assign this to expr_type.
         let mut progress_expr = expr_res.modified_lhs();
         let mut progress_arg1 = expr_res.modified_rhs();
         let progress_arg2 = args_res.modified_rhs();
         if args_res.modified_lhs() {
             unsafe {
                 let end_idx = InferenceType::find_subtree_end_idx(&(*arg2_type).parts, start_idx);
                 let subtree = &((*arg2_type).parts[start_idx..end_idx]);
                 (*expr_type).replace_subtree(start_idx, subtree);
+            }
             progress_expr = true;
             progress_arg1 = true;
+        }
         Ok((progress_expr, progress_arg1, progress_arg2))
+    }
     // TODO: @optimize Since we only deal with a single type this might be done
     //  a lot more efficiently, methinks (disregarding the allocations here)
     fn apply_equal_n_constraint(
         &mut self, ctx: &Ctx, expr_id: ExpressionId, args: &[ExpressionId],
     ) -> Result<Vec<bool>, ParseError2> {
         // Early exit
         match args.len() {
 => return Ok(vec!()),         // nothing to progress
 => return Ok(vec![false]),    // only one type, so nothing to infer
             _ => {}
+        }
         let mut progress = Vec::new();
         progress.resize(args.len(), false);
         // Do pairwise inference, keep track of the last entry we made progress
         // on. Once done we need to update everything to the most-inferred type.
         let mut arg_iter = args.iter();
         let mut last_arg_id = *arg_iter.next().unwrap();
         let mut last_lhs_progressed = 0;
         let mut lhs_arg_idx = 0;
         while let Some(next_arg_id) = arg_iter.next() {
             let arg1_type: *mut _ = self.expr_types.get_mut(&last_arg_id).unwrap();
             let arg2_type: *mut _ = self.expr_types.get_mut(next_arg_id).unwrap();
             let res = unsafe {
                 InferenceType::infer_subtrees_for_both_types(arg1_type, 0, arg2_type, 0)
             };
             if res == DualInferenceResult::Incompatible {
                 return Err(self.construct_arg_type_error(ctx, expr_id, last_arg_id, *next_arg_id));
+            }
             if res.modified_lhs() {
                 // We re-inferred something on the left hand side, so everything
                 // up until now should be re-inferred.
                 progress[lhs_arg_idx] = true;
                 last_lhs_progressed = lhs_arg_idx;
+            }
             progress[lhs_arg_idx + 1] = res.modified_rhs();
             last_arg_id = *next_arg_id;
             lhs_arg_idx += 1;
+        }
         // Re-infer everything. Note that we do not need to re-infer the type
         // exactly at `last_lhs_progressed`, but only everything up to it.
         let last_type: *mut _ = self.expr_types.get_mut(args.last().unwrap()).unwrap();
         for arg_idx in 0..last_lhs_progressed {
             let arg_type: *mut _ = self.expr_types.get_mut(&args[arg_idx]).unwrap();
             unsafe{
                 (*arg_type).replace_subtree(0, &(*last_type).parts);
+            }
             progress[arg_idx] = true;
+        }
         Ok(progress)
+    }
     /// Determines the `InferenceType` for the expression based on the
     /// expression parent. Note that if the parent is another expression, we do
     /// not take special action, instead we let parent expressions fix the type
     /// of subexpressions before they have a chance to call this function.
     fn insert_initial_expr_inference_type(
         &mut self, ctx: &mut Ctx, expr_id: ExpressionId
     ) -> Result<(), ParseError2> {
         use ExpressionParent as EP;
         use InferenceTypePart as ITP;
         let expr = &ctx.heap[expr_id];
         let inference_type = match expr.parent() {
             EP::None =>
                 // Should have been set by linker
                 unreachable!(),
             EP::ExpressionStmt(_) | EP::Expression(_, _) =>
                 // Determined during type inference
                 InferenceType::new(false, false, vec![ITP::Unknown]),
             EP::If(_) | EP::While(_) | EP::Assert(_) =>
                 // Must be a boolean
                 InferenceType::new(false, true, vec![ITP::Bool]),
             EP::Return(_) =>
                 // Must match the return type of the function
                 if let DefinitionType::Function(func_id) = self.definition_type {
                     let return_parser_type_id = ctx.heap[func_id].return_type;
                     self.determine_inference_type_from_parser_type(ctx, return_parser_type_id, true)
                 } else {
                     // Cannot happen: definition always set upon body traversal
                     // and "return" calls in components are illegal.
                     unreachable!();
                 },
             EP::New(_) =>
                 // Must be a component call, which we assign a "Void" return
                 // type
                 InferenceType::new(false, true, vec![ITP::Void]),
         };
         match self.expr_types.entry(expr_id) {
             Entry::Vacant(vacant) => {
                 vacant.insert(inference_type);
             },
             Entry::Occupied(mut preexisting) => {
                 // We already have an entry, this happens if our parent fixed
                 // our type (e.g. we're used in a conditional expression's test)
                 // but we have a different type.
                 // TODO: Is this ever called? Seems like it can't
                 debug_assert!(false, "I am actually called, my ID is {}", expr_id.index);
                 let old_type = preexisting.get_mut();
                 if let SingleInferenceResult::Incompatible = InferenceType::infer_subtree_for_single_type(
                     old_type, 0, &inference_type.parts, 0
                 ) {
                     return Err(self.construct_expr_type_error(ctx, expr_id, expr_id))
+                }
+            }
+        }
         Ok(())
+    }
     fn insert_initial_call_polymorph_data(
         &mut self, ctx: &mut Ctx, call_id: CallExpressionId
     ) {
         use InferenceTypePart as ITP;
         // Note: the polymorph variables may be partially specified and may
         // contain references to the wrapping definition's (i.e. the proctype
         // we are currently visiting) polymorphic arguments.
         //
         // The arguments of the call may refer to polymorphic variables in the
         // definition of the function we're calling, not of the wrapping
         // definition. We insert markers in these inferred types to be able to
         // map them back and forth to the polymorphic arguments of the function
         // we are calling.
         let call = &ctx.heap[call_id];
         // Handle the polymorphic variables themselves
         let mut poly_vars = Vec::with_capacity(call.poly_args.len());
         for poly_arg_type_id in call.poly_args.clone() { // TODO: @performance
             poly_vars.push(self.determine_inference_type_from_parser_type(ctx, poly_arg_type_id, true));
+        }
         // Handle the arguments
         // TODO: @cleanup: Maybe factor this out for reuse in the validator/linker, should also
         //  make the code slightly more robust.
         let (embedded_types, return_type) = match &call.method {
             Method::Create => {
                 // Not polymorphic
+                (
                     vec![InferenceType::new(false, true, vec![ITP::Int])],
                     InferenceType::new(false, true, vec![ITP::Message, ITP::Byte])
+                )
             },
             Method::Fires => {
                 // bool fires<T>(PortLike<T> arg)
+                (
                     vec![InferenceType::new(true, false, vec![ITP::PortLike, ITP::MarkerBody(0), ITP::Unknown])],
                     InferenceType::new(false, true, vec![ITP::Bool])
+                )
             },
             Method::Get => {
                 // T get<T>(input<T> arg)
+                (
                     vec![InferenceType::new(true, false, vec![ITP::Input, ITP::MarkerBody(0), ITP::Unknown])],
                     InferenceType::new(true, false, vec![ITP::MarkerBody(0), ITP::Unknown])
+                )
             },
             Method::Put => {
                 // void Put<T>(output<T> port, T msg)
+                (
                     vec![
                         InferenceType::new(true, false, vec![ITP::Output, ITP::MarkerBody(0), ITP::Unknown]),
                         InferenceType::new(true, false, vec![ITP::MarkerBody(0), ITP::Unknown])
                     ],
                     InferenceType::new(false, true, vec![ITP::Void])
+                )
+            }
             Method::Symbolic(symbolic) => {
                 let definition = &ctx.heap[symbolic.definition.unwrap()];
                 match definition {
                     Definition::Component(definition) => {
                         debug_assert_eq!(poly_vars.len(), definition.poly_vars.len());
                         let mut parameter_types = Vec::with_capacity(definition.parameters.len());
                         for param_id in definition.parameters.clone() {
                             let param = &ctx.heap[param_id];
                             let param_parser_type_id = param.parser_type;
                             parameter_types.push(self.determine_inference_type_from_parser_type(ctx, param_parser_type_id, false));
+                        }
                         (parameter_types, InferenceType::new(false, true, vec![InferenceTypePart::Void]))
                     },
                     Definition::Function(definition) => {
                         debug_assert_eq!(poly_vars.len(), definition.poly_vars.len());
                         let mut parameter_types = Vec::with_capacity(definition.parameters.len());
                         for param_id in definition.parameters.clone() {
                             let param = &ctx.heap[param_id];
                             let param_parser_type_id = param.parser_type;
                             parameter_types.push(self.determine_inference_type_from_parser_type(ctx, param_parser_type_id, false));
+                        }
                         let return_type = self.determine_inference_type_from_parser_type(ctx, definition.return_type, false);
                         (parameter_types, return_type)
                     },
                     Definition::Struct(_) | Definition::Enum(_) => {
                         unreachable!("insert initial polymorph data for struct/enum");
+                    }
+                }
+            }
         };
         self.extra_data.insert(call_id.upcast(), ExtraData {
             poly_vars,
             embedded: embedded_types,
             returned: return_type
         });
+    }
     fn insert_initial_struct_polymorph_data(
         &mut self, ctx: &mut Ctx, lit_id: LiteralExpressionId,
     ) {
         use InferenceTypePart as ITP;
         let literal = ctx.heap[lit_id].value.as_struct();
         // Handle polymorphic arguments
         let mut poly_vars = Vec::with_capacity(literal.poly_args.len());
         let mut total_num_poly_parts = 0;
         for poly_arg_type_id in literal.poly_args.clone() { // TODO: @performance
             let inference_type = self.determine_inference_type_from_parser_type(
                 ctx, poly_arg_type_id, true
             );
             total_num_poly_parts += inference_type.parts.len();
             poly_vars.push(inference_type);
+        }
         // Handle parser types on struct definition
         let definition = &ctx.heap[literal.definition.unwrap()];
         let definition = match definition {
             Definition::Struct(definition) => {
                 debug_assert_eq!(poly_vars.len(), definition.poly_vars.len());
                 definition
             },
             _ => unreachable!("definition for struct literal does not point to struct definition")
         };
         // Note: programmer is capable of specifying fields in a struct literal
         // in a different order than on the definition. We take the programmer-
         // specified order to be leading.
         let mut embedded_types = Vec::with_capacity(definition.fields.len());
         for lit_field in literal.fields.iter() {
             let def_field = &definition.fields[lit_field.field_idx];
             let inference_type = self.determine_inference_type_from_parser_type(
                 ctx, def_field.parser_type, false
             );
             embedded_types.push(inference_type);
+        }
         // Return type is the struct type itself, with the appropriate
         // polymorphic variables. So:
         // - 1 part for definition
         // - N_poly_arg marker parts for each polymorphic argument
         // - all the parts for the currently known polymorphic arguments
         let parts_reserved = 1 + poly_vars.len() + total_num_poly_parts;
         let mut parts = Vec::with_capacity(parts_reserved);
         parts.push(ITP::Instance(definition.this.upcast(), poly_vars.len()));
         let mut return_type_done = true;
         for (poly_var_idx, poly_var) in poly_vars.iter().enumerate() {
             if !poly_var.is_done { return_type_done = false; }
             parts.push(ITP::MarkerBody(poly_var_idx));
             parts.extend(poly_var.parts.iter().cloned());
+        }
         debug_assert_eq!(parts.len(), parts_reserved);
         let return_type = InferenceType::new(true, return_type_done, parts);
         self.extra_data.insert(lit_id.upcast(), ExtraData{
             poly_vars,
             embedded: embedded_types,
             returned: return_type,
         });
+    }
     /// Inserts the extra polymorphic data struct. Assumes that the select
     /// expression's referenced (definition_id, field_idx) has been resolved.
     fn insert_initial_select_polymorph_data(
         &mut self, ctx: &Ctx, select_id: SelectExpressionId
     ) {
         use InferenceTypePart as ITP;
         // Retrieve relevant data
         let expr = &ctx.heap[select_id];
         let field = match &expr.field {
             Field::Symbolic(field) => field,
             _ => unreachable!(),
         };
         let definition_id = field.definition.unwrap();
         let definition = ctx.heap[definition_id].as_struct();
         let field_idx = field.field_idx;
         // Generate initial polyvar types and struct type
         let num_poly_vars = definition.poly_vars.len();
         let mut poly_vars = Vec::with_capacity(num_poly_vars);
         let struct_parts_reserved = 1 + 2 * num_poly_vars;
         let mut struct_parts = Vec::with_capacity(struct_parts_reserved);
         struct_parts.push(ITP::Instance(definition_id, num_poly_vars));
         for poly_idx in 0..num_poly_vars {
             poly_vars.push(InferenceType::new(true, false, vec![

src/protocol/tests/mod.rs

➞

Show inline comments

 mod utils;
 mod lexer;
 mod parser_validation;
 mod parser_inference;
 pub(crate) use utils::{Tester};
@@ \ No newline at end of file @@

src/protocol/tests/parser_inference.rs

➞

Show inline comments

 /// parser_inference.rs
 ///
 /// Simple tests for the type inferences
 use super::*;
 #[test]
 fn test_integer_inference() {
     Tester::new_single_source_expect_ok(
         "by arguments",
+        "
         int call(byte b, short s, int i, long l) {
             auto b2 = b;
             auto s2 = s;
             auto i2 = i;
             auto l2 = l;
             return i2;
+        }
+        "
     ).for_function("call", |f| { f
         .for_variable("b2", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("byte");
         })
         .for_variable("s2", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("short");
         })
         .for_variable("i2", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("int");
         })
         .for_variable("l2", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("long");
         });
     });
     Tester::new_single_source_expect_ok(
         "by assignment",
+        "
         int call() {
             byte b1 = 0; short s1 = 0; int i1 = 0; long l1 = 0;
             auto b2 = b1;
             auto s2 = s1;
             auto i2 = i1;
             auto l2 = l1;
             return 0;
         }"
     ).for_function("call", |f| { f
         .for_variable("b2", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("byte");
         })
         .for_variable("s2", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("short");
         })
         .for_variable("i2", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("int");
         })
         .for_variable("l2", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("long");
         });
     });
+}
 #[test]
 fn test_struct_inference() {
     // Tester::new_single_source_expect_ok(
     //     "by function calls",
     //     "
     //     struct Pair<T1, T2>{ T1 first, T2 second }
     //     Pair<T1, T2> construct<T1, T2>(T1 first, T2 second) {
     //         return Pair{ first: first, second: second };
     //     }
     //     int fix_t1<T2>(Pair<byte, T2> arg) { return 0; }
     //     int fix_t2<T1>(Pair<T1, int> arg) { return 0; }
     //     int test() {
     //         auto first = 0;
     //         auto second = 1;
     //         auto pair = construct(first, second);
     //         fix_t1(pair);
     //         fix_t2(pair);
     //         return 0;
     //     }
     //     "
     // ).for_function("test", |f| { f
     //     .for_variable("first", |v| { v
     //         .assert_parser_type("auto")
     //         .assert_concrete_type("byte");
     //     })
     //     .for_variable("second", |v| { v
     //         .assert_parser_type("auto")
     //         .assert_concrete_type("int");
     //     })
     //     .for_variable("pair", |v| { v
     //         .assert_parser_type("auto")
     //         .assert_concrete_type("Pair<byte,int>");
     //     });
     // });
     // Tester::new_single_source_expect_ok(
     //     "by field access",
     //     "
     //     struct Pair<T1, T2>{ T1 first, T2 second }
     //     Pair<T1, T2> construct<T1, T2>(T1 first, T2 second) {
     //         return Pair{ first: first, second: second };
     //     }
     //     int test() {
     //         auto first = 0;
     //         auto second = 1;
     //         auto pair = construct(first, second);
     //         byte assign_first = 0;
     //         long assign_second = 1;
     //         pair.first = assign_first;
     //         pair.second = assign_second;
     //         return 0;
     //     }
     //     "
     // ).for_function("test", |f| { f
     //     .for_variable("first", |v| { v
     //         .assert_parser_type("auto")
     //         .assert_concrete_type("byte");
     //     })
     //     .for_variable("second", |v| { v
     //         .assert_parser_type("auto")
     //         .assert_concrete_type("long");
     //     })
     //     .for_variable("pair", |v| { v
     //         .assert_parser_type("auto")
     //         .assert_concrete_type("Pair<byte,long>");
     //     });
     // });
     Tester::new_single_source_expect_ok(
         "by nested field access",
+        "
         struct Node<T1, T2>{ T1 l, T2 r }
         Node<T1, T2> construct<T1, T2>(T1 l, T2 r) { return Node{ l: l, r: r }; }
         int fix_poly<T>(Node<T, T> a) { return 0; }
         int test() {
             byte assigned = 0;
             auto thing = construct(assigned, construct(0, 1));
             fix_poly(thing.r);
             thing.r.r = assigned;
             return 0;
+        }
         ",
     ).for_function("test", |f| { f
         .for_variable("thing", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("Pair<byte,Pair<byte,byte>>");
         });
     });
+}
@@ \ No newline at end of file @@

src/protocol/tests/parser_validation.rs

➞

Show inline comments

 /// parser_validation.rs
 ///
 /// Simple tests for the validation phase
 /// TODO: If semicolon behind struct definition: should be fine...
 use super::*;
 #[test]
 fn test_correct_struct_instance() {
     Tester::new_single_source_expect_ok(
         "single field",
+        "
         struct Foo { int a }
         Foo bar(int arg) { return Foo{ a: arg }; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple fields",
+        "
         struct Foo { int a, int b }
         Foo bar(int arg) { return Foo{ a: arg, b: arg }; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "single field, explicit polymorph",
+        "
         struct Foo<T>{ T field }
         Foo<int> bar(int arg) { return Foo<int>{ field: arg }; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "single field, implicit polymorph",
+        "
         struct Foo<T>{ T field }
         int bar(int arg) {
             auto thingo = Foo{ field: arg };
             return arg;
+        }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple fields, same explicit polymorph",
+        "
         struct Pair<T1, T2>{ T1 first, T2 second }
         int bar(int arg) {
             auto qux = Pair<int, int>{ first: arg, second: arg };
             return arg;
+        }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple fields, same implicit polymorph",
+        "
         struct Pair<T1, T2>{ T1 first, T2 second }
         int bar(int arg) {
             auto wup = Pair{ first: arg, second: arg };
             return arg;
+        }
+        "
     );
-    Tester::new_single_source_expr_ok(
+    Tester::new_single_source_expect_ok(
         "multiple fields, different explicit polymorph",
+        "
         struct Pair<T1, T2>{ T1 first, T2 second }
         int bar(int arg1, byte arg2) {
             auto shoo = Pair<int, byte>{ first: arg1, second: arg2 };
             return arg1;
+        }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple fields, different implicit polymorph",
+        "
         struct Pair<T1, T2>{ T1 first, T2 second }
         int bar(int arg1, byte arg2) {
             auto shrubbery = Pair{ first: arg1, second: arg2 };
             return arg1;
+        }
+        "
     );
+}
@@ \ No newline at end of file @@

src/protocol/tests/utils.rs

➞

Show inline comments

 use crate::protocol::ast::*;
 use crate::protocol::inputsource::*;
 use crate::protocol::parser::*;
 //------------------------------------------------------------------------------
 // Interface for parsing and compiling
 //------------------------------------------------------------------------------
 pub(crate) struct Tester {
     test_name: String,
     sources: Vec<String>
+}
 impl Tester {
     /// Constructs a new tester, allows adding multiple sources before compiling
     pub(crate) fn new<S: ToString>(test_name: S) -> Self {
         Self{
             test_name: test_name.to_string(),
             sources: Vec::new()
+        }
+    }
     /// Utility for quick tests that use a single source file and expect the
     /// compilation to succeed.
     pub(crate) fn new_single_source_expect_ok<T: ToString, S: ToString>(test_name: T, source: S) -> AstOkTester {
         Self::new(test_name)
             .with_source(source)
             .compile()
             .expect_ok()
+    }
     /// Utility for quick tests that use a single source file and expect the
     /// compilation to fail.
     pub(crate) fn new_single_source_expect_err<T: ToString, S: ToString>(test_name: T, source: S) -> AstErrTester {
         Self::new(test_name)
             .with_source(source)
             .compile()
             .expect_err()
+    }
     pub(crate) fn with_source<S: ToString>(mut self, source: S) -> Self {
         self.sources.push(source.to_string());
         self
+    }
     pub(crate) fn compile(self) -> AstTesterResult {
         let mut parser = Parser::new();
         for (source_idx, source) in self.sources.into_iter().enumerate() {
             let mut cursor = std::io::Cursor::new(source);
             let input_source = InputSource::new("", &mut cursor)
                 .expect(&format!("parsing source {}", source_idx + 1));
             if let Err(err) = parser.feed(input_source) {
                 return AstTesterResult::Err(AstErrTester::new(self.test_name, err))
+            }
+        }
         parser.compile();
         if let Err(err) = parser.parse() {
             return AstTesterResult::Err(AstErrTester::new(self.test_name, err))
+        }
         AstTesterResult::Ok(AstOkTester::new(self.test_name, parser))
+    }
+}
 pub(crate) enum AstTesterResult {
     Ok(AstOkTester),
     Err(AstErrTester)
+}
 impl AstTesterResult {
     pub(crate) fn expect_ok(self) -> AstOkTester {
         match self {
             AstTesterResult::Ok(v) => v,
             AstTesterResult::Err(err) => {
                 let wrapped = ErrorTester{ test_name: &err.test_name, error: &err.error };
                 println!("DEBUG: Full error:\n{}", &err.error);
                 assert!(
                     false,
                     "[{}] Expected compilation to succeed, but it failed with {}",
                     err.test_name, wrapped.assert_postfix()
                 );
                 unreachable!();
+            }
+        }
+    }
     pub(crate) fn expect_err(self) -> AstErrTester {
         match self {
             AstTesterResult::Ok(ok) => {
                 assert!(false, "[{}] Expected compilation to fail, but it succeeded", ok.test_name);
                 unreachable!();
             },
             AstTesterResult::Err(err) => err,
+        }
+    }
+}
 //------------------------------------------------------------------------------
 // Interface for successful compilation
 //------------------------------------------------------------------------------
 pub(crate) struct AstOkTester {
     test_name: String,
     modules: Vec<LexedModule>,
     heap: Heap,
+}
 impl AstOkTester {
     fn new(test_name: String, parser: Parser) -> Self {
         Self {
             test_name,
             modules: parser.modules,
             heap: parser.heap
+        }
+    }
     pub(crate) fn for_struct<F: Fn(StructTester)>(self, name: &str, f: F) -> Self {
         let mut found = false;
         for definition in self.heap.definitions.iter() {
             if let Definition::Struct(definition) = definition {
                 if String::from_utf8_lossy(&definition.identifier.value) != name {
                     continue;
+                }
                 // Found struct with the same name
                 let tester = StructTester::new(&self.test_name, definition, &self.heap);
                 f(tester);
                 found = true;
                 break
+            }
+        }
         if found { return self }
         assert!(
             false, "[{}] Failed to find definition for struct '{}'",
             self.test_name, name
         );
         unreachable!()
+    }
     pub(crate) fn for_function<F: Fn(FunctionTester)>(self, name: &str, f: F) -> Self {
         let mut found = false;
         for definition in self.heap.definitions.iter() {
             if let Definition::Function(definition) = definition {
                 if String::from_utf8_lossy(&definition.identifier.value) != name {
                     continue;
+                }
                 // Found function
                 let tester = FunctionTester::new(&self.test_name, definition, &self.heap);
                 f(tester);
                 found = true;
                 break;
+            }
+        }
         if found { return self }
         assert!(
             false, "[{}] failed to find definition for function '{}'",
             self.test_name, name
         );
         unreachable!();
+    }
+}
 //------------------------------------------------------------------------------
 // Utilities for successful compilation
 //------------------------------------------------------------------------------
 pub(crate) struct StructTester<'a> {
     test_name: &'a str,
     def: &'a StructDefinition,
     heap: &'a Heap,
+}
 impl<'a> StructTester<'a> {
     fn new(test_name: &'a str, def: &'a StructDefinition, heap: &'a Heap) -> Self {
         Self{ test_name, def, heap }
+    }
     pub(crate) fn assert_num_fields(self, num: usize) -> Self {
-        debug_assert_eq!(
+        assert_eq!(
             num, self.def.fields.len(),
             "[{}] Expected {} struct fields, but found {} for {}",
             self.test_name, num, self.def.fields.len(), self.assert_postfix()
         );
         self
+    }
     pub(crate) fn for_field<F: Fn(StructFieldTester)>(self, name: &str, f: F) -> Self {
         // Find field with specified name
         for field in &self.def.fields {
             if String::from_utf8_lossy(&field.field.value) == name {
                 let tester = StructFieldTester::new(self.test_name, field, self.heap);
                 f(tester);
                 return self;
+            }
+        }
         assert!(
             false, "[{}] Could not find struct field '{}' for {}",
             self.test_name, name, self.assert_postfix()
         );
         unreachable!();
+    }
     fn assert_postfix(&self) -> String {
         let mut v = String::new();
         v.push_str("Struct{ name: ");
         v.push_str(&String::from_utf8_lossy(&self.def.identifier.value));
         v.push_str(", fields: [");
         for (field_idx, field) in self.def.fields.iter().enumerate() {
             if field_idx != 0 { v.push_str(", "); }
             v.push_str(&String::from_utf8_lossy(&field.field.value));
+        }
         v.push_str("] }");
+        v
+    }
+}
 pub(crate) struct StructFieldTester<'a> {
     test_name: &'a str,
     def: &'a StructFieldDefinition,
     heap: &'a Heap,
+}
 impl<'a> StructFieldTester<'a> {
     fn new(test_name: &'a str, def: &'a StructFieldDefinition, heap: &'a Heap) -> Self {
         Self{ test_name, def, heap }
+    }
     pub(crate) fn assert_parser_type(self, expected: &str) -> Self {
         let mut serialized_type = String::new();
         serialize_parser_type(&mut serialized_type, &self.heap, self.def.parser_type);
-        debug_assert_eq!(
+        assert_eq!(
             expected, &serialized_type,
             "[{}] Expected type '{}', but got '{}' for {}",
             self.test_name, expected, &serialized_type, self.assert_postfix()
         );
         self
+    }
     fn assert_postfix(&self) -> String {
         let mut serialized_type = String::new();
         serialize_parser_type(&mut serialized_type, &self.heap, self.def.parser_type);
         format!(
             "StructField{{ name: {}, parser_type: {} }}",
             String::from_utf8_lossy(&self.def.field.value), serialized_type
+        )
+    }
+}
 pub(crate) struct FunctionTester<'a> {
     test_name: &'a str,
     def: &'a Function,
     heap: &'a Heap,
+}
 impl<'a> FunctionTester<'a> {
     fn new(test_name: &'a str, def: &'a Function, heap: &'a Heap) -> Self {
         Self{ test_name, def, heap }
+    }
     pub(crate) fn for_variable<F: Fn(VariableTester)>(self, name: &str, f: F) -> Self {
         // Find the memory statement in order to find the local
         let mem_stmt_id = seek_stmt(
             self.heap, self.def.body,
             |stmt| {
+            &|stmt| {
                 if let Statement::Local(local) = stmt {
                     if let LocalStatement::Memory(memory) = local {
                         let local = &self.heap[memory.variable];
                         if local.identifier.value == name.as_bytes() {
                             return true;
+                        }
+                    }
+                }
                 false
+            }
         );
         match mem_stmt_id {
             Some(mem_stmt_id) => {
                 // TODO: Retrieve shit
             },
             None => {
                 // TODO: Throw error
         assert!(
             mem_stmt_id.is_some(), "[{}] Failed to find variable '{}' in {}",
             self.test_name, name, self.assert_postfix()
         );
         let mem_stmt_id = mem_stmt_id.unwrap();
         let local_id = self.heap[mem_stmt_id].as_memory().variable;
         let local = &self.heap[local_id];
         // Find the assignment expression that follows it
         let assignment_id = seek_expr_in_stmt(
             self.heap, self.def.body,
             &|expr| {
                 if let Expression::Assignment(assign_expr) = expr {
                     if let Expression::Variable(variable_expr) = &self.heap[assign_expr.left] {
                         if variable_expr.position.offset == local.identifier.position.offset {
                             return true;
+                        }
+                    }
+                }
                 false
+            }
         );
         assert!(
             assignment_id.is_some(), "[{}] Failed to find assignment to variable '{}' in {}",
             self.test_name, name, self.assert_postfix()
         );
         let assignment = &self.heap[assignment_id.unwrap()];
         // Construct tester and pass to tester function
         let tester = VariableTester::new(
             self.test_name, self.def.this.upcast(), local,
             assignment.as_assignment(), self.heap
         );
         f(tester);
         self
+    }
     fn assert_postfix(&self) -> String {
         format!(
             "Function{{ name: {} }}",
             &String::from_utf8_lossy(&self.def.identifier.value)
+        )
+    }
+}
 pub(crate) struct VariableTester<'a> {
     test_name: &'a str,
     def: &'a Local,
     definition_id: DefinitionId,
     local: &'a Local,
     assignment: &'a AssignmentExpression,
     heap: &'a Heap,
+}
 impl<'a> VariableTester<'a> {
     fn new(
         test_name: &'a str, definition_id: DefinitionId, local: &'a Local, assignment: &'a AssignmentExpression, heap: &'a Heap
     ) -> Self {
         Self{ test_name, definition_id, local, assignment, heap }
+    }
     pub(crate) fn assert_parser_type(self, expected: &str) -> Self {
         let mut serialized = String::new();
         serialize_parser_type(&mut serialized, self.heap, self.local.parser_type);
         assert_eq!(
             expected, &serialized,
             "[{}] Expected parser type '{}', but got '{}' for {}",
             self.test_name, expected, &serialized, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_concrete_type(self, expected: &str) -> Self {
         let mut serialized = String::new();
         serialize_concrete_type(
             &mut serialized, self.heap, self.definition_id,
             &self.assignment.concrete_type
         );
         assert_eq!(
             expected, &serialized,
             "[{}] Expected concrete type '{}', but got '{}' for {}",
             self.test_name, expected, &serialized, self.assert_postfix()
         );
         self
+    }
     fn assert_postfix(&self) -> String {
         format!(
             "Variable{{ name: {} }}",
             &String::from_utf8_lossy(&self.local.identifier.value)
+        )
+    }
+}
 //------------------------------------------------------------------------------
 // Interface for failed compilation
 //------------------------------------------------------------------------------
 pub(crate) struct AstErrTester {
     test_name: String,
     error: ParseError2,
+}
 impl AstErrTester {
     fn new(test_name: String, error: ParseError2) -> Self {
         Self{ test_name, error }
+    }
     pub(crate) fn error<F: Fn(ErrorTester)>(&self, f: F) {
         // Maybe multiple errors will be supported in the future
         let tester = ErrorTester{ test_name: &self.test_name, error: &self.error };
         f(tester)
+    }
+}
 //------------------------------------------------------------------------------
 // Utilities for failed compilation
 //------------------------------------------------------------------------------
 pub(crate) struct ErrorTester<'a> {
     test_name: &'a str,
     error: &'a ParseError2,
+}
 impl<'a> ErrorTester<'a> {
     pub(crate) fn assert_num(self, num: usize) -> Self {
         assert_eq!(
             num, self.error.statements.len(),
             "[{}] expected error to consist of '{}' parts, but encountered '{}' for {}",
             self.test_name, num, self.error.statements.len(), self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_ctx_has(self, idx: usize, msg: &str) -> Self {
         assert!(
             self.error.statements[idx].context.contains(msg),
             "[{}] expected error statement {}'s context to contain '{}' for {}",
             self.test_name, idx, msg, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_msg_has(self, idx: usize, msg: &str) -> Self {
         assert!(
             self.error.statements[idx].message.contains(msg),
             "[{}] expected error statement {}'s message to contain '{}' for {}",
             self.test_name, idx, msg, self.assert_postfix()
         );
         self
+    }
     /// Seeks the index of the pattern in the context message, then checks if
     /// the input position corresponds to that index.
     pub (crate) fn assert_occurs_at(self, idx: usize, pattern: &str) -> Self {
         let pos = self.error.statements[idx].context.find(pattern);
         assert!(
             pos.is_some(),
             "[{}] incorrect occurs_at: '{}' could not be found in the context for {}",
             self.test_name, pattern, self.assert_postfix()
         );
         let pos = pos.unwrap();
         let col = self.error.statements[idx].position.col();
         assert_eq!(
             pos + 1, col,
             "[{}] Expected error to occur at column {}, but found it at {} for {}",
             self.test_name, pos + 1, col, self.assert_postfix()
         );
         self
+    }
     fn assert_postfix(&self) -> String {
         let mut v = String::new();
         v.push_str("error: [");
         for (idx, stmt) in self.error.statements.iter().enumerate() {
             if idx != 0 {
                 v.push_str(", ");
+            }
             v.push_str(&format!("{{ context: {}, message: {} }}", &stmt.context, stmt.message));
+        }
         v.push(']');
+        v
+    }
+}
 //------------------------------------------------------------------------------
 // Generic utilities
 //------------------------------------------------------------------------------
 fn serialize_parser_type(buffer: &mut String, heap: &Heap, id: ParserTypeId) {
     use ParserTypeVariant as PTV;
     let p = &heap[id];
     match &p.variant {
         PTV::Message => buffer.push_str("msg"),
         PTV::Bool => buffer.push_str("bool"),
         PTV::Byte => buffer.push_str("byte"),
         PTV::Short => buffer.push_str("short"),
         PTV::Int => buffer.push_str("int"),
         PTV::Long => buffer.push_str("long"),
         PTV::String => buffer.push_str("string"),
         PTV::IntegerLiteral => buffer.push_str("intlit"),
         PTV::Inferred => buffer.push_str("auto"),
         PTV::Array(sub_id) => {
             serialize_parser_type(buffer, heap, *sub_id);
             buffer.push_str("[]");
         },
         PTV::Input(sub_id) => {
             buffer.push_str("in<");
             serialize_parser_type(buffer, heap, *sub_id);
             buffer.push('>');
         },
         PTV::Output(sub_id) => {
             buffer.push_str("out<");
             serialize_parser_type(buffer, heap, *sub_id);
             buffer.push('>');
         },
         PTV::Symbolic(symbolic) => {
             buffer.push_str(&String::from_utf8_lossy(&symbolic.identifier.value));
             if symbolic.poly_args.len() > 0 {
                 buffer.push('<');
                 for (poly_idx, poly_arg) in symbolic.poly_args.iter().enumerate() {
                     if poly_idx != 0 { buffer.push(','); }
                     serialize_parser_type(buffer, heap, *poly_arg);
+                }
                 buffer.push('>');
+            }
+        }
+    }
+}
 fn seek_stmt<F: Fn(&Statement) -> bool>(heap: &Heap, start: StatementId, f: F) -> Option<StatementId> {
 fn serialize_concrete_type(buffer: &mut String, heap: &Heap, def: DefinitionId, concrete: &ConcreteType) {
     // Retrieve polymorphic variables, if present (since we're dealing with a
     // concrete type we only expect procedure types)
     let poly_vars = match &heap[def] {
         Definition::Function(func) => &func.poly_vars,
         Definition::Component(comp) => &comp.poly_vars,
         _ => unreachable!("Error in testing utility: did not expect non-procedure type for concrete type serialization"),
     };
     fn serialize_recursive(
         buffer: &mut String, heap: &Heap, poly_vars: &Vec<Identifier>, concrete: &ConcreteType, mut idx: usize
     ) -> usize {
         use ConcreteTypePart as CTP;
         let part = &concrete.parts[idx];
         match part {
             CTP::Marker(poly_idx) => {
                 buffer.push_str(&String::from_utf8_lossy(&poly_vars[*poly_idx].value));
             },
             CTP::Void => buffer.push_str("void"),
             CTP::Message => buffer.push_str("msg"),
             CTP::Bool => buffer.push_str("bool"),
             CTP::Byte => buffer.push_str("byte"),
             CTP::Short => buffer.push_str("short"),
             CTP::Int => buffer.push_str("int"),
             CTP::Long => buffer.push_str("long"),
             CTP::String => buffer.push_str("string"),
             CTP::Array => {
                 idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);
                 buffer.push_str("[]");
                 idx += 1;
             },
             CTP::Slice => {
                 idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);
                 buffer.push_str("[..]");
                 idx += 1;
             },
             CTP::Input => {
                 buffer.push_str("in<");
                 idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);
                 buffer.push('>');
                 idx += 1;
             },
             CTP::Output => {
                 buffer.push_str("out<");
                 idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);
                 buffer.push('>');
                 idx += 1
             },
             CTP::Instance(definition_id, num_sub) => {
                 let definition_name = heap[*definition_id].identifier();
                 buffer.push_str(&String::from_utf8_lossy(&definition_name.value));
                 buffer.push('<');
                 for sub_idx in 0..*num_sub {
                     if sub_idx != 0 { buffer.push(','); }
                     idx = serialize_recursive(buffer, heap, poly_vars, concrete, idx + 1);
+                }
                 buffer.push('>');
                 idx += 1;
+            }
+        }
         idx
+    }
     serialize_recursive(buffer, heap, poly_vars, concrete, 0);
+}
 fn seek_stmt<F: Fn(&Statement) -> bool>(heap: &Heap, start: StatementId, f: &F) -> Option<StatementId> {
     let stmt = &heap[start];
     if f(stmt) { return Some(start); }
     // This statement wasn't it, try to recurse
     let matched = match stmt {
         Statement::Block(block) => {
             for sub_id in &block.statements {
                 if let Some(id) = seek_stmt(heap, *sub_id, f) {
                     return Some(id);
+                }
+            }
             None
         },
         Statement::Labeled(stmt) => seek_stmt(heap, stmt.body, f),
         Statement::If(stmt) => {
             if let Some(id) = seek_stmt(heap,stmt.true_body, f) {
                 return Some(id);
             } else if let Some(id) = seek_stmt(heap, stmt.false_body, f) {
                 return Some(id);
+            }
             None
         },
         Statement::While(stmt) => seek_stmt(heap, stmt.body, f),
         Statement::Synchronous(stmt) => seek_stmt(heap, stmt.body, f),
         _ => None
     };
     matched
+}
 fn seek_expr_in_expr<F: Fn(&Expression) -> bool>(heap: &Heap, start: ExpressionId, f: F) -> Option<ExpressionId> {
+fn seek_expr_in_expr<F: Fn(&Expression) -> bool>(heap: &Heap, start: ExpressionId, f: &F) -> Option<ExpressionId> {
     let expr = &heap[start];
     if f(expr) { return Some(start); }
     match expr {
         Expression::Assignment(expr) => {
             None
             .or_else(|| seek_expr_in_expr(heap, expr.left, f))
             .or_else(|| seek_expr_in_expr(heap, expr.right, f))
         },
         Expression::Conditional(expr) => {
             None
             .or_else(|| seek_expr_in_expr(heap, expr.test, f))
             .or_else(|| seek_expr_in_expr(heap, expr.true_expression, f))
             .or_else(|| seek_expr_in_expr(heap, expr.false_expression, f))
         },
         Expression::Binary(expr) => {
             None
             .or_else(|| seek_expr_in_expr(heap, expr.left, f))
             .or_else(|| seek_expr_in_expr(heap, expr.right, f))
         },
         Expression::Unary(expr) => {
             seek_expr_in_expr(heap, expr.expression, f)
         },
         Expression::Indexing(expr) => {
             None
             .or_else(|| seek_expr_in_expr(heap, expr.subject, f))
             .or_else(|| seek_expr_in_expr(heap, expr.index, f))
         },
         Expression::Slicing(expr) => {
             None
             .or_else(|| seek_expr_in_expr(heap, expr.subject, f))
             .or_else(|| seek_expr_in_expr(heap, expr.from_index, f))
             .or_else(|| seek_expr_in_expr(heap, expr.to_index, f))
         },
         Expression::Select(expr) => {
             seek_expr_in_expr(heap, expr.subject, f)
         },
         Expression::Array(expr) => {
             for element in &expr.elements {
                 if let Some(id) = seek_expr_in_expr(heap, *element, f) {
                     return Some(id)
+                }
+            }
             None
         },
         Expression::Literal(expr) => {
             if let Literal::Struct(lit) = expr.value {
+            if let Literal::Struct(lit) = &expr.value {
                 for field in &lit.fields {
                     if let Some(id) = seek_expr_in_expr(heap, field.value, f) {
                         return Some(id)
+                    }
+                }
+            }
             None
         },
         Expression::Call(expr) => {
             for arg in &expr.arguments {
                 if let Some(id) = seek_expr_in_expr(heap, *arg, f) {
                     return Some(id)
+                }
+            }
             None
         },
         Expression::Variable(expr) => {
             None
+        }
+    }
+}
 fn seek_expr_in_stmt<F: Fn(&Expression) -> bool>(heap: &Heap, start: StatementId, f: F) -> Option<ExpressionId> {
+fn seek_expr_in_stmt<F: Fn(&Expression) -> bool>(heap: &Heap, start: StatementId, f: &F) -> Option<ExpressionId> {
     let stmt = &heap[start];
     match stmt {
         Statement::Block(stmt) => {
             for stmt_id in &stmt.statements {
                 if let Some(id) = seek_expr_in_stmt(heap, *stmt_id, f) {
                     return Some(id)
+                }
+            }
             None
         },
         Statement::Labeled(stmt) => {
             seek_expr_in_stmt(heap, stmt.body, f)
         },
         Statement::If(stmt) => {
             None
             .or_else(|| seek_expr_in_expr(heap, stmt.test, f))
             .or_else(|| seek_expr_in_stmt(heap, stmt.true_body, f))
             .or_else(|| seek_expr_in_stmt(heap, stmt.false_body, f))
         },
         Statement::While(stmt) => {
             None
             .or_else(|| seek_expr_in_expr(heap, stmt.test, f))
             .or_else(|| seek_expr_in_stmt(heap, stmt.body, f))
         },
         Statement::Synchronous(stmt) => {
             seek_expr_in_stmt(heap, stmt.body, f)
         },
         Statement::Return(stmt) => {
             seek_expr_in_expr(heap, stmt.expression, f)
         },
         Statement::Assert(stmt) => {
             seek_expr_in_expr(heap, stmt.expression, f)
         },
         Statement::New(stmt) => {
             seek_expr_in_expr(heap, stmt.expression.upcast(), f)
         },
         Statement::Expression(stmt) => {
             seek_expr_in_expr(heap, stmt.expression, f)
         },
         _ => None
+    }
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)