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

Changeset - fc2d65a1b906

Parent rev.

Child rev.

[Not reviewed]

0 18 0

MH - 4 years ago 2021-05-04 14:56:16
contact@maxhenger.nl

WIP on fixing all newly introduced bugs

18 files changed with 389 insertions and 303 deletions:

src/collections/scoped_buffer.rs

src/protocol/input_source.rs

src/protocol/parser/mod.rs

src/protocol/parser/pass_definitions.rs

src/protocol/parser/pass_imports.rs

src/protocol/parser/pass_symbols.rs

src/protocol/parser/pass_tokenizer.rs

src/protocol/parser/pass_typing.rs

src/protocol/parser/pass_validation_linking.rs

src/protocol/parser/token_parsing.rs

src/protocol/parser/tokens.rs

src/protocol/parser/visitor.rs

src/protocol/tests/lexer.rs

src/protocol/tests/parser_imports.rs

src/protocol/tests/parser_inference.rs

src/protocol/tests/parser_monomorphs.rs

src/protocol/tests/parser_validation.rs

src/protocol/tests/utils.rs

0 comments (0 inline, 0 general)

src/collections/scoped_buffer.rs

➞

Show inline comments

 use std::iter::FromIterator;
 /// scoped_buffer.rs
 ///
 /// Solves the common pattern where we are performing some kind of recursive
 /// pattern while using a temporary buffer. At the start, or during the
 /// procedure, we push stuff into the buffer. At the end we take out what we
 /// have put in.
 ///
 /// It is unsafe because we're using pointers to circumvent borrowing rules in
 /// the name of code cleanliness. The correctness of use is checked in debug
 /// mode.
 use std::iter::FromIterator;
 pub(crate) struct ScopedBuffer<T: Sized> {
     pub inner: Vec<T>,
+}
 /// A section of the buffer. Keeps track of where we started the section. When
 /// done with the section one must call `into_vec` or `forget` to remove the
 /// section from the underlying buffer.
 /// section from the underlying buffer. This will also be done upon dropping the
 /// ScopedSection in case errors are being handled.
 pub(crate) struct ScopedSection<T: Sized> {
     inner: *mut Vec<T>,
     start_size: u32,
     #[cfg(debug_assertions)] cur_size: u32,
+}
 impl<T: Sized> ScopedBuffer<T> {
     pub(crate) fn new_reserved(capacity: usize) -> Self {
         Self { inner: Vec::with_capacity(capacity) }
+    }
     pub(crate) fn start_section(&mut self) -> ScopedSection<T> {
         let start_size = self.inner.len() as u32;
         ScopedSection {
             inner: &mut self.inner,
             start_size,
             cur_size: start_size
+        }
+    }
+}
 impl<T: Clone> ScopedBuffer<T> {
     pub(crate) fn start_section_initialized(&mut self, initialize_with: &[T]) -> ScopedSection<T> {
         let start_size = self.inner.len() as u32;
         let data_size = initialize_with.len() as u32;
         self.inner.extend_from_slice(initialize_with);
         ScopedSection{
             inner: &mut self.inner,
             start_size,
             cur_size: start_size + data_size,
+        }
+    }
+}
 #[cfg(debug_assertions)]
 impl<T: Sized> Drop for ScopedBuffer<T> {
     fn drop(&mut self) {
         // Make sure that everyone cleaned up the buffer neatly
         debug_assert!(self.inner.is_empty(), "dropped non-empty scoped buffer");
+    }
+}
 impl<T: Sized> ScopedSection<T> {
     #[inline]
     pub(crate) fn push(&mut self, value: T) {
         let vec = unsafe{&mut *self.inner};
         debug_assert_eq!(vec.len(), self.cur_size as usize, "trying to push onto section, but size is larger than expected");
         vec.push(value);
         if cfg!(debug_assertions) { self.cur_size += 1; }
+    }
     pub(crate) fn len(&self) -> usize {
         let vec = unsafe{&mut *self.inner};
         debug_assert_eq!(vec.len(), self.cur_size as usize, "trying to get section length, but size is larger than expected");
         return vec.len() - self.start_size as usize;
+    }
     #[inline]
     pub(crate) fn forget(self) {
+    pub(crate) fn forget(mut self) {
         let vec = unsafe{&mut *self.inner};
         debug_assert_eq!(vec.len(), self.cur_size as usize, "trying to forget section, but size is larger than expected");
         if cfg!(debug_assertions) {
             debug_assert_eq!(
                 vec.len(), self.cur_size as usize,
                 "trying to forget section, but size is larger than expected"
             );
             self.cur_size = self.start_size;
+        }
         vec.truncate(self.start_size as usize);
+    }
     #[inline]
     pub(crate) fn into_vec(self) -> Vec<T> {
+    pub(crate) fn into_vec(mut self) -> Vec<T> {
         let vec = unsafe{&mut *self.inner};
         debug_assert_eq!(vec.len(), self.cur_size as usize, "trying to turn section into vec, but size is larger than expected");
         if cfg!(debug_assertions) {
             debug_assert_eq!(
                 vec.len(), self.cur_size as usize,
                 "trying to turn section into vec, but size is larger than expected"
             );
             self.cur_size = self.start_size;
+        }
         let section = Vec::from_iter(vec.drain(self.start_size as usize..));
         section
+    }
+}
 impl<T: Sized> std::ops::Index<usize> for ScopedSection<T> {
     type Output = T;
     fn index(&self, idx: usize) -> &Self::Output {
         let vec = unsafe{&*self.inner};
         return &vec[self.start_size as usize + idx]
+    }
+}
 #[cfg(debug_assertions)]
 impl<T: Sized> Drop for ScopedSection<T> {
     fn drop(&mut self) {
         // Make sure that the data was actually taken out of the scoped section
         let vec = unsafe{&*self.inner};
         debug_assert_eq!(vec.len(), self.start_size as usize);
         let mut vec = unsafe{&mut *self.inner};
         debug_assert_eq!(vec.len(), self.cur_size as usize);
         vec.truncate(self.start_size as usize);
+    }
+}
@@ \ No newline at end of file @@

src/protocol/input_source.rs

➞

Show inline comments

 use std::fmt;
 use std::sync::{RwLock, RwLockReadGuard};
 use std::fmt::Write;
 #[derive(Debug, Clone, Copy)]
 pub struct InputPosition {
     pub line: u32,
     pub offset: u32,
+}
 impl InputPosition {
     pub(crate) fn with_offset(&self, offset: u32) -> Self {
         InputPosition { line: self.line, offset: self.offset + offset }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub struct InputSpan {
     pub begin: InputPosition,
     pub end: InputPosition,
+}
 impl InputSpan {
     #[inline]
     pub fn from_positions(begin: InputPosition, end: InputPosition) -> Self {
         Self { begin, end }
+    }
+}
 /// Wrapper around source file with optional filename. Ensures that the file is
 /// only scanned once.
 pub struct InputSource {
     pub(crate) filename: String,
     pub(crate) input: Vec<u8>,
     // Iteration
     line: u32,
     offset: usize,
     // State tracking
     pub(crate) had_error: Option<ParseError>,
     // The offset_lookup is built on-demand upon attempting to report an error.
     // Only one procedure will actually create the lookup, afterwards only read
     // locks will be held.
     offset_lookup: RwLock<Vec<u32>>,
+}
 impl InputSource {
     pub fn new(filename: String, input: Vec<u8>) -> Self {
         Self{
             filename,
             input,
             line: 1,
             offset: 0,
             had_error: None,
             offset_lookup: RwLock::new(Vec::new()),
+        }
+    }
     #[cfg(test)]
     pub fn new_test(input: &str) -> Self {
         let bytes = Vec::from(input.as_bytes());
         return Self::new(String::from("test"), bytes)
+    }
     #[inline]
     pub fn pos(&self) -> InputPosition {
         InputPosition { line: self.line, offset: self.offset as u32 }
+    }
     pub fn next(&self) -> Option<u8> {
         if self.offset < self.input.len() {
             Some(self.input[self.offset])
         } else {
             None
+        }
+    }
     pub fn lookahead(&self, offset: usize) -> Option<u8> {
         let offset_pos = self.offset + offset;
         if offset_pos < self.input.len() {
             Some(self.input[offset_pos])
         } else {
             None
+        }
+    }
     #[inline]
     pub fn section_at_pos(&self, start: InputPosition, end: InputPosition) -> &[u8] {
         &self.input[start.offset as usize..end.offset as usize]
+    }
     #[inline]
     pub fn section_at_span(&self, span: InputSpan) -> &[u8] {
         &self.input[span.begin.offset as usize..span.end.offset as usize]
+    }
     // Consumes the next character. Will check well-formedness of newlines: \r
     // must be followed by a \n, because this is used for error reporting. Will
     // not check for ascii-ness of the file, better left to a tokenizer.
     pub fn consume(&mut self) {
         match self.next() {
             Some(b'\r') => {
                 if Some(b'\n') == self.lookahead(1) {
                     // Well formed file
                     self.offset += 1;
                 } else {
                     // Not a well-formed file, pretend like we can continue
                     self.offset += 1;
                     self.set_error("Encountered carriage-feed without a following newline");
+                }
             },
             Some(b'\n') => {
                 self.line += 1;
                 self.offset += 1;
             },
             Some(_) => {
                 self.offset += 1;
+            }
             None => {}
+        }
         // Maybe we actually want to check this in release mode. Then again:
         // a 4 gigabyte source file... Really?
         debug_assert!(self.offset < u32::max_value() as usize);
+    }
     fn set_error(&mut self, msg: &str) {
         if self.had_error.is_none() {
             self.had_error = Some(ParseError::new_error_str_at_pos(self, self.pos(), msg));
+        }
+    }
     fn get_lookup(&self) -> RwLockReadGuard<Vec<u32>> {
         // Once constructed the lookup always contains one element. We use this
         // to see if it is constructed already.
+        {
             let lookup = self.offset_lookup.read().unwrap();
             if !lookup.is_empty() {
                 return lookup;
+            }
+        }
         // Lookup was not constructed yet
         let mut lookup = self.offset_lookup.write().unwrap();
         if !lookup.is_empty() {
             // Somebody created it before we had the chance
             drop(lookup);
             let lookup = self.offset_lookup.read().unwrap();
             return lookup;
+        }
         // Build the line number (!) to offset lookup, so offset by 1. We
         // assume the entire source file is scanned (most common case) for
         // preallocation.
         lookup.reserve(self.line as usize + 2);
         lookup.push(0); // line 0: never used
         lookup.push(0); // first line: first character
         for char_idx in 0..self.input.len() {
             if self.input[char_idx] == b'\n' {
                 lookup.push(char_idx as u32 + 1);
+            }
+        }
         lookup.push(self.input.len() as u32); // for lookup_line_end
         debug_assert_eq!(self.line as usize + 2, lookup.len(), "remove me: i am a testing assert and sometimes invalid");
         // Return created lookup
         drop(lookup);
         let lookup = self.offset_lookup.read().unwrap();
         return lookup;
+    }
     /// Retrieves offset at which line starts (right after newline)
     fn lookup_line_start_offset(&self, line_number: u32) -> u32 {
         let lookup = self.get_lookup();
         lookup[line_number as usize]
+    }
     /// Retrieves offset at which line ends (at the newline character or the
     /// preceding carriage feed for \r\n-encoded newlines)
     fn lookup_line_end_offset(&self, line_number: u32) -> u32 {
         let lookup = self.get_lookup();
         let offset = lookup[(line_number + 1) as usize] - 1;
         let offset_usize = offset as usize;
         // Compensate for newlines and a potential carriage feed
         if self.input[offset_usize] == b'\n' {
             if offset_usize > 0 && self.input[offset_usize] == b'\r' {
                 offset - 2
             } else {
                 offset - 1
+            }
         } else {
             offset
+        }
+    }
+}
 #[derive(Debug)]
 pub enum StatementKind {
     Info,
     Error
+}
 #[derive(Debug)]
 pub enum ContextKind {
     SingleLine,
     MultiLine,
+}
 #[derive(Debug)]
 pub struct ParseErrorStatement {
     pub(crate) statement_kind: StatementKind,
     pub(crate) context_kind: ContextKind,
     pub(crate) start_line: u32,
     pub(crate) start_column: u32,
     pub(crate) end_line: u32,
     pub(crate) end_column: u32,
     pub(crate) filename: String,
     pub(crate) context: String,
     pub(crate) message: String,
+}
 impl ParseErrorStatement {
     fn from_source_at_pos(statement_kind: StatementKind, source: &InputSource, position: InputPosition, message: String) -> Self {
         // Seek line start and end
         let line_start = source.lookup_line_start_offset(position.line);
         let line_end = source.lookup_line_end_offset(position.line);
         let context = Self::create_context(source, line_start as usize, line_end as usize);
         debug_assert!(position.offset >= line_start);
         let column = position.offset - line_start + 1;
         Self{
             statement_kind,
             context_kind: ContextKind::SingleLine,
             start_line: position.line,
             start_column: column,
             end_line: position.line,
             end_column: column + 1,
             filename: source.filename.clone(),
             context,
             message,
+        }
+    }
     fn from_source_at_span(statement_kind: StatementKind, source: &InputSource, span: InputSpan, message: String) -> Self {
         debug_assert!(span.end.line >= span.begin.line);
         debug_assert!(span.end.offset >= span.begin.offset);
         let first_line_start = source.lookup_line_start_offset(span.begin.line);
         let last_line_start = source.lookup_line_start_offset(span.end.line);
         let last_line_end = source.lookup_line_end_offset(span.end.line);
         let context = Self::create_context(source, first_line_start as usize, last_line_end as usize);
         debug_assert!(span.begin.offset >= first_line_start);
         let start_column = span.begin.offset - first_line_start + 1;
         let end_column = span.end.offset - last_line_start + 1;
         let context_kind = if span.begin.line == span.end.line {
             ContextKind::SingleLine
         } else {
             ContextKind::MultiLine
         };
         Self{
             statement_kind,
             context_kind,
-            start_line: first_line_start,
+            start_line: span.begin.line,
             start_column,
-            end_line: last_line_start,
+            end_line: span.end.line,
             end_column,
             filename: source.filename.clone(),
             context,
             message,
+        }
+    }
     /// Produces context from source
     fn create_context(source: &InputSource, start: usize, end: usize) -> String {
         let context_raw = &source.input[start..end];
         String::from_utf8_lossy(context_raw).to_string()
+    }
+}
 impl fmt::Display for ParseErrorStatement {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Write kind of statement and message
         match self.statement_kind {
             StatementKind::Info => f.write_str(" INFO: ")?,
             StatementKind::Error => f.write_str("ERROR: ")?,
+        }
         f.write_str(&self.message)?;
         f.write_char('\n')?;
         // Write originating file/line/column
         f.write_str(" +- ")?;
         if !self.filename.is_empty() {
             write!(f, "in {} ", self.filename)?;
+        }
         match self.context_kind {
             ContextKind::SingleLine => writeln!(f, " at {}:{}", self.start_line, self.start_column),
             ContextKind::MultiLine => writeln!(
                 f, " from {}:{} to {}:{}",
                 self.start_line, self.start_column, self.end_line, self.end_column
+            )
         }?;
         // Helper function for writing context: converting tabs into 4 spaces
         // (oh, the controversy!) and creating an annotated line
         fn transform_context(source: &str, target: &mut String) {
             for char in source.chars() {
                 if char == '\t' {
                     target.push_str("    ");
                 } else {
                     target.push(char);
+                }
+            }
+        }
         fn extend_annotation(first_col: u32, last_col: u32, source: &str, target: &mut String, extend_char: char) {
             debug_assert!(first_col > 0 && last_col > first_col);
             for (char_idx, char) in source.chars().enumerate().skip(first_col as usize - 1) {
                 if char_idx == last_col as usize {
             let first_idx = first_col as usize - 1;
             let last_idx = last_col as usize - 1;
             for (char_idx, char) in source.chars().enumerate().skip(first_idx) {
                 if char_idx == last_idx as usize {
                     break;
+                }
                 if char == '\t' {
                     for _ in 0..4 { target.push(extend_char); }
                 } else {
                     target.push(extend_char);
+                }
+            }
+        }
         // Write source context
         writeln!(f, " | ")?;
         let mut context = String::with_capacity(128);
         let mut annotation = String::with_capacity(128);
         match self.context_kind {
             ContextKind::SingleLine => {
                 // Write single line of context with indicator for the offending
                 // span underneath.
                 context.push_str(" |  ");
                 transform_context(&self.context, &mut context);
                 context.push('\n');
                 f.write_str(&context)?;
                 annotation.push_str(" | ");
                 extend_annotation(1, self.start_column, &self.context, &mut annotation, ' ');
+                extend_annotation(1, self.start_column + 1, &self.context, &mut annotation, ' ');
                 extend_annotation(self.start_column, self.end_column, &self.context, &mut annotation, '~');
                 annotation.push('\n');
                 f.write_str(&annotation)?;
             },
             ContextKind::MultiLine => {
                 // Annotate all offending lines
                 // - first line
                 let mut lines = self.context.lines();
                 let first_line = lines.next().unwrap();
                 transform_context(first_line, &mut context);
                 writeln!(f, " |- {}", &context)?;
                 // - remaining lines
                 let mut last_line = first_line;
                 while let Some(cur_line) = lines.next() {
                     context.clear();
                     transform_context(cur_line, &mut context);
                     writeln!(f, " |  {}", &context)?;
                     last_line = cur_line;
+                }
                 // - underline beneath last line
                 annotation.push_str(" \\__");
                 extend_annotation(1, self.end_column, &last_line, &mut annotation, '_');
                 annotation.push_str("/\n");
                 f.write_str(&annotation)?;
+            }
+        }
         Ok(())
+    }
+}
 #[derive(Debug)]
 pub struct ParseError {
     pub(crate) statements: Vec<ParseErrorStatement>
+}
 impl fmt::Display for ParseError {
     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 ParseError {
     pub fn new_error_at_pos(source: &InputSource, position: InputPosition, message: String) -> Self {
         Self{ statements: vec!(ParseErrorStatement::from_source_at_pos(
             StatementKind::Error, source, position, message
         )) }
+    }
     pub fn new_error_str_at_pos(source: &InputSource, position: InputPosition, message: &str) -> Self {
         Self{ statements: vec!(ParseErrorStatement::from_source_at_pos(
             StatementKind::Error, source, position, message.to_string()
         )) }
+    }
     pub fn new_error_at_span(source: &InputSource, span: InputSpan, message: String) -> Self {
         Self{ statements: vec!(ParseErrorStatement::from_source_at_span(
             StatementKind::Error, source, span, message
         )) }
+    }
     pub fn new_error_str_at_span(source: &InputSource, span: InputSpan, message: &str) -> Self {
         Self{ statements: vec!(ParseErrorStatement::from_source_at_span(
             StatementKind::Error, source, span, message.to_string()
         )) }
+    }
     pub fn with_at_pos(mut self, error_type: StatementKind, source: &InputSource, position: InputPosition, message: String) -> Self {
         self.statements.push(ParseErrorStatement::from_source_at_pos(error_type, source, position, message));
         self
+    }
     pub fn with_at_span(mut self, error_type: StatementKind, source: &InputSource, span: InputSpan, message: String) -> Self {
         self.statements.push(ParseErrorStatement::from_source_at_span(error_type, source, span, message.to_string()));
         self
+    }
     pub fn with_info_at_pos(self, source: &InputSource, position: InputPosition, msg: String) -> Self {
         self.with_at_pos(StatementKind::Info, source, position, msg)
+    }
     pub fn with_info_str_at_pos(self, source: &InputSource, position: InputPosition, msg: &str) -> Self {
         self.with_at_pos(StatementKind::Info, source, position, msg.to_string())
+    }
     pub fn with_info_at_span(self, source: &InputSource, span: InputSpan, msg: String) -> Self {
         self.with_at_span(StatementKind::Info, source, span, msg)
+    }
     pub fn with_info_str_at_span(self, source: &InputSource, span: InputSpan, msg: &str) -> Self {
         self.with_at_span(StatementKind::Info, source, span, msg.to_string())
+    }
+}

src/protocol/parser/mod.rs

➞

Show inline comments

 mod depth_visitor;
 pub(crate) mod symbol_table;
 pub(crate) mod type_table;
 pub(crate) mod tokens;
 pub(crate) mod token_parsing;
 pub(crate) mod pass_tokenizer;
 pub(crate) mod pass_symbols;
 pub(crate) mod pass_imports;
 pub(crate) mod pass_definitions;
 pub(crate) mod pass_validation_linking;
 pub(crate) mod pass_typing;
 mod visitor;
 use depth_visitor::*;
 use tokens::*;
 use crate::collections::*;
 use symbol_table::SymbolTable;
 use visitor::Visitor2;
 use pass_tokenizer::PassTokenizer;
 use pass_symbols::PassSymbols;
 use pass_imports::PassImport;
 use pass_definitions::PassDefinitions;
 use pass_validation_linking::PassValidationLinking;
 use pass_typing::{PassTyping, ResolveQueue};
 use type_table::TypeTable;
 use crate::protocol::ast::*;
 use crate::protocol::input_source::*;
 use crate::protocol::ast_printer::ASTWriter;
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum ModuleCompilationPhase {
     Source,                 // only source is set
     Tokenized,              // source is tokenized
     SymbolsScanned,         // all definitions are linked to their type class
     ImportsResolved,        // all imports are added to the symbol table
     DefinitionsParsed,      // produced the AST for the entire module
     TypesAddedToTable,      // added all definitions to the type table
     ValidatedAndLinked,     // AST is traversed and has linked the required AST nodes
     Typed,                  // Type inference and checking has been performed
+}
 pub struct Module {
     // Buffers
     pub source: InputSource,
     pub tokens: TokenBuffer,
     // Identifiers
     pub root_id: RootId,
     pub name: Option<(PragmaId, StringRef<'static>)>,
     pub version: Option<(PragmaId, i64)>,
     pub phase: ModuleCompilationPhase,
+}
 pub struct PassCtx<'a> {
     heap: &'a mut Heap,
     symbols: &'a mut SymbolTable,
     pool: &'a mut StringPool,
+}
 pub struct Parser {
     pub(crate) heap: Heap,
     pub(crate) string_pool: StringPool,
     pub(crate) modules: Vec<Module>,
     pub(crate) symbol_table: SymbolTable,
     pub(crate) type_table: TypeTable,
     // Compiler passes
     pass_tokenizer: PassTokenizer,
     pass_symbols: PassSymbols,
     pass_import: PassImport,
     pass_definitions: PassDefinitions,
     pass_validation: PassValidationLinking,
     pass_typing: PassTyping,
+}
 impl Parser {
     pub fn new() -> Self {
         Parser{
             heap: Heap::new(),
             string_pool: StringPool::new(),
             modules: Vec::new(),
             symbol_table: SymbolTable::new(),
             type_table: TypeTable::new(),
             pass_tokenizer: PassTokenizer::new(),
             pass_symbols: PassSymbols::new(),
             pass_import: PassImport::new(),
             pass_definitions: PassDefinitions::new(),
             pass_validation: PassValidationLinking::new(),
             pass_typing: PassTyping::new(),
+        }
+    }
     pub fn feed(&mut self, mut source: InputSource) -> Result<(), ParseError> {
         // TODO: @Optimize
         let mut token_buffer = TokenBuffer::new();
         self.pass_tokenizer.tokenize(&mut source, &mut token_buffer)?;
         let module = Module{
             source,
             tokens: token_buffer,
             root_id: RootId::new_invalid(),
             name: None,
             version: None,
             phase: ModuleCompilationPhase::Tokenized,
         };
         self.modules.push(module);
         Ok(())
+    }
     pub fn parse(&mut self) -> Result<(), ParseError> {
         let mut pass_ctx = PassCtx{
             heap: &mut self.heap,
             symbols: &mut self.symbol_table,
             pool: &mut self.string_pool,
         };
         // Advance all modules to the phase where all symbols are scanned
         for module_idx in 0..self.modules.len() {
             self.pass_symbols.parse(&mut self.modules, module_idx, &mut pass_ctx)?;
+        }
         // With all symbols scanned, perform further compilation until we can
         // add all base types to the type table.
         for module_idx in 0..self.modules.len() {
             self.pass_import.parse(&mut self.modules, module_idx, &mut pass_ctx)?;
             self.pass_definitions.parse(&mut self.modules, module_idx, &mut pass_ctx)?;
+        }
         // Add every known type to the type table
         self.type_table.build_base_types(&mut self.modules, &mut pass_ctx)?;
         // Continue compilation with the remaining phases now that the types
         // are all in the type table
         for module_idx in 0..self.modules.len() {
             // TODO: Remove the entire Visitor abstraction. It really doesn't
             //  make sense considering the amount of special handling we do
             //  in each pass.
             let mut ctx = visitor::Ctx{
                 heap: &mut self.heap,
                 module: &self.modules[module_idx],
+                module: &mut self.modules[module_idx],
                 symbols: &mut self.symbol_table,
                 types: &mut self.type_table,
             };
             self.pass_validation.visit_module(&mut ctx)?;
+        }
         // Perform typechecking on all modules
         let mut queue = ResolveQueue::new();
         for module in &self.modules {
+        for module in &mut self.modules {
             let ctx = visitor::Ctx{
                 heap: &mut self.heap,
                 module,
                 symbols: &mut self.symbol_table,
                 types: &mut self.type_table,
             };
             PassTyping::queue_module_definitions(&ctx, &mut queue);
         };
         while !queue.is_empty() {
             let top = queue.pop().unwrap();
             let mut ctx = visitor::Ctx{
                 heap: &mut self.heap,
                 module: &self.modules[top.root_id.index as usize],
+                module: &mut self.modules[top.root_id.index as usize],
                 symbols: &mut self.symbol_table,
                 types: &mut self.type_table,
             };
             self.pass_typing.handle_module_definition(&mut ctx, &mut queue, top)?;
+        }
         // Perform remaining steps
         // TODO: Phase out at some point
         for module in &self.modules {
             let root_id = module.root_id;
             if let Err((position, message)) = Self::parse_inner(&mut self.heap, root_id) {
                 return Err(ParseError::new_error_str_at_pos(&self.modules[0].source, position, &message))
+            }
+        }
         // let mut writer = ASTWriter::new();
         // let mut file = std::fs::File::create(std::path::Path::new("ast.txt")).unwrap();
         // writer.write_ast(&mut file, &self.heap);
         Ok(())
+    }
     pub fn parse_inner(h: &mut Heap, pd: RootId) -> VisitorResult {
         // TODO: @cleanup, slowly phasing out old compiler
         // NestedSynchronousStatements::new().visit_protocol_description(h, pd)?;
         // ChannelStatementOccurrences::new().visit_protocol_description(h, pd)?;
         // FunctionStatementReturns::new().visit_protocol_description(h, pd)?;
         // ComponentStatementReturnNew::new().visit_protocol_description(h, pd)?;
         // CheckBuiltinOccurrences::new().visit_protocol_description(h, pd)?;
         // BuildSymbolDeclarations::new().visit_protocol_description(h, pd)?;
         // LinkCallExpressions::new().visit_protocol_description(h, pd)?;
         // BuildScope::new().visit_protocol_description(h, pd)?;
         // ResolveVariables::new().visit_protocol_description(h, pd)?;
         LinkStatements::new().visit_protocol_description(h, pd)?;
         // BuildLabels::new().visit_protocol_description(h, pd)?;
         // ResolveLabels::new().visit_protocol_description(h, pd)?;
         AssignableExpressions::new().visit_protocol_description(h, pd)?;
         IndexableExpressions::new().visit_protocol_description(h, pd)?;
         SelectableExpressions::new().visit_protocol_description(h, pd)?;
         Ok(())
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/pass_definitions.rs

➞

Show inline comments

 use crate::protocol::ast::*;
 use super::symbol_table::*;
 use super::{Module, ModuleCompilationPhase, PassCtx};
 use super::tokens::*;
 use super::token_parsing::*;
 use crate::protocol::input_source::{InputSource as InputSource, InputPosition as InputPosition, InputSpan, ParseError};
 use crate::collections::*;
 /// Parses all the tokenized definitions into actual AST nodes.
 pub(crate) struct PassDefinitions {
     // State
     cur_definition: DefinitionId,
     // Temporary buffers of various kinds
     buffer: String,
     struct_fields: ScopedBuffer<StructFieldDefinition>,
     enum_variants: ScopedBuffer<EnumVariantDefinition>,
     union_variants: ScopedBuffer<UnionVariantDefinition>,
     parameters: ScopedBuffer<ParameterId>,
     expressions: ScopedBuffer<ExpressionId>,
     statements: ScopedBuffer<StatementId>,
     parser_types: Vec<ParserType>,
+}
 impl PassDefinitions {
     pub(crate) fn new() -> Self {
         Self{
             cur_definition: DefinitionId::new_invalid(),
             buffer: String::with_capacity(128),
             struct_fields: ScopedBuffer::new_reserved(128),
             enum_variants: ScopedBuffer::new_reserved(128),
             union_variants: ScopedBuffer::new_reserved(128),
             parameters: ScopedBuffer::new_reserved(128),
             expressions: ScopedBuffer::new_reserved(128),
             statements: ScopedBuffer::new_reserved(128),
             parser_types: Vec::with_capacity(128),
+        }
+    }
     pub(crate) fn parse(&mut self, modules: &mut [Module], module_idx: usize, ctx: &mut PassCtx) -> Result<(), ParseError> {
         let module = &modules[module_idx];
         let module_range = &module.tokens.ranges[0];
         debug_assert_eq!(module.phase, ModuleCompilationPhase::ImportsResolved);
         debug_assert_eq!(module_range.range_kind, TokenRangeKind::Module);
         // Although we only need to parse the definitions, we want to go through
         // code ranges as well such that we can throw errors if we get
         // unexpected tokens at the module level of the source.
         let mut range_idx = module_range.first_child_idx;
         loop {
             let range_idx_usize = range_idx as usize;
             let cur_range = &module.tokens.ranges[range_idx_usize];
             match cur_range.range_kind {
                 TokenRangeKind::Module => unreachable!(), // should not be reachable
                 TokenRangeKind::Pragma | TokenRangeKind::Import => continue, // already fully parsed
                 TokenRangeKind::Definition | TokenRangeKind::Code => {}
+            }
             self.visit_range(modules, module_idx, ctx, range_idx_usize)?;
             match cur_range.next_sibling_idx {
                 Some(idx) => { range_idx = idx; },
                 None => { break; },
             if cur_range.next_sibling_idx == NO_SIBLING {
                 break;
             } else {
                 range_idx = cur_range.next_sibling_idx;
+            }
+        }
         modules[module_idx].phase = ModuleCompilationPhase::DefinitionsParsed;
         Ok(())
+    }
     fn visit_range(
         &mut self, modules: &[Module], module_idx: usize, ctx: &mut PassCtx, range_idx: usize
     ) -> Result<(), ParseError> {
         let module = &modules[module_idx];
         let cur_range = &module.tokens.ranges[range_idx];
         debug_assert!(cur_range.range_kind == TokenRangeKind::Definition || cur_range.range_kind == TokenRangeKind::Code);
         // Detect which definition we're parsing
         let mut iter = module.tokens.iter_range(cur_range);
         loop {
             let next = iter.next();
             if next.is_none() {
                 return Ok(())
+            }
             // Token was not None, so peek_ident returns None if not an ident
             let ident = peek_ident(&module.source, &mut iter);
             match ident {
                 Some(KW_STRUCT) => self.visit_struct_definition(module, &mut iter, ctx)?,
                 Some(KW_ENUM) => self.visit_enum_definition(module, &mut iter, ctx)?,
                 Some(KW_UNION) => self.visit_union_definition(module, &mut iter, ctx)?,
                 Some(KW_FUNCTION) => self.visit_function_definition(module, &mut iter, ctx)?,
                 Some(KW_PRIMITIVE) | Some(KW_COMPOSITE) => self.visit_component_definition(module, &mut iter, ctx)?,
                 _ => return Err(ParseError::new_error_str_at_pos(
                     &module.source, iter.last_valid_pos(),
-                    "unexpected symbol, expected some kind of type or procedure definition"
+                    "unexpected symbol, expected a keyword marking the start of a definition"
                 )),
+            }
+        }
+    }
     fn visit_struct_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         consume_exact_ident(&module.source, iter, KW_STRUCT)?;
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated DefinitionId
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         // Parse struct definition
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         let mut fields_section = self.struct_fields.start_section();
         consume_comma_separated(
             TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
                 let poly_vars = ctx.heap[definition_id].poly_vars(); // TODO: @Cleanup, this is really ugly. But rust...
                 let start_pos = iter.last_valid_pos();
                 let parser_type = consume_parser_type(
                     source, iter, &ctx.symbols, &ctx.heap, poly_vars, module_scope,
                     definition_id, false, 0
                 )?;
                 let field = consume_ident_interned(source, iter, ctx)?;
                 Ok(StructFieldDefinition{
                     span: InputSpan::from_positions(start_pos, field.span.end),
                     field, parser_type
                 })
             },
             &mut fields_section, "a struct field", "a list of struct fields", None
         )?;
         // Transfer to preallocated definition
         let struct_def = ctx.heap[definition_id].as_struct_mut();
         struct_def.fields = fields_section.into_vec();
         Ok(())
+    }
     fn visit_enum_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         consume_exact_ident(&module.source, iter, KW_ENUM)?;
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated DefinitionId
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         // Parse enum definition
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         let mut enum_section = self.enum_variants.start_section();
         consume_comma_separated(
             TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
                 let identifier = consume_ident_interned(source, iter, ctx)?;
                 let value = if iter.next() == Some(TokenKind::Equal) {
                     iter.consume();
                     let (variant_number, _) = consume_integer_literal(source, iter, &mut self.buffer)?;
                     EnumVariantValue::Integer(variant_number as i64) // TODO: @int
                 } else {
                     EnumVariantValue::None
                 };
                 Ok(EnumVariantDefinition{ identifier, value })
             },
             &mut enum_section, "an enum variant", "a list of enum variants", None
         )?;
         // Transfer to definition
         let enum_def = ctx.heap[definition_id].as_enum_mut();
         enum_def.variants = enum_section.into_vec();
         Ok(())
+    }
     fn visit_union_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         consume_exact_ident(&module.source, iter, KW_UNION)?;
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated DefinitionId
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         // Parse union definition
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         let mut variants_section = self.union_variants.start_section();
         consume_comma_separated(
             TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
                 let identifier = consume_ident_interned(source, iter, ctx)?;
                 let mut close_pos = identifier.span.end;
                 let has_embedded = maybe_consume_comma_separated(
                     TokenKind::OpenParen, TokenKind::CloseParen, source, iter, ctx,
                     |source, iter, ctx| {
                         let poly_vars = ctx.heap[definition_id].poly_vars(); // TODO: @Cleanup, this is really ugly. But rust...
                         consume_parser_type(
                             source, iter, &ctx.symbols, &ctx.heap, poly_vars,
                             module_scope, definition_id, false, 0
+                        )
                     },
                     &mut self.parser_types, "an embedded type", Some(&mut close_pos)
                 )?;
                 let value = if has_embedded {
                     UnionVariantValue::Embedded(self.parser_types.clone())
                 } else {
                     UnionVariantValue::None
                 };
                 self.parser_types.clear();
                 Ok(UnionVariantDefinition{
                     span: InputSpan::from_positions(identifier.span.begin, close_pos),
                     identifier,
                     value
                 })
             },
             &mut variants_section, "a union variant", "a list of union variants", None
         )?;
         // Transfer to AST
         let union_def = ctx.heap[definition_id].as_union_mut();
         union_def.variants = variants_section.into_vec();
         Ok(())
+    }
     fn visit_function_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         consume_exact_ident(&module.source, iter, KW_FUNCTION)?;
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated DefinitionId
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         // Parse function's argument list
         let mut parameter_section = self.parameters.start_section();
         consume_parameter_list(
             &module.source, iter, ctx, &mut parameter_section, module_scope, definition_id
         )?;
         let parameters = parameter_section.into_vec();
         // Consume return types
         consume_token(&module.source, iter, TokenKind::ArrowRight)?;
         let mut open_curly_pos = iter.last_valid_pos();
         consume_comma_separated_until(
             TokenKind::OpenCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
                 let poly_vars = ctx.heap[definition_id].poly_vars(); // TODO: @Cleanup, this is really ugly. But rust...
                 consume_parser_type(source, iter, &ctx.symbols, &ctx.heap, poly_vars, module_scope, definition_id, false, 0)
             },
             &mut self.parser_types, "a return type", Some(&mut open_curly_pos)
         )?;
         let return_types = self.parser_types.clone();
         // TODO: @ReturnValues
         match return_types.len() {
 => return Err(ParseError::new_error_str_at_pos(&module.source, open_curly_pos, "expected a return type")),
 => {},
             _ => return Err(ParseError::new_error_str_at_pos(&module.source, open_curly_pos, "multiple return types are not (yet) allowed")),
+        }
         // Consume block
         let body = self.consume_block_statement_without_leading_curly(module, iter, ctx, open_curly_pos)?;
         // Assign everything in the preallocated AST node
         let function = ctx.heap[definition_id].as_function_mut();
         function.return_types = return_types;
         function.parameters = parameters;
         function.body = body;
         Ok(())
+    }
     fn visit_component_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         let (_variant_text, _) = consume_any_ident(&module.source, iter)?;
         debug_assert!(_variant_text == KW_PRIMITIVE || _variant_text == KW_COMPOSITE);
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated definition
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         // Parse component's argument list
         let mut parameter_section = self.parameters.start_section();
         consume_parameter_list(
             &module.source, iter, ctx, &mut parameter_section, module_scope, definition_id
         )?;
         let parameters = parameter_section.into_vec();
         // Consume block
         let body = self.consume_block_statement(module, iter, ctx)?;
         // Assign everything in the AST node
         let component = ctx.heap[definition_id].as_component_mut();
         component.parameters = parameters;
         component.body = body;
         Ok(())
+    }
     /// Consumes a block statement. If the resulting statement is not a block
     /// (e.g. for a shorthand "if (expr) single_statement") then it will be
     /// wrapped in one
     fn consume_block_or_wrapped_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<BlockStatementId, ParseError> {
         if Some(TokenKind::OpenCurly) == iter.next() {
             // This is a block statement
             self.consume_block_statement(module, iter, ctx)
         } else {
             // Not a block statement, so wrap it in one
             let mut statements = self.statements.start_section();
             let wrap_begin_pos = iter.last_valid_pos();
             self.consume_statement(module, iter, ctx, &mut statements)?;
             let wrap_end_pos = iter.last_valid_pos();
             debug_assert_eq!(statements.len(), 1);
             let statements = statements.into_vec();
             Ok(ctx.heap.alloc_block_statement(|this| BlockStatement{
                 this,
                 is_implicit: true,
                 span: InputSpan::from_positions(wrap_begin_pos, wrap_end_pos), // TODO: @Span
                 statements,
                 parent_scope: None,
                 relative_pos_in_parent: 0,
                 locals: Vec::new(),
                 labels: Vec::new()
             }))
+        }
+    }
     /// Consumes a statement and returns a boolean indicating whether it was a
     /// block or not.
     fn consume_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, section: &mut ScopedSection<StatementId>
     ) -> Result<(), ParseError> {
         let next = iter.next().expect("consume_statement has a next token");
         if next == TokenKind::OpenCurly {
             let id = self.consume_block_statement(module, iter, ctx)?;
             section.push(id.upcast());
         } else if next == TokenKind::Ident {
-            let (ident, _) = consume_any_ident(&module.source, iter)?;
+            let ident = peek_ident(&module.source, iter).unwrap();
             if ident == KW_STMT_IF {
                 // Consume if statement and place end-if statement directly
                 // after it.
                 let id = self.consume_if_statement(module, iter, ctx)?;
                 section.push(id.upcast());
                 let end_if = ctx.heap.alloc_end_if_statement(|this| EndIfStatement{
                     this, start_if: id, next: None
                 });
                 section.push(id.upcast());
                 let if_stmt = &mut ctx.heap[id];
                 if_stmt.end_if = Some(end_if);
             } else if ident == KW_STMT_WHILE {
                 let id = self.consume_while_statement(module, iter, ctx)?;
                 section.push(id.upcast());
                 let end_while = ctx.heap.alloc_end_while_statement(|this| EndWhileStatement{
                     this, start_while: id, next: None
                 });
                 section.push(id.upcast());
                 let while_stmt = &mut ctx.heap[id];
                 while_stmt.end_while = Some(end_while);
             } else if ident == KW_STMT_BREAK {
                 let id = self.consume_break_statement(module, iter, ctx)?;
                 section.push(id.upcast());
             } else if ident == KW_STMT_CONTINUE {
                 let id = self.consume_continue_statement(module, iter, ctx)?;
                 section.push(id.upcast());
             } else if ident == KW_STMT_SYNC {
                 let id = self.consume_synchronous_statement(module, iter, ctx)?;
                 section.push(id.upcast());
                 let end_sync = ctx.heap.alloc_end_synchronous_statement(|this| EndSynchronousStatement{
                     this, start_sync: id, next: None
                 });
                 let sync_stmt = &mut ctx.heap[id];
                 sync_stmt.end_sync = Some(end_sync);
             } else if ident == KW_STMT_RETURN {
                 let id = self.consume_return_statement(module, iter, ctx)?;
                 section.push(id.upcast());
             } else if ident == KW_STMT_GOTO {
                 let id = self.consume_goto_statement(module, iter, ctx)?;
                 section.push(id.upcast());
             } else if ident == KW_STMT_NEW {
                 let id = self.consume_new_statement(module, iter, ctx)?;
                 section.push(id.upcast());
             } else if ident == KW_STMT_CHANNEL {
                 let id = self.consume_channel_statement(module, iter, ctx)?;
                 section.push(id.upcast().upcast());
             } else if iter.peek() == Some(TokenKind::Colon) {
                 self.consume_labeled_statement(module, iter, ctx, section)?;
             } else {
                 // Two fallback possibilities: the first one is a memory
                 // declaration, the other one is to parse it as a regular
                 // expression. This is a bit ugly
                 if let Some((memory_stmt_id, assignment_stmt_id)) = self.maybe_consume_memory_statement(module, iter, ctx)? {
                     section.push(memory_stmt_id.upcast().upcast());
                     section.push(assignment_stmt_id.upcast());
                 } else {
                     let id = self.consume_expression_statement(module, iter, ctx)?;
                     section.push(id.upcast());
+                }
+            }
         };
         return Ok(());
+    }
     fn consume_block_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<BlockStatementId, ParseError> {
         let open_span = consume_token(&module.source, iter, TokenKind::OpenCurly)?;
         self.consume_block_statement_without_leading_curly(module, iter, ctx, open_span.begin)
+    }
     fn consume_block_statement_without_leading_curly(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, open_curly_pos: InputPosition
     ) -> Result<BlockStatementId, ParseError> {
         let mut stmt_section = self.statements.start_section();
         let mut next = iter.next();
         while next != Some(TokenKind::CloseCurly) {
             if next.is_none() {
                 return Err(ParseError::new_error_str_at_pos(
                     &module.source, iter.last_valid_pos(), "expected a statement or '}'"
                 ));
+            }
             self.consume_statement(module, iter, ctx, &mut stmt_section)?;
             next = iter.next();
+        }
         let statements = stmt_section.into_vec();
         let mut block_span = consume_token(&module.source, iter, TokenKind::CloseCurly)?;
         block_span.begin = open_curly_pos;
         Ok(ctx.heap.alloc_block_statement(|this| BlockStatement{
             this,
             is_implicit: false,
             span: block_span,
             statements,
             parent_scope: None,
             relative_pos_in_parent: 0,
             locals: Vec::new(),
             labels: Vec::new(),
         }))
+    }
     fn consume_if_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<IfStatementId, ParseError> {
         let if_span = consume_exact_ident(&module.source, iter, KW_STMT_IF)?;
         consume_token(&module.source, iter, TokenKind::OpenParen)?;
         let test = self.consume_expression(module, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::CloseParen)?;
         let true_body = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
         let false_body = if has_ident(&module.source, iter, KW_STMT_ELSE) {
             iter.consume();
             let false_body = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
             Some(false_body)
         } else {
             None
         };
         Ok(ctx.heap.alloc_if_statement(|this| IfStatement{
             this,
             span: if_span,
             test,
             true_body,
             false_body,
             end_if: None,
         }))
+    }
     fn consume_while_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<WhileStatementId, ParseError> {
         let while_span = consume_exact_ident(&module.source, iter, KW_STMT_WHILE)?;
         consume_token(&module.source, iter, TokenKind::OpenParen)?;
         let test = self.consume_expression(module, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::CloseParen)?;
         let body = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
         Ok(ctx.heap.alloc_while_statement(|this| WhileStatement{
             this,
             span: while_span,
             test,
             body,
             end_while: None,
             in_sync: None,
         }))
+    }
     fn consume_break_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<BreakStatementId, ParseError> {
         let break_span = consume_exact_ident(&module.source, iter, KW_STMT_BREAK)?;
         let label = if Some(TokenKind::Ident) == iter.next() {
             let label = consume_ident_interned(&module.source, iter, ctx)?;
             Some(label)
         } else {
             None
         };
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         Ok(ctx.heap.alloc_break_statement(|this| BreakStatement{
             this,
             span: break_span,
             label,
             target: None,
         }))
+    }
     fn consume_continue_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ContinueStatementId, ParseError> {
         let continue_span = consume_exact_ident(&module.source, iter, KW_STMT_CONTINUE)?;
         let label=  if Some(TokenKind::Ident) == iter.next() {
             let label = consume_ident_interned(&module.source, iter, ctx)?;
             Some(label)
         } else {
             None
         };
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         Ok(ctx.heap.alloc_continue_statement(|this| ContinueStatement{
             this,
             span: continue_span,
             label,
             target: None
         }))
+    }
     fn consume_synchronous_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<SynchronousStatementId, ParseError> {
         let synchronous_span = consume_exact_ident(&module.source, iter, KW_STMT_SYNC)?;
         let body = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
         Ok(ctx.heap.alloc_synchronous_statement(|this| SynchronousStatement{
             this,
             span: synchronous_span,
             body,
             end_sync: None,
             parent_scope: None,
         }))
+    }
     fn consume_return_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ReturnStatementId, ParseError> {
         let return_span = consume_exact_ident(&module.source, iter, KW_STMT_RETURN)?;
         let mut scoped_section = self.expressions.start_section();
         consume_comma_separated_until(
             TokenKind::SemiColon, &module.source, iter, ctx,
             |_source, iter, ctx| self.consume_expression(module, iter, ctx),
             &mut scoped_section, "a return expression", None
         )?;
         let expressions = scoped_section.into_vec();
         if expressions.is_empty() {
             return Err(ParseError::new_error_str_at_span(&module.source, return_span, "expected at least one return value"));
         } else if expressions.len() > 1 {
             return Err(ParseError::new_error_str_at_span(&module.source, return_span, "multiple return values are not (yet) supported"))
+        }
         Ok(ctx.heap.alloc_return_statement(|this| ReturnStatement{
             this,
             span: return_span,
             expressions
         }))
+    }
     fn consume_goto_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<GotoStatementId, ParseError> {
         let goto_span = consume_exact_ident(&module.source, iter, KW_STMT_GOTO)?;
         let label = consume_ident_interned(&module.source, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         Ok(ctx.heap.alloc_goto_statement(|this| GotoStatement{
             this,
             span: goto_span,
             label,
             target: None
         }))
+    }
     fn consume_new_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<NewStatementId, ParseError> {
         let new_span = consume_exact_ident(&module.source, iter, KW_STMT_NEW)?;
         // TODO: @Cleanup, should just call something like consume_component_expression-ish
         let start_pos = iter.last_valid_pos();
         let expression_id = self.consume_primary_expression(module, iter, ctx)?;
         let expression = &ctx.heap[expression_id];
         let mut valid = false;
         let mut call_id = CallExpressionId::new_invalid();
         if let Expression::Call(expression) = expression {
             // Allow both components and functions, as it makes more sense to
             // check their correct use in the validation and linking pass
             if expression.method == Method::UserComponent || expression.method == Method::UserFunction {
                 call_id = expression.this;
                 valid = true;
+            }
+        }
         if !valid {
             return Err(ParseError::new_error_str_at_span(
                 &module.source, InputSpan::from_positions(start_pos, iter.last_valid_pos()), "expected a call expression"
             ));
+        }
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         debug_assert!(!call_id.is_invalid());
         Ok(ctx.heap.alloc_new_statement(|this| NewStatement{
             this,
             span: new_span,
             expression: call_id,
             next: None
         }))
+    }
     fn consume_channel_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ChannelStatementId, ParseError> {
         // Consume channel specification
         let channel_span = consume_exact_ident(&module.source, iter, KW_STMT_CHANNEL)?;
         let channel_type = if Some(TokenKind::OpenAngle) == iter.next() {
             // Retrieve the type of the channel, we're cheating a bit here by
             // consuming the first '<' and setting the initial angle depth to 1
             // such that our final '>' will be consumed as well.
             iter.consume();
             let definition_id = self.cur_definition;
             let poly_vars = ctx.heap[definition_id].poly_vars();
             consume_parser_type(
                 &module.source, iter, &ctx.symbols, &ctx.heap,
                 &poly_vars, SymbolScope::Module(module.root_id), definition_id,
                 true, 1
             )?
         } else {
             // Assume inferred
             ParserType{ elements: vec![ParserTypeElement{
                 full_span: channel_span, // TODO: @Span fix
                 variant: ParserTypeVariant::Inferred
             }]}
         };
         let from_identifier = consume_ident_interned(&module.source, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::ArrowRight)?;
         let to_identifier = consume_ident_interned(&module.source, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         // Construct ports
         let from = ctx.heap.alloc_local(|this| Local{
             this,
             identifier: from_identifier,
             parser_type: channel_type.clone(),
             relative_pos_in_block: 0,
         });
         let to = ctx.heap.alloc_local(|this| Local{
             this,
             identifier: to_identifier,
             parser_type: channel_type,
             relative_pos_in_block: 0,
         });
         // Construct the channel
         Ok(ctx.heap.alloc_channel_statement(|this| ChannelStatement{
             this,
             span: channel_span,
             from, to,
             relative_pos_in_block: 0,
             next: None,
         }))
+    }
     fn consume_labeled_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, section: &mut ScopedSection<StatementId>
     ) -> Result<(), ParseError> {
         let label = consume_ident_interned(&module.source, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::Colon)?;
         // Not pretty: consume_statement may produce more than one statement.
         // The values in the section need to be in the correct order if some
         // kind of outer block is consumed, so we take another section, push
         // the expressions in that one, and then allocate the labeled statement.
         let mut inner_section = self.statements.start_section();
         self.consume_statement(module, iter, ctx, &mut inner_section)?;
         debug_assert!(inner_section.len() >= 1);
         let stmt_id = ctx.heap.alloc_labeled_statement(|this| LabeledStatement {
             this,
             label,
             body: inner_section[0],
             relative_pos_in_block: 0,
             in_sync: None,
         });
         if inner_section.len() == 1 {
             // Produce the labeled statement pointing to the first statement.
             // This is by far the most common case.
             inner_section.forget();
             section.push(stmt_id.upcast());
         } else {
             // Produce the labeled statement using the first statement, and push
             // the remaining ones at the end.
             let inner_statements = inner_section.into_vec();
             section.push(stmt_id.upcast());
             for idx in 1..inner_statements.len() {
                 section.push(inner_statements[idx])
+            }
+        }
         Ok(())
+    }
     fn maybe_consume_memory_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<Option<(MemoryStatementId, ExpressionStatementId)>, ParseError> {
         // This is a bit ugly. It would be nicer if we could somehow
         // consume the expression with a type hint if we do get a valid
         // type, but we don't get an identifier following it
         let iter_state = iter.save();
         let definition_id = self.cur_definition;
         let poly_vars = ctx.heap[definition_id].poly_vars();
         let parser_type = consume_parser_type(
             &module.source, iter, &ctx.symbols, &ctx.heap, poly_vars,
             SymbolScope::Definition(definition_id), definition_id, true, 0
         );
         if let Ok(parser_type) = parser_type {
             if Some(TokenKind::Ident) == iter.next() {
                 // Assume this is a proper memory statement
                 let identifier = consume_ident_interned(&module.source, iter, ctx)?;
                 let memory_span = InputSpan::from_positions(parser_type.elements[0].full_span.begin, identifier.span.end);
                 let assign_span = consume_token(&module.source, iter, TokenKind::Equal)?;
                 let initial_expr_begin_pos = iter.last_valid_pos();
                 let initial_expr_id = self.consume_expression(module, iter, ctx)?;
                 let initial_expr_end_pos = iter.last_valid_pos();
                 consume_token(&module.source, iter, TokenKind::SemiColon)?;
                 // Allocate the memory statement with the variable
                 let local_id = ctx.heap.alloc_local(|this| Local{
                     this,
                     identifier: identifier.clone(),
                     parser_type,
                     relative_pos_in_block: 0,
                 });
                 let memory_stmt_id = ctx.heap.alloc_memory_statement(|this| MemoryStatement{
                     this,
                     span: memory_span,
                     variable: local_id,
                     next: None
                 });
                 // Allocate the initial assignment
                 let variable_expr_id = ctx.heap.alloc_variable_expression(|this| VariableExpression{
                     this,
                     identifier,
                     declaration: None,
                     parent: ExpressionParent::None,
                     concrete_type: Default::default()
                 });
                 let assignment_expr_id = ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{
                     this,
                     span: assign_span,
                     left: variable_expr_id.upcast(),
                     operation: AssignmentOperator::Set,
                     right: initial_expr_id,
                     parent: ExpressionParent::None,
                     concrete_type: Default::default(),
                 });
                 let assignment_stmt_id = ctx.heap.alloc_expression_statement(|this| ExpressionStatement{
                     this,
                     span: InputSpan::from_positions(initial_expr_begin_pos, initial_expr_end_pos),
                     expression: assignment_expr_id.upcast(),
                     next: None,
                 });
                 return Ok(Some((memory_stmt_id, assignment_stmt_id)))
+            }
+        }
         // If here then one of the preconditions for a memory statement was not
         // met. So recover the iterator and return
         iter.load(iter_state);
         Ok(None)
+    }
     fn consume_expression_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionStatementId, ParseError> {
         let start_pos = iter.last_valid_pos();
         let expression = self.consume_expression(module, iter, ctx)?;
         let end_pos = iter.last_valid_pos();
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         Ok(ctx.heap.alloc_expression_statement(|this| ExpressionStatement{
             this,
             span: InputSpan::from_positions(start_pos, end_pos),
             expression,
             next: None,
         }))
+    }
     //--------------------------------------------------------------------------
     // Expression Parsing
     //--------------------------------------------------------------------------
     fn consume_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_assignment_expression(module, iter, ctx)
+    }
     fn consume_assignment_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         // Utility to convert token into assignment operator
         fn parse_assignment_operator(token: Option<TokenKind>) -> Option<AssignmentOperator> {
             use TokenKind as TK;
             use AssignmentOperator as AO;
             if token.is_none() {
                 return None
+            }
             match token.unwrap() {
                 TK::Equal               => Some(AO::Set),
                 TK::StarEquals          => Some(AO::Multiplied),
                 TK::SlashEquals         => Some(AO::Divided),
                 TK::PercentEquals       => Some(AO::Remained),
                 TK::PlusEquals          => Some(AO::Added),
                 TK::MinusEquals         => Some(AO::Subtracted),
                 TK::ShiftLeftEquals     => Some(AO::ShiftedLeft),
                 TK::ShiftRightEquals    => Some(AO::ShiftedRight),
                 TK::AndEquals           => Some(AO::BitwiseAnded),
                 TK::CaretEquals         => Some(AO::BitwiseXored),
                 TK::OrEquals            => Some(AO::BitwiseOred),
                 _                       => None
+            }
+        }
         let expr = self.consume_conditional_expression(module, iter, ctx)?;
         if let Some(operation) = parse_assignment_operator(iter.next()) {
             let span = iter.next_span();
             iter.consume();
             let left = expr;
             let right = self.consume_expression(module, iter, ctx)?;
             Ok(ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{
                 this, span, left, operation, right,
                 parent: ExpressionParent::None,
                 concrete_type: ConcreteType::default(),
             }).upcast())
         } else {
             Ok(expr)
+        }
+    }
     fn consume_conditional_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         let result = self.consume_concat_expression(module, iter, ctx)?;
         if let Some(TokenKind::Question) = iter.next() {
             let span = iter.next_span();
             iter.consume();
             let test = result;
             let true_expression = self.consume_expression(module, iter, ctx)?;
             consume_token(&module.source, iter, TokenKind::Colon)?;
             let false_expression = self.consume_expression(module, iter, ctx)?;
             Ok(ctx.heap.alloc_conditional_expression(|this| ConditionalExpression{
                 this, span, test, true_expression, false_expression,
                 parent: ExpressionParent::None,
                 concrete_type: ConcreteType::default(),
             }).upcast())
         } else {
             Ok(result)
+        }
+    }
     fn consume_concat_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::At) => Some(BinaryOperator::Concatenate),
                 _ => None
             },
             Self::consume_logical_or_expression
+        )
+    }
     fn consume_logical_or_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::OrOr) => Some(BinaryOperator::LogicalOr),
                 _ => None
             },
             Self::consume_logical_and_expression
+        )
+    }
     fn consume_logical_and_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::AndAnd) => Some(BinaryOperator::LogicalAnd),
                 _ => None
             },
             Self::consume_bitwise_or_expression
+        )
+    }
     fn consume_bitwise_or_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::Or) => Some(BinaryOperator::BitwiseOr),
                 _ => None
             },
             Self::consume_bitwise_xor_expression
+        )
+    }
     fn consume_bitwise_xor_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::Caret) => Some(BinaryOperator::BitwiseXor),
                 _ => None
             },
             Self::consume_bitwise_and_expression
+        )
+    }
     fn consume_bitwise_and_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::And) => Some(BinaryOperator::BitwiseAnd),
                 _ => None
             },
             Self::consume_equality_expression
+        )
+    }
     fn consume_equality_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::EqualEqual) => Some(BinaryOperator::Equality),
                 Some(TokenKind::NotEqual) => Some(BinaryOperator::Inequality),
                 _ => None
             },
             Self::consume_relational_expression
+        )
+    }
     fn consume_relational_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::OpenAngle) => Some(BinaryOperator::LessThan),
                 Some(TokenKind::CloseAngle) => Some(BinaryOperator::GreaterThan),
                 Some(TokenKind::LessEquals) => Some(BinaryOperator::LessThanEqual),
                 Some(TokenKind::GreaterEquals) => Some(BinaryOperator::GreaterThanEqual),
                 _ => None
             },
             Self::consume_shift_expression
+        )
+    }
     fn consume_shift_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::ShiftLeft) => Some(BinaryOperator::ShiftLeft),
                 Some(TokenKind::ShiftRight) => Some(BinaryOperator::ShiftRight),
                 _ => None
             },
             Self::consume_add_or_subtract_expression
+        )
+    }
     fn consume_add_or_subtract_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::Plus) => Some(BinaryOperator::Add),
                 Some(TokenKind::Minus) => Some(BinaryOperator::Subtract),
                 _ => None,
             },
             Self::consume_multiply_divide_or_modulus_expression
+        )
+    }
     fn consume_multiply_divide_or_modulus_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::Star) => Some(BinaryOperator::Multiply),
                 Some(TokenKind::Slash) => Some(BinaryOperator::Divide),
                 Some(TokenKind::Percent) => Some(BinaryOperator::Remainder),
                 _ => None
             },
             Self::consume_prefix_expression
+        )
+    }
     fn consume_prefix_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         fn parse_prefix_token(token: Option<TokenKind>) -> Option<UnaryOperation> {
             use TokenKind as TK;
             use UnaryOperation as UO;
             match token {
                 Some(TK::Plus) => Some(UO::Positive),
                 Some(TK::Minus) => Some(UO::Negative),
                 Some(TK::PlusPlus) => Some(UO::PreIncrement),
                 Some(TK::MinusMinus) => Some(UO::PreDecrement),
                 Some(TK::Tilde) => Some(UO::BitwiseNot),
                 Some(TK::Exclamation) => Some(UO::LogicalNot),
                 _ => None
+            }
+        }
         if let Some(operation) = parse_prefix_token(iter.next()) {
             let span = iter.next_span();
             iter.consume();
             let expression = self.consume_prefix_expression(module, iter, ctx)?;
             Ok(ctx.heap.alloc_unary_expression(|this| UnaryExpression {
                 this, span, operation, expression,
                 parent: ExpressionParent::None,
                 concrete_type: ConcreteType::default()
             }).upcast())
         } else {
             self.consume_postfix_expression(module, iter, ctx)
+        }
+    }
     fn consume_postfix_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         fn has_matching_postfix_token(token: Option<TokenKind>) -> bool {
             use TokenKind as TK;
             if token.is_none() { return false; }
             match token.unwrap() {
                 TK::PlusPlus | TK::MinusMinus | TK::OpenSquare | TK::Dot => true,
                 _ => false
+            }
+        }
         let mut result = self.consume_primary_expression(module, iter, ctx)?;
         let mut next = iter.next();
         while has_matching_postfix_token(next) {
             let token = next.unwrap();
             let mut span = iter.next_span();
             iter.consume();
             if token == TokenKind::PlusPlus {
                 result = ctx.heap.alloc_unary_expression(|this| UnaryExpression{
                     this, span,
                     operation: UnaryOperation::PostIncrement,
                     expression: result,
                     parent: ExpressionParent::None,
                     concrete_type: ConcreteType::default()
                 }).upcast();
             } else if token == TokenKind::MinusMinus {
                 result = ctx.heap.alloc_unary_expression(|this| UnaryExpression{
                     this, span,
                     operation: UnaryOperation::PostDecrement,
                     expression: result,
                     parent: ExpressionParent::None,
                     concrete_type: ConcreteType::default()
                 }).upcast();
             } else if token == TokenKind::OpenSquare {
                 let subject = result;
                 let from_index = self.consume_expression(module, iter, ctx)?;
                 // Check if we have an indexing or slicing operation
                 next = iter.next();
                 if Some(TokenKind::DotDot) == next {
                     iter.consume();
                     let to_index = self.consume_expression(module, iter, ctx)?;
                     let end_span = consume_token(&module.source, iter, TokenKind::CloseSquare)?;
                     span.end = end_span.end;
                     result = ctx.heap.alloc_slicing_expression(|this| SlicingExpression{
                         this, span, subject, from_index, to_index,
                         parent: ExpressionParent::None,
                         concrete_type: ConcreteType::default()
                     }).upcast();
                 } else if Some(TokenKind::CloseSquare) == next {
                     let end_span = consume_token(&module.source, iter, TokenKind::CloseSquare)?;
                     span.end = end_span.end;
                     result = ctx.heap.alloc_indexing_expression(|this| IndexingExpression{
                         this, span, subject,
                         index: from_index,
                         parent: ExpressionParent::None,
                         concrete_type: ConcreteType::default()
                     }).upcast();
                 } else {
                     return Err(ParseError::new_error_str_at_pos(
                         &module.source, iter.last_valid_pos(), "unexpected token: expected ']' or '..'"
                     ));
+                }
             } else {
                 debug_assert_eq!(token, TokenKind::Dot);
                 let subject = result;
                 let (field_text, field_span) = consume_ident(&module.source, iter)?;
                 let field = if field_text == b"length" {
                     Field::Length
                 } else {
                     let value = ctx.pool.intern(field_text);
                     let identifier = Identifier{ value, span: field_span };
                     Field::Symbolic(FieldSymbolic{ identifier, definition: None, field_idx: 0 })
                 };
                 result = ctx.heap.alloc_select_expression(|this| SelectExpression{
                     this, span, subject, field,
                     parent: ExpressionParent::None,
                     concrete_type: ConcreteType::default()
                 }).upcast();
+            }
             next = iter.next();
+        }
         Ok(result)
+    }
     fn consume_primary_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         let next = iter.next();
         let result = if next == Some(TokenKind::OpenParen) {
             // Expression between parentheses
             iter.consume();
             let result = self.consume_expression(module, iter, ctx)?;
             consume_token(&module.source, iter, TokenKind::CloseParen)?;
             result
         } else if next == Some(TokenKind::OpenCurly) {
             // Array literal
             let (start_pos, mut end_pos) = iter.next_positions();
             let mut scoped_section = self.expressions.start_section();
             consume_comma_separated(
                 TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
                 |_source, iter, ctx| self.consume_expression(module, iter, ctx),
                 &mut scoped_section, "an expression", "a list of expressions", Some(&mut end_pos)
             )?;
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this,
                 span: InputSpan::from_positions(start_pos, end_pos),
                 value: Literal::Array(scoped_section.into_vec()),
                 parent: ExpressionParent::None,
                 concrete_type: ConcreteType::default(),
             }).upcast()
         } else if next == Some(TokenKind::Integer) {
             let (literal, span) = consume_integer_literal(&module.source, iter, &mut self.buffer)?;
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this, span,
                 value: Literal::Integer(LiteralInteger{ unsigned_value: literal, negated: false }),
                 parent: ExpressionParent::None,
                 concrete_type: ConcreteType::default(),
             }).upcast()
         } else if next == Some(TokenKind::String) {
             let span = consume_string_literal(&module.source, iter, &mut self.buffer)?;
             let interned = ctx.pool.intern(self.buffer.as_bytes());
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this, span,
                 value: Literal::String(interned),
                 parent: ExpressionParent::None,
                 concrete_type: ConcreteType::default(),
             }).upcast()
         } else if next == Some(TokenKind::Character) {
             let (character, span) = consume_character_literal(&module.source, iter)?;
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this, span,
                 value: Literal::Character(character),
                 parent: ExpressionParent::None,
                 concrete_type: ConcreteType::default(),
             }).upcast()
         } else if next == Some(TokenKind::Ident) {
             // May be a variable, a type instantiation or a function call. If we
             // have a single identifier that we cannot find in the type table
             // then we're going to assume that we're dealing with a variable.
             let ident_span = iter.next_span();
             let ident_text = module.source.section_at_span(ident_span);
             let symbol = ctx.symbols.get_symbol_by_name(SymbolScope::Module(module.root_id), ident_text);
             if symbol.is_some() {
                 // The first bit looked like a symbol, so we're going to follow
                 // that all the way through, assume we arrive at some kind of
                 // function call or type instantiation
                 use ParserTypeVariant as PTV;
                 let symbol_scope = SymbolScope::Definition(self.cur_definition);
                 let poly_vars = ctx.heap[self.cur_definition].poly_vars();
                 let parser_type = consume_parser_type(
                     &module.source, iter, &ctx.symbols, &ctx.heap, poly_vars, symbol_scope,
                     self.cur_definition, true, 0
                 )?;
                 debug_assert!(!parser_type.elements.is_empty());
                 match parser_type.elements[0].variant {
                     PTV::Definition(target_definition_id, _) => {
                         let definition = &ctx.heap[target_definition_id];
                         match definition {
                             Definition::Struct(_) => {
                                 // Struct literal
                                 let mut last_token = iter.last_valid_pos();
                                 let mut struct_fields = Vec::new();
                                 consume_comma_separated(
                                     TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
                                     |source, iter, ctx| {
                                         let identifier = consume_ident_interned(source, iter, ctx)?;
                                         consume_token(source, iter, TokenKind::Colon)?;
                                         let value = self.consume_expression(module, iter, ctx)?;
                                         Ok(LiteralStructField{ identifier, value, field_idx: 0 })
                                     },
                                     &mut struct_fields, "a struct field", "a list of struct field", Some(&mut last_token)
                                 )?;
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, last_token),
                                     value: Literal::Struct(LiteralStruct{
                                         parser_type,
                                         fields: struct_fields,
                                         definition: target_definition_id,
                                     }),
                                     parent: ExpressionParent::None,
                                     concrete_type: ConcreteType::default(),
                                 }).upcast()
                             },
                             Definition::Enum(_) => {
                                 // Enum literal: consume the variant
                                 consume_token(&module.source, iter, TokenKind::ColonColon)?;
                                 let variant = consume_ident_interned(&module.source, iter, ctx)?;
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, variant.span.end),
                                     value: Literal::Enum(LiteralEnum{
                                         parser_type,
                                         variant,
                                         definition: target_definition_id,
                                         variant_idx: 0
                                     }),
                                     parent: ExpressionParent::None,
                                     concrete_type: ConcreteType::default()
                                 }).upcast()
                             },
                             Definition::Union(_) => {
                                 // Union literal: consume the variant
                                 consume_token(&module.source, iter, TokenKind::ColonColon)?;
                                 let variant = consume_ident_interned(&module.source, iter, ctx)?;
                                 // Consume any possible embedded values
                                 let mut end_pos = iter.last_valid_pos();
                                 let values = self.consume_expression_list(module, iter, ctx, Some(&mut end_pos))?;
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, end_pos),
                                     value: Literal::Union(LiteralUnion{
                                         parser_type, variant, values,
                                         definition: target_definition_id,
                                         variant_idx: 0,
                                     }),
                                     parent: ExpressionParent::None,
                                     concrete_type: ConcreteType::default()
                                 }).upcast()
                             },
                             Definition::Component(_) => {
                                 // Component instantiation
                                 let arguments = self.consume_expression_list(module, iter, ctx, None)?;
                                 ctx.heap.alloc_call_expression(|this| CallExpression{
                                     this,
                                     span: parser_type.elements[0].full_span, // TODO: @Span fix
                                     parser_type,
                                     method: Method::UserComponent,
                                     arguments,
                                     definition: target_definition_id,
                                     parent: ExpressionParent::None,
                                     concrete_type: ConcreteType::default(),
                                 }).upcast()
                             },
                             Definition::Function(function_definition) => {
                                 // Check whether it is a builtin function
                                 let method = if function_definition.builtin {
                                     match function_definition.identifier.value.as_str() {
                                         "get" => Method::Get,
                                         "put" => Method::Put,
                                         "fires" => Method::Fires,
                                         "create" => Method::Create,
                                         "length" => Method::Length,
                                         "assert" => Method::Assert,
                                         _ => unreachable!(),
+                                    }
                                 } else {
                                     Method::UserFunction
                                 };
                                 // Function call: consume the arguments
                                 let arguments = self.consume_expression_list(module, iter, ctx, None)?;
                                 ctx.heap.alloc_call_expression(|this| CallExpression{
                                     this,
                                     span: parser_type.elements[0].full_span, // TODO: @Span fix
                                     parser_type,
                                     method,
                                     arguments,
                                     definition: target_definition_id,
                                     parent: ExpressionParent::None,
                                     concrete_type: ConcreteType::default(),
                                 }).upcast()
+                            }
+                        }
                     },
                     _ => {
                         // TODO: Casting expressions
                         return Err(ParseError::new_error_str_at_span(
                             &module.source, parser_type.elements[0].full_span,
                             "unexpected type in expression, note that casting expressions are not yet implemented"
                         ))
+                    }
+                }
             } else {
                 // Check for builtin keywords or builtin functions
                 if ident_text == KW_LIT_NULL || ident_text == KW_LIT_TRUE || ident_text == KW_LIT_FALSE {
                     // Parse builtin literal
                     let value = match ident_text {
                         KW_LIT_NULL => Literal::Null,
                         KW_LIT_TRUE => Literal::True,
                         KW_LIT_FALSE => Literal::False,
                         _ => unreachable!(),
                     };
                     ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                         this,
                         span: ident_span,
                         value,
                         parent: ExpressionParent::None,
                         concrete_type: ConcreteType::default(),
                     }).upcast()
                 } else {
                     // I'm a bit unsure about this. One may as well have wrongfully
                     // typed `TypeWithTypo<Subtype>::`, then we assume that
                     // `TypeWithTypo` is a variable. So might want to come back to
                     // this later to do some silly heuristics.
                     iter.consume();
                     if Some(TokenKind::ColonColon) == iter.next() {
                         return Err(ParseError::new_error_str_at_span(&module.source, ident_span, "unknown identifier"));
+                    }
                     let ident_text = ctx.pool.intern(ident_text);
                     let identifier = Identifier { span: ident_span, value: ident_text };
                     ctx.heap.alloc_variable_expression(|this| VariableExpression {
                         this,
                         identifier,
                         declaration: None,
                         parent: ExpressionParent::None,
                         concrete_type: ConcreteType::default()
                     }).upcast()
+                }
+            }
         } else {
             return Err(ParseError::new_error_str_at_pos(
                 &module.source, iter.last_valid_pos(), "expected an expression"
             ));
         };
         Ok(result)
+    }
     //--------------------------------------------------------------------------
     // Expression Utilities
     //--------------------------------------------------------------------------
     #[inline]
     fn consume_generic_binary_expression<
         M: Fn(Option<TokenKind>) -> Option<BinaryOperator>,
         F: Fn(&mut PassDefinitions, &Module, &mut TokenIter, &mut PassCtx) -> Result<ExpressionId, ParseError>
     >(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, match_fn: M, higher_precedence_fn: F
     ) -> Result<ExpressionId, ParseError> {
         let mut result = higher_precedence_fn(self, module, iter, ctx)?;
         while let Some(operation) = match_fn(iter.next()) {
             let span = iter.next_span();
             iter.consume();
             let left = result;
             let right = higher_precedence_fn(self, module, iter, ctx)?;
             result = ctx.heap.alloc_binary_expression(|this| BinaryExpression{
                 this, span, left, operation, right,
                 parent: ExpressionParent::None,
                 concrete_type: ConcreteType::default()
             }).upcast();
+        }
         Ok(result)
+    }
     #[inline]
     fn consume_expression_list(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, end_pos: Option<&mut InputPosition>
     ) -> Result<Vec<ExpressionId>, ParseError> {
         let mut section = self.expressions.start_section();
         consume_comma_separated(
             TokenKind::OpenParen, TokenKind::CloseParen, &module.source, iter, ctx,
             |_source, iter, ctx| self.consume_expression(module, iter, ctx),
             &mut section, "an expression", "a list of expressions", end_pos
         )?;
         Ok(section.into_vec())
+    }
+}
 /// Consumes a type. A type always starts with an identifier which may indicate
 /// a builtin type or a user-defined type. The fact that it may contain
 /// polymorphic arguments makes it a tree-like structure. Because we cannot rely
 /// on knowing the exact number of polymorphic arguments we do not check for
 /// these.
 ///
 /// Note that the first depth index is used as a hack.
 // TODO: @Optimize, @Span fix
 fn consume_parser_type(
     source: &InputSource, iter: &mut TokenIter, symbols: &SymbolTable, heap: &Heap, poly_vars: &[Identifier],
     cur_scope: SymbolScope, wrapping_definition: DefinitionId, allow_inference: bool, first_angle_depth: i32,
 ) -> Result<ParserType, ParseError> {
     struct Entry{
         element: ParserTypeElement,
         depth: i32,
+    }
     fn insert_array_before(elements: &mut Vec<Entry>, depth: i32, span: InputSpan) {
         let index = elements.iter().rposition(|e| e.depth == depth).unwrap();
         elements.insert(index, Entry{
             element: ParserTypeElement{ full_span: span, variant: ParserTypeVariant::Array },
             depth,
         });
+    }
     // Most common case we just have one type, perhaps with some array
     // annotations.
     let element = consume_parser_type_ident(source, iter, symbols, heap, poly_vars, cur_scope, wrapping_definition, allow_inference)?;
     if iter.next() != Some(TokenKind::OpenAngle) {
         let mut num_array = 0;
         while iter.next() == Some(TokenKind::OpenSquare) {
             iter.consume();
             consume_token(source, iter, TokenKind::CloseSquare)?;
             num_array += 1;
+        }
         let array_span = element.full_span;
         let mut elements = Vec::with_capacity(num_array + 1);
         for _ in 0..num_array {
             elements.push(ParserTypeElement{ full_span: array_span, variant: ParserTypeVariant::Array });
+        }
         elements.push(element);
         return Ok(ParserType{ elements });
     };
     // We have a polymorphic specification. So we start by pushing the item onto
     // our stack, then start adding entries together with the angle-brace depth
     // at which they're found.
     let mut elements = Vec::new();
     elements.push(Entry{ element, depth: 0 });
     // Start out with the first '<' consumed.
     iter.consume();
     enum State { Ident, Open, Close, Comma }
     let mut state = State::Open;
     let mut angle_depth = first_angle_depth + 1;
     loop {
         let next = iter.next();
         match state {
             State::Ident => {
                 // Just parsed an identifier, may expect comma, angled braces,
                 // or the tokens indicating an array
                 if Some(TokenKind::OpenAngle) == next {
                     angle_depth += 1;
                     state = State::Open;
                 } else if Some(TokenKind::CloseAngle) == next {
                     angle_depth -= 1;
                     state = State::Close;
                 } else if Some(TokenKind::ShiftRight) == next {
                     angle_depth -= 2;
                     state = State::Close;
                 } else if Some(TokenKind::Comma) == next {
                     state = State::Comma;
                 } else if Some(TokenKind::OpenSquare) == next {
                     let (start_pos, _) = iter.next_positions();
                     iter.consume(); // consume opening square
                     if iter.next() != Some(TokenKind::CloseSquare) {
                         return Err(ParseError::new_error_str_at_pos(
                             source, iter.last_valid_pos(),
                             "unexpected token: expected ']'"
                         ));
+                    }
                     let (_, end_pos) = iter.next_positions();
                     let array_span = InputSpan::from_positions(start_pos, end_pos);
                     insert_array_before(&mut elements, angle_depth, array_span);
                 } else {
                     return Err(ParseError::new_error_str_at_pos(
                         source, iter.last_valid_pos(),
                         "unexpected token: expected '<', '>', ',' or '['")
                     );
+                }
                 iter.consume();
             },
             State::Open => {
                 // Just parsed an opening angle bracket, expecting an identifier
                 let element = consume_parser_type_ident(source, iter, symbols, heap, poly_vars, cur_scope, wrapping_definition, allow_inference)?;
                 elements.push(Entry{ element, depth: angle_depth });
                 state = State::Ident;
             },
             State::Close => {
                 // Just parsed 1 or 2 closing angle brackets, expecting comma,
                 // more closing brackets or the tokens indicating an array
                 if Some(TokenKind::Comma) == next {
                     state = State::Comma;
                 } else if Some(TokenKind::CloseAngle) == next {
                     angle_depth -= 1;
                     state = State::Close;
                 } else if Some(TokenKind::ShiftRight) == next {
                     angle_depth -= 2;
                     state = State::Close;
                 } else if Some(TokenKind::OpenSquare) == next {
                     let (start_pos, _) = iter.next_positions();
                     iter.consume();
                     if iter.next() != Some(TokenKind::CloseSquare) {
                         return Err(ParseError::new_error_str_at_pos(
                             source, iter.last_valid_pos(),
                             "unexpected token: expected ']'"
                         ));
+                    }
                     let (_, end_pos) = iter.next_positions();
                     let array_span = InputSpan::from_positions(start_pos, end_pos);
                     insert_array_before(&mut elements, angle_depth, array_span);
                 } else {
                     return Err(ParseError::new_error_str_at_pos(
                         source, iter.last_valid_pos(),
                         "unexpected token: expected ',', '>', or '['")
                     );
+                }
                 iter.consume();
             },
             State::Comma => {
                 // Just parsed a comma, expecting an identifier or more closing
                 // braces
                 if Some(TokenKind::Ident) == next {
                     let element = consume_parser_type_ident(source, iter, symbols, heap, poly_vars, cur_scope, wrapping_definition, allow_inference)?;
                     elements.push(Entry{ element, depth: angle_depth });
                     state = State::Ident;
                 } else if Some(TokenKind::CloseAngle) == next {
                     iter.consume();
                     angle_depth -= 1;
                     state = State::Close;
                 } else if Some(TokenKind::ShiftRight) == next {
                     iter.consume();
                     angle_depth -= 2;
                     state = State::Close;
                 } else {
                     return Err(ParseError::new_error_str_at_pos(
                         source, iter.last_valid_pos(),
                         "unexpected token: expected '>' or a type name"
                     ));
+                }
+            }
+        }
         if angle_depth < 0 {
             return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "unmatched '>'"));
         } else if angle_depth == 0 {
             break;
+        }
+    }
     // If here then we found the correct number of angle braces. But we still
     // need to make sure that each encountered type has the correct number of
     // embedded types.
     let mut idx = 0;
     while idx < elements.len() {
         let cur_element = &elements[idx];
         let expected_subtypes = cur_element.element.variant.num_embedded();
         let mut encountered_subtypes = 0;
         for peek_idx in idx + 1..elements.len() {
             let peek_element = &elements[peek_idx];
             if peek_element.depth == cur_element.depth + 1 {
                 encountered_subtypes += 1;
             } else if peek_element.depth <= cur_element.depth {
                 break;
+            }
+        }
         if expected_subtypes != encountered_subtypes {
             if encountered_subtypes == 0 {
                 // Case where we have elided the embedded types, all of them
                 // should be inferred.
                 if !allow_inference {
                     return Err(ParseError::new_error_str_at_span(
                         source, cur_element.element.full_span,
                         "type inference is not allowed here"
                     ));
+                }
                 // Insert the missing types
                 let inserted_span = cur_element.element.full_span;
                 let inserted_depth = cur_element.depth + 1;
                 elements.reserve(expected_subtypes);
                 for _ in 0..expected_subtypes {
                     elements.insert(idx + 1, Entry{
                         element: ParserTypeElement{ full_span: inserted_span, variant: ParserTypeVariant::Inferred },
                         depth: inserted_depth,
                     });
+                }
             } else {
                 // Mismatch in number of embedded types
                 let expected_args_text = if expected_subtypes == 1 {
                     "polymorphic argument"
                 } else {
                     "polymorphic arguments"
                 };
                 let maybe_infer_text = if allow_inference {
                     " (or none, to perform implicit type inference)"
                 } else {
                     ""
                 };
                 return Err(ParseError::new_error_at_span(
                     source, cur_element.element.full_span,
                     format!(
                         "expected {} {}{}, but {} were provided",
                         expected_subtypes, expected_args_text, maybe_infer_text, encountered_subtypes
+                    )
                 ));
+            }
+        }
         idx += 1;
+    }
     let mut constructed_elements = Vec::with_capacity(elements.len());
     for element in elements.into_iter() {
         constructed_elements.push(element.element);
+    }
     Ok(ParserType{ elements: constructed_elements })
+}
 /// Consumes an identifier for which we assume that it resolves to some kind of
 /// type. Once we actually arrive at a type we will stop parsing. Hence there
 /// may be trailing '::' tokens in the iterator.
 fn consume_parser_type_ident(
     source: &InputSource, iter: &mut TokenIter, symbols: &SymbolTable, heap: &Heap, poly_vars: &[Identifier],
     mut scope: SymbolScope, wrapping_definition: DefinitionId, allow_inference: bool,
 ) -> Result<ParserTypeElement, ParseError> {
     use ParserTypeVariant as PTV;
     let (mut type_text, mut type_span) = consume_any_ident(source, iter)?;
     let variant = match type_text {
         KW_TYPE_MESSAGE => PTV::Message,
         KW_TYPE_BOOL => PTV::Bool,
         KW_TYPE_UINT8 => PTV::UInt8,
         KW_TYPE_UINT16 => PTV::UInt16,
         KW_TYPE_UINT32 => PTV::UInt32,
         KW_TYPE_UINT64 => PTV::UInt64,
         KW_TYPE_SINT8 => PTV::SInt8,
         KW_TYPE_SINT16 => PTV::SInt16,
         KW_TYPE_SINT32 => PTV::SInt32,
         KW_TYPE_SINT64 => PTV::SInt64,
         KW_TYPE_IN_PORT => PTV::Input,
         KW_TYPE_OUT_PORT => PTV::Output,
         KW_TYPE_CHAR => PTV::Character,
         KW_TYPE_STRING => PTV::String,
         KW_TYPE_INFERRED => {
             if !allow_inference {
                 return Err(ParseError::new_error_str_at_span(source, type_span, "type inference is not allowed here"));
+            }
             PTV::Inferred
         },
         _ => {
             // Must be some kind of symbolic type
             let mut type_kind = None;
             for (poly_idx, poly_var) in poly_vars.iter().enumerate() {
                 if poly_var.value.as_bytes() == type_text {
                     type_kind = Some(PTV::PolymorphicArgument(wrapping_definition, poly_idx));
+                }
+            }
             if type_kind.is_none() {
                 // Check symbol table for definition. To be fair, the language
                 // only allows a single namespace for now. That said:
                 let last_symbol = symbols.get_symbol_by_name(scope, type_text);
                 if last_symbol.is_none() {
                     return Err(ParseError::new_error_str_at_span(source, type_span, "unknown type"));
+                }
                 let mut last_symbol = last_symbol.unwrap();
                 loop {
                     match &last_symbol.variant {
                         SymbolVariant::Module(symbol_module) => {
                             // Expecting more identifiers
                             if Some(TokenKind::ColonColon) != iter.next() {
                                 return Err(ParseError::new_error_str_at_span(source, type_span, "expected type but got module"));
+                            }
                             consume_token(source, iter, TokenKind::ColonColon)?;
                             // Consume next part of type and prepare for next
                             // lookup loop
                             let (next_text, next_span) = consume_any_ident(source, iter)?;
                             let old_text = type_text;
                             type_text = next_text;
                             type_span.end = next_span.end;
                             scope = SymbolScope::Module(symbol_module.root_id);
                             let new_symbol = symbols.get_symbol_by_name_defined_in_scope(scope, type_text);
                             if new_symbol.is_none() {
                                 return Err(ParseError::new_error_at_span(
                                     source, next_span,
                                     format!(
                                         "unknown type '{}' in module '{}'",
                                         String::from_utf8_lossy(type_text),
                                         String::from_utf8_lossy(old_text)
+                                    )
                                 ));
+                            }
                             last_symbol = new_symbol.unwrap();
                         },
                         SymbolVariant::Definition(symbol_definition) => {
                             let num_poly_vars = heap[symbol_definition.definition_id].poly_vars().len();
                             type_kind = Some(PTV::Definition(symbol_definition.definition_id, num_poly_vars));
                             break;
+                        }
+                    }
+                }
+            }
             debug_assert!(type_kind.is_some());
             type_kind.unwrap()
         },
     };
     Ok(ParserTypeElement{ full_span: type_span, variant })
+}
 /// Consumes polymorphic variables and throws them on the floor.
 fn consume_polymorphic_vars_spilled(source: &InputSource, iter: &mut TokenIter, _ctx: &mut PassCtx) -> Result<(), ParseError> {
     maybe_consume_comma_separated_spilled(
         TokenKind::OpenAngle, TokenKind::CloseAngle, source, iter, _ctx,
         |source, iter, _ctx| {
             consume_ident(source, iter)?;
             Ok(())
         }, "a polymorphic variable"
     )?;
     Ok(())
+}
 /// Consumes the parameter list to functions/components
 fn consume_parameter_list(
     source: &InputSource, iter: &mut TokenIter, ctx: &mut PassCtx,
     target: &mut ScopedSection<ParameterId>, scope: SymbolScope, definition_id: DefinitionId
 ) -> Result<(), ParseError> {
     consume_comma_separated(
         TokenKind::OpenParen, TokenKind::CloseParen, source, iter, ctx,
         |source, iter, ctx| {
             let poly_vars = ctx.heap[definition_id].poly_vars(); // TODO: @Cleanup, this is really ugly. But rust...
             let (start_pos, _) = iter.next_positions();
             let parser_type = consume_parser_type(
                 source, iter, &ctx.symbols, &ctx.heap, poly_vars, scope,
                 definition_id, false, 0
             )?;
             let identifier = consume_ident_interned(source, iter, ctx)?;
             let parameter_id = ctx.heap.alloc_parameter(|this| Parameter{
                 this,
                 span: InputSpan::from_positions(start_pos, identifier.span.end),
                 parser_type,
                 identifier
             });
             Ok(parameter_id)
         },
         target, "a parameter", "a parameter list", None
+    )
+}
@@ \ No newline at end of file @@

src/protocol/parser/pass_imports.rs

➞

Show inline comments

 use crate::protocol::ast::*;
 use super::symbol_table::*;
 use super::{Module, ModuleCompilationPhase, PassCtx};
 use super::tokens::*;
 use super::token_parsing::*;
 use crate::protocol::input_source::{InputSource as InputSource, InputSpan, ParseError};
 use crate::collections::*;
 /// Parses all the imports in the module tokens. Is applied after the
 /// definitions and name of modules are resolved. Hence we should be able to
 /// resolve all symbols to their appropriate module/definition.
 pub(crate) struct PassImport {
     imports: Vec<ImportId>,
     found_symbols: Vec<(AliasedSymbol, SymbolDefinition)>,
     scoped_symbols: Vec<Symbol>,
+}
 impl PassImport {
     pub(crate) fn new() -> Self {
         Self{
             imports: Vec::with_capacity(32),
             found_symbols: Vec::with_capacity(32),
             scoped_symbols: Vec::with_capacity(32),
+        }
+    }
     pub(crate) fn parse(&mut self, modules: &mut [Module], module_idx: usize, ctx: &mut PassCtx) -> Result<(), ParseError> {
         let module = &modules[module_idx];
         let module_range = &module.tokens.ranges[0];
         debug_assert!(modules.iter().all(|m| m.phase >= ModuleCompilationPhase::SymbolsScanned));
         debug_assert_eq!(module.phase, ModuleCompilationPhase::SymbolsScanned);
         debug_assert_eq!(module_range.range_kind, TokenRangeKind::Module);
         let mut range_idx = module_range.first_child_idx;
         loop {
             let range_idx_usize = range_idx as usize;
             let cur_range = &module.tokens.ranges[range_idx_usize];
             if cur_range.range_kind == TokenRangeKind::Import {
                 self.visit_import_range(modules, module_idx, ctx, range_idx_usize)?;
+            }
             match cur_range.next_sibling_idx {
                 Some(idx) => { range_idx = idx; },
                 None => { break; }
             if cur_range.next_sibling_idx == NO_SIBLING {
                 break;
             } else {
                 range_idx = cur_range.next_sibling_idx;
+            }
+        }
         let root = &mut ctx.heap[module.root_id];
         root.imports.extend(self.imports.drain(..));
         let module = &mut modules[module_idx];
         module.phase = ModuleCompilationPhase::ImportsResolved;
         Ok(())
+    }
     pub(crate) fn visit_import_range(
         &mut self, modules: &[Module], module_idx: usize, ctx: &mut PassCtx, range_idx: usize
     ) -> Result<(), ParseError> {
         let module = &modules[module_idx];
         let import_range = &module.tokens.ranges[range_idx];
         debug_assert_eq!(import_range.range_kind, TokenRangeKind::Import);
         let mut iter = module.tokens.iter_range(import_range);
         // Consume "import"
         let (_import_ident, import_span) =
             consume_any_ident(&module.source, &mut iter)?;
         debug_assert_eq!(_import_ident, KW_IMPORT);
         // Consume module name
         let (module_name, module_name_span) = consume_domain_ident(&module.source, &mut iter)?;
         let target_root_id = ctx.symbols.get_module_by_name(module_name);
         if target_root_id.is_none() {
             return Err(ParseError::new_error_at_span(
                 &module.source, module_name_span,
                 format!("could not resolve module '{}'", String::from_utf8_lossy(module_name))
             ));
+        }
         let module_name = ctx.pool.intern(module_name);
         let module_identifier = Identifier{ span: module_name_span, value: module_name };
         let target_root_id = target_root_id.unwrap();
         // Check for subsequent characters (alias, multiple imported symbols)
         let next = iter.next();
         let import_id;
         if has_ident(&module.source, &mut iter, b"as") {
             // Alias for module
             iter.consume();
             let alias_identifier = consume_ident_interned(&module.source, &mut iter, ctx)?;
             let alias_name = alias_identifier.value.clone();
             import_id = ctx.heap.alloc_import(|this| Import::Module(ImportModule{
                 this,
                 span: import_span,
                 module: module_identifier,
                 alias: alias_identifier,
                 module_id: target_root_id
             }));
             ctx.symbols.insert_symbol(SymbolScope::Module(module.root_id), Symbol{
                 name: alias_name,
                 variant: SymbolVariant::Module(SymbolModule{
                     root_id: target_root_id,
                     introduced_at: import_id,
                 }),
             });
         } else if Some(TokenKind::ColonColon) == next {
             iter.consume();
             // Helper function to consume symbols, their alias, and the
             // definition the symbol is pointing to.
             fn consume_symbol_and_maybe_alias<'a>(
                 source: &'a InputSource, iter: &mut TokenIter, ctx: &mut PassCtx,
                 module_name: &StringRef<'static>, module_root_id: RootId,
             ) -> Result<(AliasedSymbol, SymbolDefinition), ParseError> {
                 // Consume symbol name and make sure it points to an existing definition
                 let symbol_identifier = consume_ident_interned(source, iter, ctx)?;
                 // Consume alias text if specified
                 let alias_identifier = if peek_ident(source, iter) == Some(b"as") {
                     // Consume alias
                     iter.consume();
                     Some(consume_ident_interned(source, iter, ctx)?)
                 } else {
                     None
                 };
                 let target = ctx.symbols.get_symbol_by_name_defined_in_scope(
                     SymbolScope::Module(module_root_id), symbol_identifier.value.as_bytes()
                 );
                 if target.is_none() {
                     return Err(ParseError::new_error_at_span(
                         source, symbol_identifier.span,
                         format!(
                             "could not find symbol '{}' within module '{}'",
                             symbol_identifier.value.as_str(), module_name.as_str()
+                        )
                     ));
+                }
                 let target = target.unwrap();
                 debug_assert_ne!(target.class(), SymbolClass::Module);
                 let target_definition = target.variant.as_definition();
                 Ok((
                     AliasedSymbol{
                         name: symbol_identifier,
                         alias: alias_identifier,
                         definition_id: target_definition.definition_id,
                     },
                     target_definition.clone()
                 ))
+            }
             let next = iter.next();
             if Some(TokenKind::Ident) == next {
                 // Importing a single symbol
                 iter.consume();
                 let (imported_symbol, symbol_definition) = consume_symbol_and_maybe_alias(
                     &module.source, &mut iter, ctx, &module_identifier.value, target_root_id
                 )?;
                 let alias_identifier = match imported_symbol.alias.as_ref() {
                     Some(alias) => alias.clone(),
                     None => imported_symbol.name.clone(),
                 };
                 import_id = ctx.heap.alloc_import(|this| Import::Symbols(ImportSymbols{
                     this,
                     span: InputSpan::from_positions(import_span.begin, alias_identifier.span.end),
                     module: module_identifier,
                     module_id: target_root_id,
                     symbols: vec![imported_symbol],
                 }));
                 if let Err((new_symbol, old_symbol)) = ctx.symbols.insert_symbol(
                     SymbolScope::Module(module.root_id),
                     Symbol{
                         name: alias_identifier.value,
                         variant: SymbolVariant::Definition(symbol_definition.into_imported(import_id))
+                    }
                 ) {
                     return Err(construct_symbol_conflict_error(
                         modules, module_idx, ctx, &new_symbol, &old_symbol
                     ));
+                }
             } else if Some(TokenKind::OpenCurly) == next {
                 // Importing multiple symbols
                 let mut end_of_list = iter.last_valid_pos();
                 consume_comma_separated(
                     TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, &mut iter, ctx,
                     |source, iter, ctx| consume_symbol_and_maybe_alias(
                         source, iter, ctx, &module_identifier.value, target_root_id
                     ),
                     &mut self.found_symbols, "a symbol", "a list of symbols to import", Some(&mut end_of_list)
                 )?;
                 // Preallocate import
                 import_id = ctx.heap.alloc_import(|this| Import::Symbols(ImportSymbols {
                     this,
                     span: InputSpan::from_positions(import_span.begin, end_of_list),
                     module: module_identifier,
                     module_id: target_root_id,
                     symbols: Vec::with_capacity(self.found_symbols.len()),
                 }));
                 // Fill import symbols while inserting symbols in the
                 // appropriate scope in the symbol table.
                 let import = ctx.heap[import_id].as_symbols_mut();
                 for (imported_symbol, symbol_definition) in self.found_symbols.drain(..) {
                     let import_name = match imported_symbol.alias.as_ref() {
                         Some(import) => import.value.clone(),
                         None => imported_symbol.name.value.clone()
                     };
                     import.symbols.push(imported_symbol);
                     if let Err((new_symbol, old_symbol)) = ctx.symbols.insert_symbol(
                         SymbolScope::Module(module.root_id), Symbol{
                             name: import_name,
                             variant: SymbolVariant::Definition(symbol_definition.into_imported(import_id))
+                        }
                     ) {
                         return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, &old_symbol));
+                    }
+                }
             } else if Some(TokenKind::Star) == next {
                 // Import all symbols from the module
                 let star_span = iter.next_span();
                 iter.consume();
                 self.scoped_symbols.clear();
                 let _found = ctx.symbols.get_all_symbols_defined_in_scope(
                     SymbolScope::Module(target_root_id),
                     &mut self.scoped_symbols
                 );
                 debug_assert!(_found); // even modules without symbols should have a scope
                 // Preallocate import
                 import_id = ctx.heap.alloc_import(|this| Import::Symbols(ImportSymbols{
                     this,
                     span: InputSpan::from_positions(import_span.begin, star_span.end),
                     module: module_identifier,
                     module_id: target_root_id,
                     symbols: Vec::with_capacity(self.scoped_symbols.len())
                 }));
                 // Fill import AST node and symbol table
                 let import = ctx.heap[import_id].as_symbols_mut();
                 for symbol in self.scoped_symbols.drain(..) {
                     let symbol_name = symbol.name;
                     match symbol.variant {
                         SymbolVariant::Definition(symbol_definition) => {
                             import.symbols.push(AliasedSymbol{
                                 name: Identifier{ span: star_span, value: symbol_name.clone() },
                                 alias: None,
                                 definition_id: symbol_definition.definition_id,
                             });
                             if let Err((new_symbol, old_symbol)) = ctx.symbols.insert_symbol(
                                 SymbolScope::Module(module.root_id),
                                 Symbol{
                                     name: symbol_name,
                                     variant: SymbolVariant::Definition(symbol_definition.into_imported(import_id))
+                                }
                             ) {
                                 return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, &old_symbol));
+                            }
                         },
                         _ => unreachable!(),
+                    }
+                }
             } else {
                 return Err(ParseError::new_error_str_at_pos(
                     &module.source, iter.last_valid_pos(), "expected symbol name, '{' or '*'"
                 ));
+            }
         } else {
             // Assume implicit alias
             let module_name_str = module_identifier.value.clone();
             let last_ident_start = module_name_str.as_str().rfind('.').map_or(0, |v| v + 1);
             let alias_text = &module_name_str.as_bytes()[last_ident_start..];
             let alias = ctx.pool.intern(alias_text);
             let alias_span = InputSpan::from_positions(
                 module_name_span.begin.with_offset(last_ident_start as u32),
                 module_name_span.end
             );
             let alias_identifier = Identifier{ span: alias_span, value: alias.clone() };
             import_id = ctx.heap.alloc_import(|this| Import::Module(ImportModule{
                 this,
                 span: InputSpan::from_positions(import_span.begin, module_identifier.span.end),
                 module: module_identifier,
                 alias: alias_identifier,
                 module_id: target_root_id,
             }));
             if let Err((new_symbol, old_symbol)) = ctx.symbols.insert_symbol(SymbolScope::Module(module.root_id), Symbol{
                 name: alias,
                 variant: SymbolVariant::Module(SymbolModule{
                     root_id: target_root_id,
                     introduced_at: import_id
                 })
             }) {
                 return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, &old_symbol));
+            }
+        }
         // By now the `import_id` is set, just need to make sure that the import
         // properly ends with a semicolon
         consume_token(&module.source, &mut iter, TokenKind::SemiColon)?;
         self.imports.push(import_id);
         Ok(())
+    }
+}

src/protocol/parser/pass_symbols.rs

➞

Show inline comments

 use crate::protocol::ast::*;
 use super::symbol_table::*;
 use crate::protocol::input_source::{ParseError, InputSpan};
 use super::tokens::*;
 use super::token_parsing::*;
 use super::{Module, ModuleCompilationPhase, PassCtx};
 /// Scans the module and finds all module-level type definitions. These will be
 /// added to the symbol table such that during AST-construction we know which
 /// identifiers point to types. Will also parse all pragmas to determine module
 /// names.
 pub(crate) struct PassSymbols {
     symbols: Vec<Symbol>,
     pragmas: Vec<PragmaId>,
     imports: Vec<ImportId>,
     definitions: Vec<DefinitionId>,
     buffer: String,
     has_pragma_version: bool,
     has_pragma_module: bool,
+}
 impl PassSymbols {
     pub(crate) fn new() -> Self {
         Self{
             symbols: Vec::with_capacity(128),
             pragmas: Vec::with_capacity(8),
             imports: Vec::with_capacity(32),
             definitions: Vec::with_capacity(128),
             buffer: String::with_capacity(128),
             has_pragma_version: false,
             has_pragma_module: false,
+        }
+    }
     fn reset(&mut self) {
         self.symbols.clear();
         self.pragmas.clear();
         self.imports.clear();
         self.definitions.clear();
         self.has_pragma_version = false;
         self.has_pragma_module = false;
+    }
     pub(crate) fn parse(&mut self, modules: &mut [Module], module_idx: usize, ctx: &mut PassCtx) -> Result<(), ParseError> {
         self.reset();
         let module = &mut modules[module_idx];
         let module_range = &module.tokens.ranges[0];
         debug_assert_eq!(module.phase, ModuleCompilationPhase::Tokenized);
         debug_assert_eq!(module_range.range_kind, TokenRangeKind::Module);
         debug_assert!(module.root_id.is_invalid()); // not set yet,
         // Preallocate root in the heap
         let root_id = ctx.heap.alloc_protocol_description(|this| {
             Root{
                 this,
                 pragmas: Vec::new(),
                 imports: Vec::new(),
                 definitions: Vec::new(),
+            }
         });
         module.root_id = root_id;
         // Retrieve first range index, then make immutable borrow
         let mut range_idx = module_range.first_child_idx;
         let module = &modules[module_idx];
         // Visit token ranges to detect definitions and pragmas
         loop {
             let range_idx_usize = range_idx as usize;
             let cur_range = &module.tokens.ranges[range_idx_usize];
             let next_sibling_idx = cur_range.next_sibling_idx;
             let range_kind = cur_range.range_kind;
             // Parse if it is a definition or a pragma
             if range_kind == TokenRangeKind::Definition {
                 self.visit_definition_range(modules, module_idx, ctx, range_idx_usize)?;
             } else if range_kind == TokenRangeKind::Pragma {
                 self.visit_pragma_range(modules, module_idx, ctx, range_idx_usize)?;
+            }
             match next_sibling_idx {
                 Some(idx) => { range_idx = idx; },
                 None => { break; },
             if next_sibling_idx == NO_SIBLING {
                 break;
             } else {
                 range_idx = next_sibling_idx;
+            }
+        }
         // Add the module's symbol scope and the symbols we just parsed
         let module_scope = SymbolScope::Module(root_id);
         ctx.symbols.insert_scope(None, module_scope);
         for symbol in self.symbols.drain(..) {
             if let Err((new_symbol, old_symbol)) = ctx.symbols.insert_symbol(module_scope, symbol) {
                 return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, &old_symbol))
+            }
+        }
         // Modify the preallocated root
         let root = &mut ctx.heap[root_id];
         root.pragmas.extend(self.pragmas.drain(..));
         root.definitions.extend(self.definitions.drain(..));
         let module = &mut modules[module_idx];
         module.phase = ModuleCompilationPhase::SymbolsScanned;
         Ok(())
+    }
     fn visit_pragma_range(&mut self, modules: &[Module], module_idx: usize, ctx: &mut PassCtx, range_idx: usize) -> Result<(), ParseError> {
         let module = &modules[module_idx];
         let range = &module.tokens.ranges[range_idx];
         let mut iter = module.tokens.iter_range(range);
         // Consume pragma name
         let (pragma_section, pragma_start, _) = consume_pragma(&module.source, &mut iter)?;
         // Consume pragma values
         if pragma_section == b"#module" {
             // Check if name is defined twice within the same file
             if self.has_pragma_module {
                 return Err(ParseError::new_error_str_at_pos(&module.source, pragma_start, "module name is defined twice"));
+            }
             // Consume the domain-name
             let (module_name, module_span) = consume_domain_ident(&module.source, &mut iter)?;
             if iter.next().is_some() {
                 return Err(ParseError::new_error_str_at_pos(&module.source, iter.last_valid_pos(), "expected end of #module pragma after module name"));
+            }
             // Add to heap and symbol table
             let pragma_span = InputSpan::from_positions(pragma_start, module_span.end);
             let module_name = ctx.pool.intern(module_name);
             let pragma_id = ctx.heap.alloc_pragma(|this| Pragma::Module(PragmaModule{
                 this,
                 span: pragma_span,
                 value: Identifier{ span: module_span, value: module_name.clone() },
             }));
             self.pragmas.push(pragma_id);
             if let Err(other_module_root_id) = ctx.symbols.insert_module(module_name, module.root_id) {
                 // Naming conflict
                 let this_module = &modules[module_idx];
                 let other_module = seek_module(modules, other_module_root_id).unwrap();
                 let other_module_pragma_id = other_module.name.as_ref().map(|v| (*v).0).unwrap();
                 let other_pragma = ctx.heap[other_module_pragma_id].as_module();
                 return Err(ParseError::new_error_str_at_span(
                     &this_module.source, pragma_span, "conflict in module name"
                 ).with_info_str_at_span(
                     &other_module.source, other_pragma.span, "other module is defined here"
                 ));
+            }
             self.has_pragma_module = true;
         } else if pragma_section == b"#version" {
             // Check if version is defined twice within the same file
             if self.has_pragma_version {
                 return Err(ParseError::new_error_str_at_pos(&module.source, pragma_start, "module version is defined twice"));
+            }
             // Consume the version pragma
             let (version, version_span) = consume_integer_literal(&module.source, &mut iter, &mut self.buffer)?;
             let pragma_id = ctx.heap.alloc_pragma(|this| Pragma::Version(PragmaVersion{
                 this,
                 span: InputSpan::from_positions(pragma_start, version_span.end),
                 version,
             }));
             self.pragmas.push(pragma_id);
             self.has_pragma_version = true;
         } else {
             // Custom pragma, maybe we support this in the future, but for now
             // we don't.
             return Err(ParseError::new_error_str_at_pos(&module.source, pragma_start, "illegal pragma name"));
+        }
         Ok(())
+    }
     fn visit_definition_range(&mut self, modules: &[Module], module_idx: usize, ctx: &mut PassCtx, range_idx: usize) -> Result<(), ParseError> {
         let module = &modules[module_idx];
         let range = &module.tokens.ranges[range_idx];
         let definition_span = InputSpan::from_positions(
             module.tokens.start_pos(range),
             module.tokens.end_pos(range)
         );
         let mut iter = module.tokens.iter_range(range);
         // First ident must be type of symbol
         let (kw_text, _) = consume_any_ident(&module.source, &mut iter).unwrap();
         // Retrieve identifier of definition
         let identifier = consume_ident_interned(&module.source, &mut iter, ctx)?;
         let mut poly_vars = Vec::new();
         maybe_consume_comma_separated(
             TokenKind::OpenAngle, TokenKind::CloseAngle, &module.source, &mut iter, ctx,
             |source, iter, ctx| consume_ident_interned(source, iter, ctx),
             &mut poly_vars, "a polymorphic variable", None
         )?;
         let ident_text = identifier.value.clone(); // because we need it later
         let ident_span = identifier.span.clone();
         // Reserve space in AST for definition and add it to the symbol table
         let definition_class;
         let ast_definition_id;
         match kw_text {
             KW_STRUCT => {
                 let struct_def_id = ctx.heap.alloc_struct_definition(|this| {
                     StructDefinition::new_empty(this, module.root_id, definition_span, identifier, poly_vars)
                 });
                 definition_class = DefinitionClass::Struct;
                 ast_definition_id = struct_def_id.upcast();
             },
             KW_ENUM => {
                 let enum_def_id = ctx.heap.alloc_enum_definition(|this| {
                     EnumDefinition::new_empty(this, module.root_id, definition_span, identifier, poly_vars)
                 });
                 definition_class = DefinitionClass::Enum;
                 ast_definition_id = enum_def_id.upcast();
             },
             KW_UNION => {
                 let union_def_id = ctx.heap.alloc_union_definition(|this| {
                     UnionDefinition::new_empty(this, module.root_id, definition_span, identifier, poly_vars)
                 });
                 definition_class = DefinitionClass::Union;
                 ast_definition_id = union_def_id.upcast()
             },
             KW_FUNCTION => {
                 let func_def_id = ctx.heap.alloc_function_definition(|this| {
                     FunctionDefinition::new_empty(this, module.root_id, definition_span, identifier, poly_vars)
                 });
                 definition_class = DefinitionClass::Function;
                 ast_definition_id = func_def_id.upcast();
             },
             KW_PRIMITIVE | KW_COMPOSITE => {
                 let component_variant = if kw_text == KW_PRIMITIVE {
                     ComponentVariant::Primitive
                 } else {
                     ComponentVariant::Composite
                 };
                 let comp_def_id = ctx.heap.alloc_component_definition(|this| {
                     ComponentDefinition::new_empty(this, module.root_id, definition_span, component_variant, identifier, poly_vars)
                 });
                 definition_class = DefinitionClass::Component;
                 ast_definition_id = comp_def_id.upcast();
             },
             _ => unreachable!("encountered keyword '{}' in definition range", String::from_utf8_lossy(kw_text)),
+        }
         let symbol = Symbol{
             name: ident_text,
             variant: SymbolVariant::Definition(SymbolDefinition{
                 defined_in_module: module.root_id,
                 defined_in_scope: SymbolScope::Module(module.root_id),
                 definition_span,
                 identifier_span: ident_span,
                 imported_at: None,
                 class: definition_class,
                 definition_id: ast_definition_id,
             }),
         };
         self.symbols.push(symbol);
         self.definitions.push(ast_definition_id);
         Ok(())
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/pass_tokenizer.rs

➞

Show inline comments

 use crate::protocol::input_source::{
     InputSource as InputSource,
     ParseError,
     InputPosition as InputPosition,
 };
 use super::tokens::*;
 use super::token_parsing::*;
 /// Tokenizer is a reusable parser to tokenize multiple source files using the
 /// same allocated buffers. In a well-formed program, we produce a consistent
 /// tree of token ranges such that we may identify tokens that represent a
 /// defintion or an import before producing the entire AST.
 ///
 /// If the program is not well-formed then the tree may be inconsistent, but we
 /// will detect this once we transform the tokens into the AST. To ensure a
 /// consistent AST-producing phase we will require the import to have balanced
 /// curly braces
 pub(crate) struct PassTokenizer {
     // Stack of input positions of opening curly braces, used to detect
     // unmatched opening braces, unmatched closing braces are detected
     // immediately.
     curly_stack: Vec<InputPosition>,
     // Points to an element in the `TokenBuffer.ranges` variable.
     stack_idx: usize,
+}
 impl PassTokenizer {
     pub(crate) fn new() -> Self {
         Self{
             curly_stack: Vec::with_capacity(32),
             stack_idx: 0
+        }
+    }
     pub(crate) fn tokenize(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {
         // Assert source and buffer are at start
         debug_assert_eq!(source.pos().offset, 0);
         debug_assert!(target.tokens.is_empty());
         debug_assert!(target.ranges.is_empty());
         // Set up for tokenization by pushing the first range onto the stack.
         // This range may get transformed into the appropriate range kind later,
         // see `push_range` and `pop_range`.
         self.stack_idx = 0;
         target.ranges.push(TokenRange{
-            parent_idx: 0,
+            parent_idx: NO_RELATION,
             range_kind: TokenRangeKind::Module,
             curly_depth: 0,
             start: 0,
             end: 0,
             num_child_ranges: 0,
             first_child_idx: 0,
             last_child_idx: 0,
             next_sibling_idx: None,
             first_child_idx: NO_RELATION,
             last_child_idx: NO_RELATION,
             next_sibling_idx: NO_RELATION,
         });
         // Main tokenization loop
         while let Some(c) = source.next() {
             let token_index = target.tokens.len() as u32;
             if is_char_literal_start(c) {
                 self.consume_char_literal(source, target)?;
             } else if is_string_literal_start(c) {
                 self.consume_string_literal(source, target)?;
             } else if is_identifier_start(c) {
                 let ident = self.consume_identifier(source, target)?;
                 if demarks_definition(ident) {
                     self.push_range(target, TokenRangeKind::Definition, token_index);
                 } else if demarks_import(ident) {
                     self.push_range(target, TokenRangeKind::Import, token_index);
+                }
             } else if is_integer_literal_start(c) {
                 self.consume_number(source, target)?;
             } else if is_pragma_start_or_pound(c) {
                 let was_pragma = self.consume_pragma_or_pound(c, source, target)?;
                 if was_pragma {
                     self.push_range(target, TokenRangeKind::Pragma, token_index);
+                }
             } else if self.is_line_comment_start(c, source) {
                 self.consume_line_comment(source, target)?;
             } else if self.is_block_comment_start(c, source) {
                 self.consume_block_comment(source, target)?;
             } else if is_whitespace(c) {
                 let contained_newline = self.consume_whitespace(source);
                 if contained_newline {
                     let range = &target.ranges[self.stack_idx];
                     if range.range_kind == TokenRangeKind::Pragma {
                         self.pop_range(target, target.tokens.len() as u32);
+                    }
+                }
             } else {
                 let was_punctuation = self.maybe_parse_punctuation(c, source, target)?;
                 if let Some((token, token_pos)) = was_punctuation {
                     if token == TokenKind::OpenCurly {
                         self.curly_stack.push(token_pos);
                     } else if token == TokenKind::CloseCurly {
                         // Check if this marks the end of a range we're
                         // currently processing
                         if self.curly_stack.is_empty() {
                             return Err(ParseError::new_error_str_at_pos(
                                 source, token_pos, "unmatched closing curly brace '}'"
                             ));
+                        }
                         self.curly_stack.pop();
                         let range = &target.ranges[self.stack_idx];
                         if range.range_kind == TokenRangeKind::Definition && range.curly_depth == self.curly_stack.len() as u32 {
                             self.pop_range(target, target.tokens.len() as u32);
+                        }
                         // Exit early if we have more closing curly braces than
                         // opening curly braces
                     } else if token == TokenKind::SemiColon {
                         // Check if this marks the end of an import
                         let range = &target.ranges[self.stack_idx];
                         if range.range_kind == TokenRangeKind::Import {
                             self.pop_range(target, target.tokens.len() as u32);
+                        }
+                    }
                 } else {
                     return Err(ParseError::new_error_str_at_pos(
                         source, source.pos(), "unexpected character"
                     ));
+                }
+            }
+        }
         // End of file, check if our state is correct
         if let Some(error) = source.had_error.take() {
             return Err(error);
+        }
         if !self.curly_stack.is_empty() {
             // Let's not add a lot of heuristics and just tell the programmer
             // that something is wrong
             let last_unmatched_open = self.curly_stack.pop().unwrap();
             return Err(ParseError::new_error_str_at_pos(
                 source, last_unmatched_open, "unmatched opening curly brace '{'"
             ));
+        }
         // Ranges that did not depend on curly braces may have missing tokens.
         // So close all of the active tokens
         while self.stack_idx != 0 {
             self.pop_range(target, target.tokens.len() as u32);
+        }
         // And finally, we may have a token range at the end that doesn't belong
         // to a range yet, so insert a "code" range if this is the case.
         debug_assert_eq!(self.stack_idx, 0);
         let last_token_idx = target.tokens.len() as u32;
         if target.ranges[0].end != last_token_idx {
+        }
         // TODO: @remove once I'm sure the algorithm works. For now it is better
         //  if the debugging is a little more expedient
         if cfg!(debug_assertions) {
             // For each range make sure its children make sense
             for parent_idx in 0..target.ranges.len() {
                 let cur_range = &target.ranges[parent_idx];
                 if cur_range.num_child_ranges == 0 {
                     assert_eq!(cur_range.first_child_idx, parent_idx as u32);
                     assert_eq!(cur_range.last_child_idx, parent_idx as u32);
                     assert_eq!(cur_range.first_child_idx, NO_RELATION);
                     assert_eq!(cur_range.last_child_idx, NO_RELATION);
                 } else {
                     assert_ne!(cur_range.first_child_idx, parent_idx as u32);
                     assert_ne!(cur_range.last_child_idx, parent_idx as u32);
                     assert_ne!(cur_range.first_child_idx, NO_RELATION);
                     assert_ne!(cur_range.last_child_idx, NO_RELATION);
                     let mut child_counter = 0u32;
                     let last_child_idx = cur_range.first_child_idx;
                     let mut child_idx = Some(cur_range.first_child_idx);
                     while let Some(cur_child_idx) = child_idx {
                         let child_range = &target.ranges[cur_child_idx as usize];
                         assert_eq!(child_range.parent_idx, parent_idx);
                     let mut last_valid_child_idx = cur_range.first_child_idx;
                     let mut child_idx = cur_range.first_child_idx;
                     while child_idx != NO_RELATION {
                         let child_range = &target.ranges[child_idx as usize];
                         assert_eq!(child_range.parent_idx, parent_idx as i32);
                         last_valid_child_idx = child_idx;
                         child_idx = child_range.next_sibling_idx;
                         child_counter += 1;
+                    }
-                    assert_eq!(cur_range.last_child_idx, last_child_idx);
+                    assert_eq!(cur_range.last_child_idx, last_valid_child_idx);
                     assert_eq!(cur_range.num_child_ranges, child_counter);
+                }
+            }
+        }
         Ok(())
+    }
     fn is_line_comment_start(&self, first_char: u8, source: &InputSource) -> bool {
         return first_char == b'/' && Some(b'/') == source.lookahead(1);
+    }
     fn is_block_comment_start(&self, first_char: u8, source: &InputSource) -> bool {
         return first_char == b'/' && Some(b'*') == source.lookahead(1);
+    }
     fn maybe_parse_punctuation(
         &mut self, first_char: u8, source: &mut InputSource, target: &mut TokenBuffer
     ) -> Result<Option<(TokenKind, InputPosition)>, ParseError> {
         debug_assert!(first_char != b'#', "'#' needs special handling");
         debug_assert!(first_char != b'\'', "'\'' needs special handling");
         debug_assert!(first_char != b'"', "'\"' needs special handling");
         let pos = source.pos();
         let token_kind;
         if first_char == b'!' {
             source.consume();
             if Some(b'=') == source.next() {
                 source.consume();
                 token_kind = TokenKind::NotEqual;
             } else {
                 token_kind = TokenKind::Exclamation;
+            }
         } else if first_char == b'%' {
             source.consume();
             if Some(b'=') == source.next() {
                 source.consume();
                 token_kind = TokenKind::PercentEquals;
             } else {
                 token_kind = TokenKind::Percent;
+            }
         } else if first_char == b'&' {
             source.consume();
             let next = source.next();
             if Some(b'&') == next {
                 source.consume();
                 token_kind = TokenKind::AndAnd;
             } else if Some(b'=') == next {
                 source.consume();
                 token_kind = TokenKind::AndEquals;
             } else {
                 token_kind = TokenKind::And;
+            }
         } else if first_char == b'(' {
             source.consume();
             token_kind = TokenKind::OpenParen;
         } else if first_char == b')' {
             source.consume();
             token_kind = TokenKind::CloseParen;
         } else if first_char == b'*' {
             source.consume();
             if let Some(b'=') = source.next() {
                 source.consume();
                 token_kind = TokenKind::StarEquals;
             } else {
                 token_kind = TokenKind::Star;
+            }
         } else if first_char == b'+' {
             source.consume();
             let next = source.next();
             if Some(b'+') == next {
                 source.consume();
                 token_kind = TokenKind::PlusPlus;
             } else if Some(b'=') == next {
                 source.consume();
                 token_kind = TokenKind::PlusEquals;
             } else {
                 token_kind = TokenKind::Plus;
+            }
         } else if first_char == b',' {
             source.consume();
             token_kind = TokenKind::Comma;
         } else if first_char == b'-' {
             source.consume();
             let next = source.next();
             if Some(b'-') == next {
                 source.consume();
                 token_kind = TokenKind::MinusMinus;
             } else if Some(b'>') == next {
                 source.consume();
                 token_kind = TokenKind::ArrowRight;
             } else if Some(b'=') == next {
                 source.consume();
                 token_kind = TokenKind::MinusEquals;
             } else {
                 token_kind = TokenKind::Minus;
+            }
         } else if first_char == b'.' {
             source.consume();
             if let Some(b'.') = source.next() {
                 source.consume();
                 token_kind = TokenKind::DotDot;
             } else {
                 token_kind = TokenKind::Dot
+            }
         } else if first_char == b'/' {
             source.consume();
             debug_assert_ne!(Some(b'/'), source.next());
             debug_assert_ne!(Some(b'*'), source.next());
             if let Some(b'=') = source.next() {
                 source.consume();
                 token_kind = TokenKind::SlashEquals;
             } else {
                 token_kind = TokenKind::Slash;
+            }
         } else if first_char == b':' {
             source.consume();
             if let Some(b':') = source.next() {
                 source.consume();
                 token_kind = TokenKind::ColonColon;
             } else {
                 token_kind = TokenKind::Colon;
+            }
         } else if first_char == b';' {
             source.consume();
             token_kind = TokenKind::SemiColon;
         } else if first_char == b'<' {
             source.consume();
             let next = source.next();
             if let Some(b'<') = next {
                 source.consume();
                 if let Some(b'=') = source.next() {
                     source.consume();
                     token_kind = TokenKind::ShiftLeftEquals;
                 } else {
                     token_kind = TokenKind::ShiftLeft;
+                }
             } else if let Some(b'=') = next {
                 source.consume();
                 token_kind = TokenKind::LessEquals;
             } else {
                 token_kind = TokenKind::OpenAngle;
+            }
         } else if first_char == b'=' {
             source.consume();
             if let Some(b'=') = source.next() {
                 source.consume();
                 token_kind = TokenKind::EqualEqual;
             } else {
                 token_kind = TokenKind::Equal;
+            }
         } else if first_char == b'>' {
             source.consume();
             let next = source.next();
             if Some(b'>') == next {
                 source.consume();
                 if Some(b'=') == source.next() {
                     source.consume();
                     token_kind = TokenKind::ShiftRightEquals;
                 } else {
                     token_kind = TokenKind::ShiftRight;
+                }
             } else if Some(b'=') == next {
                 source.consume();
                 token_kind = TokenKind::GreaterEquals;
             } else {
                 token_kind = TokenKind::CloseAngle;
+            }
         } else if first_char == b'?' {
             source.consume();
             token_kind = TokenKind::Question;
         } else if first_char == b'@' {
             source.consume();
             token_kind = TokenKind::At;
         } else if first_char == b'[' {
             source.consume();
             token_kind = TokenKind::OpenSquare;
         } else if first_char == b']' {
             source.consume();
             token_kind = TokenKind::CloseSquare;
         } else if first_char == b'^' {
             source.consume();
             if let Some(b'=') = source.next() {
                 source.consume();
                 token_kind = TokenKind::CaretEquals;
             } else {
                 token_kind = TokenKind::Caret;
+            }
         } else if first_char == b'{' {
             source.consume();
             token_kind = TokenKind::OpenCurly;
         } else if first_char == b'|' {
             source.consume();
             let next = source.next();
             if Some(b'|') == next {
                 source.consume();
                 token_kind = TokenKind::OrOr;
             } else if Some(b'=') == next {
                 source.consume();
                 token_kind = TokenKind::OrEquals;
             } else {
                 token_kind = TokenKind::Or;
+            }
         } else if first_char == b'}' {
             source.consume();
             token_kind = TokenKind::CloseCurly;
         } else if first_char == b'~' {
             source.consume();
             token_kind = TokenKind::Tilde;
         } else {
             self.check_ascii(source)?;
             return Ok(None);
+        }
         target.tokens.push(Token::new(token_kind, pos));
         Ok(Some((token_kind, pos)))
+    }
     fn consume_char_literal(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {
         let begin_pos = source.pos();
         // Consume the leading quote
         debug_assert!(source.next().unwrap() == b'\'');
         source.consume();
         let mut prev_char = b'\'';
         while let Some(c) = source.next() {
             if !c.is_ascii() {
                 return Err(ParseError::new_error_str_at_pos(source, source.pos(), "non-ASCII character in char literal"));
+            }
             source.consume();
             // Make sure ending quote was not escaped
             if c == b'\'' && prev_char != b'\\' {
                 prev_char = c;
                 break;
+            }
             prev_char = c;
+        }
         if prev_char != b'\'' {
             // Unterminated character literal, reached end of file.
             return Err(ParseError::new_error_str_at_pos(source, begin_pos, "encountered unterminated character literal"));
+        }
         let end_pos = source.pos();
         target.tokens.push(Token::new(TokenKind::Character, begin_pos));
         target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
         Ok(())
+    }
     fn consume_string_literal(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {
         let begin_pos = source.pos();
         // Consume the leading double quotes
         debug_assert!(source.next().unwrap() == b'"');
         source.consume();
         let mut prev_char = b'"';
         while let Some(c) = source.next() {
             if !c.is_ascii() {
                 return Err(ParseError::new_error_str_at_pos(source, source.pos(), "non-ASCII character in string literal"));
+            }
             source.consume();
             if c == b'"' && prev_char != b'\\' {
                 prev_char = c;
                 break;
+            }
             prev_char = c;
+        }
         if prev_char != b'"' {
             // Unterminated string literal
             return Err(ParseError::new_error_str_at_pos(source, begin_pos, "encountered unterminated string literal"));
+        }
         let end_pos = source.pos();
         target.tokens.push(Token::new(TokenKind::String, begin_pos));
         target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
         Ok(())
+    }
     fn consume_pragma_or_pound(&mut self, first_char: u8, source: &mut InputSource, target: &mut TokenBuffer) -> Result<bool, ParseError> {
         let start_pos = source.pos();
         debug_assert_eq!(first_char, b'#');
         source.consume();
         let next = source.next();
         if next.is_none() || !is_identifier_start(next.unwrap()) {
             // Just a pound sign
             target.tokens.push(Token::new(TokenKind::Pound, start_pos));
             Ok(false)
         } else {
             // Pound sign followed by identifier
             source.consume();
             while let Some(c) = source.next() {
                 if !is_identifier_remaining(c) {
                     break;
+                }
                 source.consume();
+            }
             self.check_ascii(source)?;
             let end_pos = source.pos();
             target.tokens.push(Token::new(TokenKind::Pragma, start_pos));
             target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
             Ok(true)
+        }
+    }
     fn consume_line_comment(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {
         let begin_pos = source.pos();
         // Consume the leading "//"
         debug_assert!(source.next().unwrap() == b'/' && source.lookahead(1).unwrap() == b'/');
         source.consume();
         source.consume();
         let mut prev_char = b'/';
         let mut cur_char = b'/';
         while let Some(c) = source.next() {
             prev_char = cur_char;
             cur_char = c;
             if c == b'\n' {
                 // End of line, note that the newline is not consumed
                 break;
+            }
             source.consume();
+        }
         let mut end_pos = source.pos();
         debug_assert_eq!(begin_pos.line, end_pos.line);
         // Modify offset to not include the newline characters
         if cur_char == b'\n' {
             if prev_char == b'\r' {
                 end_pos.offset -= 2;
             } else {
                 end_pos.offset -= 1;
+            }
             // Consume final newline
             source.consume();
         } else {
             // End of comment was due to EOF
             debug_assert!(source.next().is_none())
+        }
         target.tokens.push(Token::new(TokenKind::LineComment, begin_pos));
         target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
         Ok(())
+    }
     fn consume_block_comment(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {
         let begin_pos = source.pos();
         // Consume the leading "/*"
         debug_assert!(source.next().unwrap() == b'/' && source.lookahead(1).unwrap() == b'*');
         source.consume();
         source.consume();
         // Explicitly do not put prev_char at "*", because then "/*/" would
         // represent a valid and closed block comment
         let mut prev_char = b' ';
         let mut is_closed = false;
         while let Some(c) = source.next() {
             source.consume();
             if prev_char == b'*' && c == b'/' {
                 // End of block comment
                 is_closed = true;
                 break;
+            }
             prev_char = c;
+        }
         if !is_closed {
             return Err(ParseError::new_error_str_at_pos(
                 source, source.pos(), "encountered unterminated block comment")
             );
+        }
         let end_pos = source.pos();
         target.tokens.push(Token::new(TokenKind::BlockComment, begin_pos));
         target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
         Ok(())
+    }
     fn consume_identifier<'a>(&mut self, source: &'a mut InputSource, target: &mut TokenBuffer) -> Result<&'a [u8], ParseError> {
         let begin_pos = source.pos();
         debug_assert!(is_identifier_start(source.next().unwrap()));
         source.consume();
         // Keep reading until no more identifier
         while let Some(c) = source.next() {
             if !is_identifier_remaining(c) {
                 break;
+            }
             source.consume();
+        }
         self.check_ascii(source)?;
         let end_pos = source.pos();
         target.tokens.push(Token::new(TokenKind::Ident, begin_pos));
         target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
         Ok(source.section_at_pos(begin_pos, end_pos))
+    }
     fn consume_number(&mut self, source: &mut InputSource, target: &mut TokenBuffer) -> Result<(), ParseError> {
         let begin_pos = source.pos();
         debug_assert!(is_integer_literal_start(source.next().unwrap()));
         source.consume();
         // Keep reading until it doesn't look like a number anymore
         while let Some(c) = source.next() {
             if !maybe_number_remaining(c) {
                 break;
+            }
             source.consume();
+        }
         self.check_ascii(source)?;
         let end_pos = source.pos();
         target.tokens.push(Token::new(TokenKind::Integer, begin_pos));
         target.tokens.push(Token::new(TokenKind::SpanEnd, end_pos));
         Ok(())
+    }
     // Consumes whitespace and returns whether or not the whitespace contained
     // a newline.
     fn consume_whitespace(&self, source: &mut InputSource) -> bool {
         debug_assert!(is_whitespace(source.next().unwrap()));
         let mut has_newline = false;
         while let Some(c) = source.next() {
             if !is_whitespace(c) {
                 break;
+            }
             if c == b'\n' {
                 has_newline = true;
+            }
             source.consume();
+        }
         has_newline
+    }
     /// Pushes a new token range onto the stack in the buffers.
     fn push_range(&mut self, target: &mut TokenBuffer, range_kind: TokenRangeKind, first_token: u32) {
         let new_range_idx = target.ranges.len() as u32;
         let cur_range = &mut target.ranges[self.stack_idx];
         // If we have just popped a range and then push a new range, then the
         // first token is equal to the last token registered on the current
         // range. If not, then we had some intermediate tokens that did not
         // belong to a particular kind of token range: hence we insert an
         // intermediate "code" range.
         if cur_range.end != first_token {
             let code_start = cur_range.end;
     fn push_range(&mut self, target: &mut TokenBuffer, range_kind: TokenRangeKind, first_token_idx: u32) {
         let new_range_idx = target.ranges.len() as i32;
         let parent_idx = self.stack_idx as i32;
         let parent_range = &mut target.ranges[self.stack_idx];
         let curly_depth = self.curly_stack.len() as u32;
             if cur_range.first_child_idx == self.stack_idx as u32 {
                 // The parent of the new "code" range we're going to push does
                 // not have any registered children yet.
                 cur_range.first_child_idx = new_range_idx;
         if parent_range.first_child_idx == NO_RELATION {
             parent_range.first_child_idx = new_range_idx;
+        }
             cur_range.last_child_idx = new_range_idx + 1;
             cur_range.end = first_token;
             cur_range.num_child_ranges += 1;
         if parent_range.end != first_token_idx {
             // We popped a range, processed some intermediate tokens and now
             // enter a new range. Those intermediate tokens do not belong to a
             // particular range yet. So we put them in a "code" range.
             // Remember last sibling from parent (if any)
             let sibling_idx = parent_range.last_child_idx;
             // Push the code range
             let code_start_idx = parent_range.end;
             let code_end_idx = first_token_idx;
             parent_range.last_child_idx = new_range_idx;
             parent_range.end = code_end_idx;
             parent_range.num_child_ranges += 1;
             target.ranges.push(TokenRange{
-                parent_idx: self.stack_idx,
                 parent_idx,
                 range_kind: TokenRangeKind::Code,
                 curly_depth: self.curly_stack.len() as u32,
                 start: code_start,
                 end: first_token,
                 curly_depth,
                 start: code_start_idx,
                 end: code_end_idx,
                 num_child_ranges: 0,
                 first_child_idx: new_range_idx,
                 last_child_idx: new_range_idx,
                 next_sibling_idx: Some(new_range_idx + 1), // we're going to push this thing next
                 first_child_idx: NO_RELATION,
                 last_child_idx: NO_RELATION,
                 next_sibling_idx: new_range_idx + 1, // we're going to push this range below
             });
         } else {
             // We're going to push the range in the code below, but while we
             // have the `cur_range` borrowed mutably, we fix up its children
             // indices.
             if cur_range.first_child_idx == self.stack_idx as u32 {
                 cur_range.first_child_idx = new_range_idx;
             // Fix up the sibling indices
             if sibling_idx != NO_RELATION {
                 let sibling_range = &mut target.ranges[sibling_idx as usize];
                 sibling_range.next_sibling_idx = new_range_idx;
+            }
             cur_range.last_child_idx = new_range_idx;
+        }
         // Insert a new range
         let parent_idx = self.stack_idx;
         // Push the new range
         self.stack_idx = target.ranges.len();
         let new_range_idx = self.stack_idx as u32;
         target.ranges.push(TokenRange{
             parent_idx,
             range_kind,
             curly_depth: self.curly_stack.len() as u32,
             start: first_token,
             end: first_token,
             curly_depth,
             start: first_token_idx,
             end: first_token_idx, // modified when popped
             num_child_ranges: 0,
             first_child_idx: new_range_idx,
             last_child_idx: new_range_idx,
             next_sibling_idx: None,
         });
             first_child_idx: NO_RELATION,
             last_child_idx: NO_RELATION,
             next_sibling_idx: NO_RELATION
         })
+    }
     fn pop_range(&mut self, target: &mut TokenBuffer, end_index: u32) {
         let last = &mut target.ranges[self.stack_idx];
         debug_assert!(self.stack_idx != last.parent_idx, "attempting to pop top-level range");
     fn pop_range(&mut self, target: &mut TokenBuffer, end_token_idx: u32) {
         let popped_idx = self.stack_idx as i32;
         let popped_range = &mut target.ranges[self.stack_idx];
         debug_assert!(self.stack_idx != 0, "attempting to pop top-level range");
         // Fix up the current range before going back to parent
         last.end = end_index;
         debug_assert_ne!(last.start, end_index);
         popped_range.end = end_token_idx;
         debug_assert_ne!(popped_range.start, end_token_idx);
         // Go back to parent
         self.stack_idx = last.parent_idx;
         // Go back to parent and fix up its child pointers, but remember the
         // last child, so we can link it to the newly popped range.
         self.stack_idx = popped_range.parent_idx as usize;
         let parent = &mut target.ranges[self.stack_idx];
         parent.end = end_index;
         if parent.first_child_idx == NO_RELATION {
             parent.first_child_idx = popped_idx;
+        }
         let prev_sibling_idx = parent.last_child_idx;
         parent.last_child_idx = popped_idx;
         parent.end = end_token_idx;
         parent.num_child_ranges += 1;
         // Fix up the sibling (if it exists)
         if prev_sibling_idx != NO_RELATION {
             let sibling = &mut target.ranges[prev_sibling_idx as usize];
             sibling.next_sibling_idx = popped_idx;
+        }
+    }
     fn check_ascii(&self, source: &InputSource) -> Result<(), ParseError> {
         match source.next() {
             Some(c) if !c.is_ascii() => {
                 Err(ParseError::new_error_str_at_pos(source, source.pos(), "encountered a non-ASCII character"))
             },
             _else => {
                 Ok(())
             },
+        }
+    }
+}
 // Helpers for characters
 fn demarks_definition(ident: &[u8]) -> bool {
     return
         ident == KW_STRUCT ||
             ident == KW_ENUM ||
             ident == KW_UNION ||
             ident == KW_FUNCTION ||
             ident == KW_PRIMITIVE ||
             ident == KW_COMPOSITE
+}
 fn demarks_import(ident: &[u8]) -> bool {
     return ident == KW_IMPORT;
+}
 fn is_whitespace(c: u8) -> bool {
     c.is_ascii_whitespace()
+}
 fn is_char_literal_start(c: u8) -> bool {
     return c == b'\'';
+}
 fn is_string_literal_start(c: u8) -> bool {
     return c == b'"';
+}
 fn is_pragma_start_or_pound(c: u8) -> bool {
     return c == b'#';
+}
 fn is_identifier_start(c: u8) -> bool {
     return
         (c >= b'a' && c <= b'z') ||
             (c >= b'A' && c <= b'Z') ||
             c == b'_'
+}
 fn is_identifier_remaining(c: u8) -> bool {
     return
         (c >= b'0' && c <= b'9') ||
             (c >= b'a' && c <= b'z') ||
             (c >= b'A' && c <= b'Z') ||
             c == b'_'
+}
 fn is_integer_literal_start(c: u8) -> bool {
     return c >= b'0' && c <= b'9';
+}
 fn maybe_number_remaining(c: u8) -> bool {
     return
         (c == b'b' || c == b'B' || c == b'o' || c == b'O' || c == b'x' || c == b'X') ||
             (c >= b'0' && c <= b'9') ||
             c == b'_';
+}
 #[cfg(test)]
 mod tests {
     use super::*;
     // TODO: Remove at some point
     #[test]
     fn test_tokenizer() {
         let mut source = InputSource::new_test("
         #version 500
         # hello 2
         import std.reo::*;
         struct Thing {
             int a: 5,
+        }
         enum Hello {
             A,
+            B
+        }
         // Hello hello, is it me you are looking for?
         // I can seee it in your eeeyes
         func something(int a, int b, int c) -> byte {
             int a = 5;
             struct Inner {
                 int a
+            }
             struct City {
                 int b
+            }
             /* Waza
             How are you doing
             Things in here yo
             /* */ */
             a = a + 5 * 2;
             struct Pressure {
                 int d
+            }
+        }
         ");
         let mut t = PassTokenizer::new();
         let mut buffer = TokenBuffer::new();
         t.tokenize(&mut source, &mut buffer).expect("tokenize");
         println!("Ranges:\n");
         for (idx, range) in buffer.ranges.iter().enumerate() {
             println!("[{}] {:?}", idx, range)
+        }
         println!("Tokens:\n");
         let mut iter = buffer.tokens.iter().enumerate();
         while let Some((idx, token)) = iter.next() {
             match token.kind {
                 TokenKind::Ident | TokenKind::Pragma | TokenKind::Integer |
                 TokenKind::String | TokenKind::Character | TokenKind::LineComment |
                 TokenKind::BlockComment => {
                     let (_, end) = iter.next().unwrap();
                     println!("[{}] {:?} ......", idx, token.kind);
                     assert_eq!(end.kind, TokenKind::SpanEnd);
                     let text = source.section_at_pos(token.pos, end.pos);
                     println!("{}", String::from_utf8_lossy(text));
                 },
                 _ => {
                     println!("[{}] {:?}", idx, token.kind);
+                }
+            }
+        }
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/pass_typing.rs

➞

Show inline comments

 /// pass_typing
 ///
 /// Performs type inference and type checking. Type inference is implemented by
 /// applying constraints on (sub)trees of types. During this process the
 /// resolver takes the `ParserType` structs (the representation of the types
 /// written by the programmer), converts them to `InferenceType` structs (the
 /// temporary data structure used during type inference) and attempts to arrive
 /// at `ConcreteType` structs (the representation of a fully checked and
 /// validated type).
 ///
 /// The resolver will visit every statement and expression relevant to the
 /// procedure and insert and determine its initial type based on context (e.g. a
 /// return statement's expression must match the function's return type, an
 /// if statement's test expression must evaluate to a boolean). When all are
 /// visited we attempt to make progress in evaluating the types. Whenever a type
 /// is progressed we queue the related expressions for further type progression.
 /// Once no more expressions are in the queue the algorithm is finished. At this
 /// point either all types are inferred (or can be trivially implicitly
 /// determined), or we have incomplete types. In the latter casee we return an
 /// error.
 ///
 /// Inference may be applied on non-polymorphic procedures and on polymorphic
 /// procedures. When dealing with a non-polymorphic procedure we apply the type
 /// resolver and annotate the AST with the `ConcreteType`s. When dealing with
 /// polymorphic procedures we will only annotate the AST once, preserving
 /// references to polymorphic variables. Any later pass will perform just the
 /// type checking.
 ///
 /// TODO: Needs a thorough rewrite:
 ///  0. polymorph_progress is intentionally broken at the moment.
 ///  1. For polymorphic type inference we need to have an extra datastructure
 ///     for progressing the polymorphic variables and mapping them back to each
 ///     signature type that uses that polymorphic type. The two types of markers
 ///     became somewhat of a mess.
 ///  2. We're doing a lot of extra work. It seems better to apply the initial
 ///     type based on expression parents, then to apply forced constraints (arg
 ///     to a fires() call must be port-like), only then to start progressing the
 ///     types.
 ///     Furthermore, queueing of expressions can be more intelligent, currently
 ///     every child/parent of an expression is inferred again when queued. Hence
 ///     we need to queue only specific children/parents of expressions.
 ///  3. Remove the `msg` type?
 ///  4. Disallow certain types in certain operations (e.g. `Void`).
 ///  5. Implement implicit and explicit casting.
 ///  6. Investigate different ways of performing the type-on-type inference,
 ///     maybe there is a better way then flattened trees + markers?
 macro_rules! debug_log {
     ($format:literal) => {
-        enabled_debug_print!(true, "types", $format);
+        enabled_debug_print!(false, "types", $format);
     };
     ($format:literal, $($args:expr),*) => {
-        enabled_debug_print!(true, "types", $format, $($args),*);
+        enabled_debug_print!(false, "types", $format, $($args),*);
     };
+}
 use std::collections::{HashMap, HashSet};
 use crate::protocol::ast::*;
 use crate::protocol::input_source::ParseError;
 use crate::protocol::parser::ModuleCompilationPhase;
 use crate::protocol::parser::type_table::*;
 use crate::protocol::parser::token_parsing::*;
 use super::visitor::{
     STMT_BUFFER_INIT_CAPACITY,
     EXPR_BUFFER_INIT_CAPACITY,
     Ctx,
     Visitor2,
     VisitorResult
 };
 use std::collections::hash_map::Entry;
 const MESSAGE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Message, InferenceTypePart::UInt8 ];
 const BOOL_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Bool ];
 const CHARACTER_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Character ];
 const STRING_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::String ];
 const NUMBERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::NumberLike ];
 const INTEGERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::IntegerLike ];
 const ARRAY_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Array, InferenceTypePart::Unknown ];
 const ARRAYLIKE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::ArrayLike, InferenceTypePart::Unknown ];
 /// TODO: @performance Turn into PartialOrd+Ord to simplify checks
 /// TODO: @types Remove the Message -> Byte hack at some point...
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub(crate) enum InferenceTypePart {
     // A marker with an identifier which we can use to retrieve the type subtree
     // that follows the marker. This is used to perform type inference on
     // polymorphs: an expression may determine the polymorphs type, after we
     // need to apply that information to all other places where the polymorph is
     // used.
     MarkerDefinition(usize), // marker for polymorph types on a procedure's definition
     MarkerBody(usize), // marker for polymorph types within a procedure body
     // Completely unknown type, needs to be inferred
     Unknown,
     // Partially known type, may be inferred to to be the appropriate related
     // type.
     // IndexLike,      // index into array/slice
     NumberLike,     // any kind of integer/float
     IntegerLike,    // any kind of integer
     ArrayLike,      // array or slice. Note that this must have a subtype
     PortLike,       // input or output port
     // Special types that cannot be instantiated by the user
     Void, // For builtin functions that do not return anything
     // Concrete types without subtypes
     Bool,
     UInt8,
     UInt16,
     UInt32,
     UInt64,
     SInt8,
     SInt16,
     SInt32,
     SInt64,
     Character,
     String,
     // One subtype
     Message,
     Array,
     Slice,
     Input,
     Output,
     // A user-defined type with any number of subtypes
     Instance(DefinitionId, usize)
+}
 impl InferenceTypePart {
     fn is_marker(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::MarkerDefinition(_) | ITP::MarkerBody(_) => true,
             _ => false,
+        }
+    }
     /// Checks if the type is concrete, markers are interpreted as concrete
     /// types.
     fn is_concrete(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::Unknown | ITP::NumberLike | ITP::IntegerLike |
             ITP::ArrayLike | ITP::PortLike => false,
             _ => true
+        }
+    }
     fn is_concrete_number(&self) -> bool {
         // TODO: @float
         use InferenceTypePart as ITP;
         match self {
             ITP::UInt8 | ITP::UInt16 | ITP::UInt32 | ITP::UInt64 |
             ITP::SInt8 | ITP::SInt16 | ITP::SInt32 | ITP::SInt64 => true,
             _ => false,
+        }
+    }
     fn is_concrete_integer(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {ITP::UInt8 | ITP::UInt16 | ITP::UInt32 | ITP::UInt64 |
         ITP::SInt8 | ITP::SInt16 | ITP::SInt32 | ITP::SInt64 => true,
             _ => false,
+        }
+    }
     fn is_concrete_msg_array_or_slice(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::Array | ITP::Slice | ITP::Message => true,
             _ => false,
+        }
+    }
     fn is_concrete_port(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::Input | ITP::Output => true,
             _ => false,
+        }
+    }
     /// Checks if a part is less specific than the argument. Only checks for
     /// single-part inference (i.e. not the replacement of an `Unknown` variant
     /// with the argument)
     fn may_be_inferred_from(&self, arg: &InferenceTypePart) -> bool {
         use InferenceTypePart as ITP;
         (*self == ITP::IntegerLike && arg.is_concrete_integer()) ||
         (*self == ITP::NumberLike && (arg.is_concrete_number() || *arg == ITP::IntegerLike)) ||
         (*self == ITP::ArrayLike && arg.is_concrete_msg_array_or_slice()) ||
         (*self == ITP::PortLike && arg.is_concrete_port())
+    }
     /// Returns the change in "iteration depth" when traversing this particular
     /// part. The iteration depth is used to traverse the tree in a linear
     /// fashion. It is basically `number_of_subtypes - 1`
     fn depth_change(&self) -> i32 {
         use InferenceTypePart as ITP;
         match &self {
             ITP::Unknown | ITP::NumberLike | ITP::IntegerLike |
             ITP::Void | ITP::Bool |
             ITP::UInt8 | ITP::UInt16 | ITP::UInt32 | ITP::UInt64 |
             ITP::SInt8 | ITP::SInt16 | ITP::SInt32 | ITP::SInt64 |
             ITP::Character | ITP::String => {
                 -1
             },
             ITP::MarkerDefinition(_) | ITP::MarkerBody(_) |
             ITP::ArrayLike | ITP::Message | ITP::Array | ITP::Slice |
             ITP::PortLike | ITP::Input | ITP::Output => {
                 // One subtype, so do not modify depth
             },
             ITP::Instance(_, num_args) => {
                 (*num_args as i32) - 1
+            }
+        }
+    }
+}
 impl From<ConcreteTypePart> for InferenceTypePart {
     fn from(v: ConcreteTypePart) -> InferenceTypePart {
         use ConcreteTypePart as CTP;
         use InferenceTypePart as ITP;
         match v {
             CTP::Marker(_) => {
                 unreachable!("encountered marker while converting concrete type to inferred type");
+            }
             CTP::Void => ITP::Void,
             CTP::Message => ITP::Message,
             CTP::Bool => ITP::Bool,
             CTP::UInt8 => ITP::UInt8,
             CTP::UInt16 => ITP::UInt16,
             CTP::UInt32 => ITP::UInt32,
             CTP::UInt64 => ITP::UInt64,
             CTP::SInt8 => ITP::SInt8,
             CTP::SInt16 => ITP::SInt16,
             CTP::SInt32 => ITP::SInt32,
             CTP::SInt64 => ITP::SInt64,
             CTP::Character => ITP::Character,
             CTP::String => ITP::String,
             CTP::Array => ITP::Array,
             CTP::Slice => ITP::Slice,
             CTP::Input => ITP::Input,
             CTP::Output => ITP::Output,
             CTP::Instance(id, num) => ITP::Instance(id, num),
+        }
+    }
+}
 #[derive(Debug)]
 struct InferenceType {
     has_body_marker: bool,
     is_done: bool,
     parts: Vec<InferenceTypePart>,
+}
 impl InferenceType {
     /// Generates a new InferenceType. The two boolean flags will be checked in
     /// debug mode.
     fn new(has_body_marker: bool, is_done: bool, parts: Vec<InferenceTypePart>) -> Self {
         if cfg!(debug_assertions) {
             debug_assert!(!parts.is_empty());
             let parts_body_marker = parts.iter().any(|v| {
                 if let InferenceTypePart::MarkerBody(_) = v { true } else { false }
             });
             debug_assert_eq!(has_body_marker, parts_body_marker);
             let parts_done = parts.iter().all(|v| v.is_concrete());
             debug_assert_eq!(is_done, parts_done, "{:?}", parts);
+        }
         Self{ has_body_marker, is_done, parts }
+    }
     /// Replaces a type subtree with the provided subtree. The caller must make
     /// sure the the replacement is a well formed type subtree.
     fn replace_subtree(&mut self, start_idx: usize, with: &[InferenceTypePart]) {
         let end_idx = Self::find_subtree_end_idx(&self.parts, start_idx);
         debug_assert_eq!(with.len(), Self::find_subtree_end_idx(with, 0));
         self.parts.splice(start_idx..end_idx, with.iter().cloned());
         self.recompute_is_done();
+    }
     // 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. Make sure to copy definition markers, but not to
             // transfer polymorph markers.
             let template_end_idx = Self::find_subtree_end_idx(template_parts, *template_idx);
             let template_start_idx = if let Some(marker) = template_definition_marker {
                 to_infer.parts[*to_infer_idx] = ITP::MarkerDefinition(marker);
                 *template_idx
             } else {
                 to_infer.parts[*to_infer_idx] = template_parts[*template_idx].clone();
                 *template_idx + 1
             };
             *to_infer_idx += 1;
             for template_idx in template_start_idx..template_end_idx {
                 let template_part = &template_parts[template_idx];
                 if let ITP::MarkerBody(_) = template_part {
                     // Do not copy this one
                 } else {
                     to_infer.parts.insert(*to_infer_idx, template_part.clone());
                     *to_infer_idx += 1;
+                }
+            }
             *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::UInt8 => CTP::UInt8,
                 ITP::UInt16 => CTP::UInt16,
                 ITP::UInt32 => CTP::UInt32,
                 ITP::UInt64 => CTP::UInt64,
                 ITP::SInt8 => CTP::SInt8,
                 ITP::SInt16 => CTP::SInt16,
                 ITP::SInt32 => CTP::SInt32,
                 ITP::SInt64 => CTP::SInt64,
                 ITP::Character => CTP::Character,
                 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. This is used
     /// to display error messages
     fn write_display_name(
         buffer: &mut String, heap: &Heap, parts: &[InferenceTypePart], mut idx: usize
     ) -> usize {
         use InferenceTypePart as ITP;
         match &parts[idx] {
             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("numberlike"),
             ITP::IntegerLike => buffer.push_str("integerlike"),
             ITP::ArrayLike => {
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push_str("[?]");
             },
             ITP::PortLike => {
                 buffer.push_str("portlike<");
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
+            }
             ITP::Void => buffer.push_str("void"),
             ITP::Bool => buffer.push_str(KW_TYPE_BOOL_STR),
             ITP::UInt8 => buffer.push_str(KW_TYPE_UINT8_STR),
             ITP::UInt16 => buffer.push_str(KW_TYPE_UINT16_STR),
             ITP::UInt32 => buffer.push_str(KW_TYPE_UINT32_STR),
             ITP::UInt64 => buffer.push_str(KW_TYPE_UINT64_STR),
             ITP::SInt8 => buffer.push_str(KW_TYPE_SINT8_STR),
             ITP::SInt16 => buffer.push_str(KW_TYPE_SINT16_STR),
             ITP::SInt32 => buffer.push_str(KW_TYPE_SINT32_STR),
             ITP::SInt64 => buffer.push_str(KW_TYPE_SINT64_STR),
             ITP::Character => buffer.push_str(KW_TYPE_CHAR_STR),
             ITP::String => buffer.push_str(KW_TYPE_STRING_STR),
             ITP::Message => {
                 buffer.push_str(KW_TYPE_MESSAGE_STR);
                 buffer.push('<');
                 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(KW_TYPE_IN_PORT_STR);
                 buffer.push('<');
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
             },
             ITP::Output => {
                 buffer.push_str(KW_TYPE_OUT_PORT_STR);
                 buffer.push('<');
                 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(definition.identifier().value.as_str());
                 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{
     Component(ComponentDefinitionId),
     Function(FunctionDefinitionId),
+}
 impl DefinitionType {
     fn definition_id(&self) -> DefinitionId {
         match self {
             DefinitionType::Component(v) => v.upcast(),
             DefinitionType::Function(v) => v.upcast(),
+        }
+    }
+}
 #[derive(PartialEq, Eq)]
 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 PassTyping {
     // 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 PassTyping {
     pub(crate) fn new() -> Self {
         PassTyping {
             definition_type: DefinitionType::Function(FunctionDefinitionId::new_invalid()),
             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) {
         debug_assert_eq!(ctx.module.phase, ModuleCompilationPhase::ValidatedAndLinked);
         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(_) | Definition::Union(_) => {},
+            }
+        }
+    }
     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::Function(FunctionDefinitionId::new_invalid());
         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 PassTyping {
     // Definitions
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> 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 '{}': {}", comp_def.identifier.value.as_str(), 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_elements(&param.parser_type.elements, 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_block_stmt(ctx, body_stmt_id)
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionDefinitionId) -> 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 '{}': {}", func_def.identifier.value.as_str(), 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_elements(&param.parser_type.elements, 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_block_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_elements(&local.parser_type.elements, 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_elements(&from_local.parser_type.elements, 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_elements(&to_local.parser_type.elements, 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_block_stmt(ctx, true_body_id)?;
         if let Some(false_body_id) = false_body_id {
             self.visit_block_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;
         self.visit_expr(ctx, test_expr_id)?;
         self.visit_block_stmt(ctx, body_id)?;
         Ok(())
+    }
     fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {
         let sync_stmt = &ctx.heap[id];
         let body_id = sync_stmt.body;
         self.visit_block_stmt(ctx, body_id)
+    }
     fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {
         let return_stmt = &ctx.heap[id];
         debug_assert_eq!(return_stmt.expressions.len(), 1);
         let expr_id = return_stmt.expressions[0];
         self.visit_expr(ctx, expr_id)
+    }
     fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {
         let new_stmt = &ctx.heap[id];
         let call_expr_id = new_stmt.expression;
         self.visit_call_expr(ctx, call_expr_id)
+    }
     fn visit_expr_stmt(&mut self, ctx: &mut Ctx, id: ExpressionStatementId) -> VisitorResult {
         let expr_stmt = &ctx.heap[id];
         let subexpr_id = expr_stmt.expression;
         self.visit_expr(ctx, subexpr_id)
+    }
     // Expressions
     fn visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let assign_expr = &ctx.heap[id];
         let left_expr_id = assign_expr.left;
         let right_expr_id = assign_expr.right;
         self.visit_expr(ctx, left_expr_id)?;
         self.visit_expr(ctx, right_expr_id)?;
         self.progress_assignment_expr(ctx, id)
+    }
     fn visit_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let conditional_expr = &ctx.heap[id];
         let test_expr_id = conditional_expr.test;
         let true_expr_id = conditional_expr.true_expression;
         let false_expr_id = conditional_expr.false_expression;
         self.expr_types.insert(test_expr_id, InferenceType::new(false, true, vec![InferenceTypePart::Bool]));
         self.visit_expr(ctx, test_expr_id)?;
         self.visit_expr(ctx, true_expr_id)?;
         self.visit_expr(ctx, false_expr_id)?;
         self.progress_conditional_expr(ctx, id)
+    }
     fn visit_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let binary_expr = &ctx.heap[id];
         let lhs_expr_id = binary_expr.left;
         let rhs_expr_id = binary_expr.right;
         self.visit_expr(ctx, lhs_expr_id)?;
         self.visit_expr(ctx, rhs_expr_id)?;
         self.progress_binary_expr(ctx, id)
+    }
     fn visit_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let unary_expr = &ctx.heap[id];
         let arg_expr_id = unary_expr.expression;
         self.visit_expr(ctx, arg_expr_id)?;
         self.progress_unary_expr(ctx, id)
+    }
     fn visit_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let indexing_expr = &ctx.heap[id];
         let subject_expr_id = indexing_expr.subject;
         let index_expr_id = indexing_expr.index;
         self.visit_expr(ctx, subject_expr_id)?;
         self.visit_expr(ctx, index_expr_id)?;
         self.progress_indexing_expr(ctx, id)
+    }
     fn visit_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let slicing_expr = &ctx.heap[id];
         let subject_expr_id = slicing_expr.subject;
         let from_expr_id = slicing_expr.from_index;
         let to_expr_id = slicing_expr.to_index;
         self.visit_expr(ctx, subject_expr_id)?;
         self.visit_expr(ctx, from_expr_id)?;
         self.visit_expr(ctx, to_expr_id)?;
         self.progress_slicing_expr(ctx, id)
+    }
     fn visit_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let select_expr = &ctx.heap[id];
         let subject_expr_id = select_expr.subject;
         self.visit_expr(ctx, subject_expr_id)?;
         self.progress_select_expr(ctx, id)
+    }
     fn visit_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let literal_expr = &ctx.heap[id];
         match &literal_expr.value {
             Literal::Null | Literal::False | Literal::True |
             Literal::Integer(_) | Literal::Character(_) | Literal::String(_) => {
                 // No subexpressions
             },
             Literal::Struct(literal) => {
                 // TODO: @performance
                 let expr_ids: Vec<_> = literal.fields
                     .iter()
                     .map(|f| f.value)
                     .collect();
                 self.insert_initial_struct_polymorph_data(ctx, id);
                 for expr_id in expr_ids {
                     self.visit_expr(ctx, expr_id)?;
+                }
             },
             Literal::Enum(_) => {
                 // Enumerations do not carry any subexpressions, but may still
                 // have a user-defined polymorphic marker variable. For this
                 // reason we may still have to apply inference to this
                 // polymorphic variable
                 self.insert_initial_enum_polymorph_data(ctx, id);
             },
             Literal::Union(literal) => {
                 // May carry subexpressions and polymorphic arguments
                 // TODO: @performance
                 let expr_ids = literal.values.clone();
                 self.insert_initial_union_polymorph_data(ctx, id);
                 for expr_id in expr_ids {
                     self.visit_expr(ctx, expr_id)?;
+                }
             },
             Literal::Array(expressions) => {
                 // TODO: @performance
                 let expr_ids = expressions.clone();
                 for expr_id in expr_ids {
                     self.visit_expr(ctx, expr_id)?;
+                }
+            }
+        }
         self.progress_literal_expr(ctx, id)
+    }
     fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         self.insert_initial_call_polymorph_data(ctx, id);
         // TODO: @performance
         let call_expr = &ctx.heap[id];
         for arg_expr_id in call_expr.arguments.clone() {
             self.visit_expr(ctx, arg_expr_id)?;
+        }
         self.progress_call_expr(ctx, id)
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let var_expr = &ctx.heap[id];
         debug_assert!(var_expr.declaration.is_some());
         let var_data = self.var_types.get_mut(var_expr.declaration.as_ref().unwrap()).unwrap();
         var_data.used_at.push(upcast_id);
         self.progress_variable_expr(ctx, id)
+    }
+}
 macro_rules! debug_assert_expr_ids_unique_and_known {
     // Base case for a single expression ID
     ($resolver:ident, $id:ident) => {
         if cfg!(debug_assertions) {
             $resolver.expr_types.contains_key(&$id);
+        }
     };
     // Base case for two expression IDs
     ($resolver:ident, $id1:ident, $id2:ident) => {
         debug_assert_ne!($id1, $id2);
         debug_assert_expr_ids_unique_and_known!($resolver, $id1);
         debug_assert_expr_ids_unique_and_known!($resolver, $id2);
     };
     // Generic case
     ($resolver:ident, $id1:ident, $id2:ident, $($tail:ident),+) => {
         debug_assert_ne!($id1, $id2);
         debug_assert_expr_ids_unique_and_known!($resolver, $id1);
         debug_assert_expr_ids_unique_and_known!($resolver, $id2, $($tail),+);
     };
+}
 macro_rules! debug_assert_ptrs_distinct {
     // Base case
     ($ptr1:ident, $ptr2:ident) => {
         debug_assert!(!std::ptr::eq($ptr1, $ptr2));
     };
     // Generic case
     ($ptr1:ident, $ptr2:ident, $($tail:ident),+) => {
         debug_assert_ptrs_distinct!($ptr1, $ptr2);
         debug_assert_ptrs_distinct!($ptr2, $($tail),+);
     };
+}
 impl PassTyping {
     fn resolve_types(&mut self, ctx: &mut Ctx, queue: &mut ResolveQueue) -> Result<(), ParseError> {
         // Keep inferring until we can no longer make any progress
         while let Some(next_expr_id) = self.expr_queued.iter().next() {
             let next_expr_id = *next_expr_id;
             self.expr_queued.remove(&next_expr_id);
             self.progress_expr(ctx, next_expr_id)?;
+        }
         // We check if we have all the types we need. If we're typechecking a
         // polymorphic procedure more than once, then we have already annotated
         // the AST and have now performed typechecking for a different
         // monomorph. In that case we just need to perform typechecking, no need
         // to annotate the AST again.
         let definition_id = match &self.definition_type {
             DefinitionType::Component(id) => id.upcast(),
             DefinitionType::Function(id) => id.upcast(),
         };
         let already_checked = ctx.types.get_base_definition(&definition_id).unwrap().has_any_monomorph();
         for (expr_id, expr_type) in self.expr_types.iter_mut() {
             if !expr_type.is_done {
                 // Auto-infer numberlike/integerlike types to a regular int
                 if expr_type.parts.len() == 1 && expr_type.parts[0] == InferenceTypePart::IntegerLike {
                     expr_type.parts[0] = InferenceTypePart::SInt32;
                 } else {
                     let expr = &ctx.heap[*expr_id];
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, expr.span(), format!(
                             "could not fully infer the type of this expression (got '{}')",
                             expr_type.display_name(&ctx.heap)
+                        )
                     ));
+                }
+            }
             if !already_checked {
                 let concrete_type = ctx.heap[*expr_id].get_type_mut();
                 expr_type.write_concrete_type(concrete_type);
             } else {
                 if cfg!(debug_assertions) {
                     let mut concrete_type = ConcreteType::default();
                     expr_type.write_concrete_type(&mut concrete_type);
                     debug_assert_eq!(*ctx.heap[*expr_id].get_type(), concrete_type);
+                }
+            }
+        }
         // All types are fine
         ctx.types.add_monomorph(&definition_id, self.poly_vars.clone());
         // Check all things we need to monomorphize
         // TODO: Struct/enum/union monomorphization
         for (expr_id, extra_data) in self.extra_data.iter() {
             if extra_data.poly_vars.is_empty() { continue; }
             // Retrieve polymorph variable specification. Those of struct
             // literals and those of procedure calls need to be fully inferred.
             // The remaining ones (e.g. select expressions) allow partial
             // inference of types, as long as the accessed field's type is
             // fully inferred.
             let needs_full_inference = match &ctx.heap[*expr_id] {
                 Expression::Call(_) => true,
                 Expression::Literal(_) => true,
                 _ => false
             };
             if needs_full_inference {
                 let mut monomorph_types = Vec::with_capacity(extra_data.poly_vars.len());
                 for (poly_idx, poly_type) in extra_data.poly_vars.iter().enumerate() {
                     if !poly_type.is_done {
                         // TODO: Single clean function for function signatures and polyvars.
                         // TODO: Better error message
                         let expr = &ctx.heap[*expr_id];
                         return Err(ParseError::new_error_at_span(
                             &ctx.module.source, expr.span(), format!(
                                 "could not fully infer the type of polymorphic variable {} of this expression (got '{}')",
                                 poly_idx, poly_type.display_name(&ctx.heap)
+                            )
                         ))
+                    }
                     let mut concrete_type = ConcreteType::default();
                     poly_type.write_concrete_type(&mut concrete_type);
                     monomorph_types.insert(poly_idx, concrete_type);
+                }
                 // Resolve to the appropriate expression and instantiate
                 // monomorphs.
                 match &ctx.heap[*expr_id] {
                     Expression::Call(call_expr) => {
                         // Add to type table if not yet typechecked
                         if call_expr.method == Method::UserFunction {
                             let definition_id = call_expr.definition;
                             if !ctx.types.has_monomorph(&definition_id, &monomorph_types) {
                                 let root_id = ctx.types
                                     .get_base_definition(&definition_id)
                                     .unwrap()
                                     .ast_root;
                                 // Pre-emptively add the monomorph to the type table, but
                                 // we still need to perform typechecking on it
                                 // TODO: Unsure about this, performance wise
                                 let queue_element = ResolveQueueElement{
                                     root_id,
                                     definition_id,
                                     monomorph_types,
                                 };
                                 if !queue.contains(&queue_element) {
                                     queue.push(queue_element);
+                                }
+                            }
+                        }
                     },
                     Expression::Literal(lit_expr) => {
                         let definition_id = match &lit_expr.value {
                             Literal::Struct(literal) => &literal.definition,
                             Literal::Enum(literal) => &literal.definition,
                             Literal::Union(literal) => &literal.definition,
                             _ => unreachable!("post-inference monomorph for non-struct, non-enum literal")
                         };
                         if !ctx.types.has_monomorph(definition_id, &monomorph_types) {
                             ctx.types.add_monomorph(definition_id, monomorph_types);
+                        }
                     },
                     _ => unreachable!("needs fully inference, but not a struct literal or call expression")
+                }
             } // else: was just a helper structure...
+        }
         Ok(())
+    }
     fn progress_expr(&mut self, ctx: &mut Ctx, id: ExpressionId) -> Result<(), ParseError> {
         match &ctx.heap[id] {
             Expression::Assignment(expr) => {
                 let id = expr.this;
                 self.progress_assignment_expr(ctx, id)
             },
             Expression::Binding(_expr) => {
                 unimplemented!("progress binding expression");
             },
             Expression::Conditional(expr) => {
                 let id = expr.this;
                 self.progress_conditional_expr(ctx, id)
             },
             Expression::Binary(expr) => {
                 let id = expr.this;
                 self.progress_binary_expr(ctx, id)
             },
             Expression::Unary(expr) => {
                 let id = expr.this;
                 self.progress_unary_expr(ctx, id)
             },
             Expression::Indexing(expr) => {
                 let id = expr.this;
                 self.progress_indexing_expr(ctx, id)
             },
             Expression::Slicing(expr) => {
                 let id = expr.this;
                 self.progress_slicing_expr(ctx, id)
             },
             Expression::Select(expr) => {
                 let id = expr.this;
                 self.progress_select_expr(ctx, id)
             },
             Expression::Literal(expr) => {
                 let id = expr.this;
                 self.progress_literal_expr(ctx, id)
             },
             Expression::Call(expr) => {
                 let id = expr.this;
                 self.progress_call_expr(ctx, id)
             },
             Expression::Variable(expr) => {
                 let id = expr.this;
                 self.progress_variable_expr(ctx, id)
+            }
+        }
+    }
     fn progress_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> Result<(), ParseError> {
         use AssignmentOperator as AO;
         // TODO: Assignable check
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_expr_id = expr.left;
         let arg2_expr_id = expr.right;
         debug_log!("Assignment expr '{:?}': {}", expr.operation, 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_base = match expr.operation {
             AO::Set =>
                 false,
             AO::Multiplied | AO::Divided | AO::Added | AO::Subtracted =>
                 self.apply_forced_constraint(ctx, upcast_id, &NUMBERLIKE_TEMPLATE)?,
             AO::Remained | AO::ShiftedLeft | AO::ShiftedRight |
             AO::BitwiseAnded | AO::BitwiseXored | AO::BitwiseOred =>
                 self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?,
         };
         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_base || progress_expr, self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         if progress_base || 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_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> Result<(), ParseError> {
         // 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<(), ParseError> {
         // 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<(), ParseError> {
         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<(), ParseError> {
         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<(), ParseError> {
         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<(), ParseError> {
         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(ParseError::new_error_at_span(
                                     &ctx.module.source, field.identifier.span, 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_span = field.identifier.span;
                                 let ast_struct_def = ctx.heap[type_def.ast_definition].as_struct();
                                 return Err(ParseError::new_error_at_span(
                                     &ctx.module.source, field_span, format!(
                                         "this field does not exist on the struct '{}'",
                                         ast_struct_def.identifier.value.as_str()
+                                    )
                                 ))
+                            }
                             // 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(ParseError::new_error_at_span(
                                 &ctx.module.source, field.identifier.span, 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(&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(&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_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> Result<(), ParseError> {
         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(_) => {
                 self.apply_forced_constraint(ctx, upcast_id, &CHARACTER_TEMPLATE)?;
                 todo!("check character literal type inference");
             },
             Literal::String(_) => {
                 self.apply_forced_constraint(ctx, upcast_id, &STRING_TEMPLATE)?;
                 todo!("check string literal type inference");
             },
             Literal::Struct(data) => {
                 let extra = self.extra_data.get_mut(&upcast_id).unwrap();
                 for poly in &extra.poly_vars {
                     debug_log!(" * Poly: {}", poly.display_name(&ctx.heap));
+                }
                 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);
+                    }
+                }
                 debug_log!("   - Field poly progress | {:?}", poly_progress);
                 // 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)
                 );
                 debug_log!("   - Ret poly progress | {:?}", poly_progress);
                 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(&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(
                     &ctx.heap, extra, &poly_progress, signature_type, expr_type
                 );
                 progress_expr
             },
             Literal::Enum(_) => {
                 let extra = self.extra_data.get_mut(&upcast_id).unwrap();
                 for poly in &extra.poly_vars {
                     debug_log!(" * Poly: {}", poly.display_name(&ctx.heap));
+                }
                 let mut poly_progress = HashSet::new();
                 debug_log!(" * During (inferring types from 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
                     if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {
                         self.expr_queued.insert(parent_id);
+                    }
+                }
                 debug_log!(" * During (reinferring from progress polyvars):");
                 let progress_expr = Self::apply_equal2_polyvar_constraint(
                     &ctx.heap, extra, &poly_progress, signature_type, expr_type
                 );
                 progress_expr
             },
             Literal::Union(data) => {
                 let extra = self.extra_data.get_mut(&upcast_id).unwrap();
                 for poly in &extra.poly_vars {
                     debug_log!(" * Poly: {}", poly.display_name(&ctx.heap));
+                }
                 let mut poly_progress = HashSet::new();
                 debug_assert_eq!(extra.embedded.len(), data.values.len());
                 debug_log!(" * During (inferring types from variant values and union type):");
                 // Mutually infer union variant values
                 for (value_idx, value_expr_id) in data.values.iter().enumerate() {
                     let value_expr_id = *value_expr_id;
                     let signature_type: *mut _ = &mut extra.embedded[value_idx];
                     let value_type: *mut _ = self.expr_types.get_mut(&value_expr_id).unwrap();
                     let (_, progress_arg) = Self::apply_equal2_signature_constraint(
                         ctx, upcast_id, Some(value_expr_id), extra, &mut poly_progress,
                         signature_type, 0, value_type, 0
                     )?;
                     debug_log!(
                         "   - Value {} type | sig: {}, field: {}", value_idx,
                         unsafe{&*signature_type}.display_name(&ctx.heap),
                         unsafe{&*value_type}.display_name(&ctx.heap)
                     );
                     if progress_arg {
                         self.expr_queued.insert(value_expr_id);
+                    }
+                }
                 debug_log!("   - Field poly progress | {:?}", poly_progress);
                 // Infer type of union 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)
                 );
                 debug_log!("   - Ret poly progress | {:?}", poly_progress);
                 if progress_expr {
                     // TODO: @cleanup, borrowing rules
                     if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {
                         self.expr_queued.insert(parent_id);
+                    }
+                }
                 debug_log!(" * During (reinferring from progress polyvars):");
                 // For all embedded values of the union variant
                 for value_idx in 0..extra.embedded.len() {
                     let signature_type: *mut _ = &mut extra.embedded[value_idx];
                     let value_expr_id = data.values[value_idx];
                     let value_type: *mut _ = self.expr_types.get_mut(&value_expr_id).unwrap();
                     let progress_arg = Self::apply_equal2_polyvar_constraint(
                         &ctx.heap, extra, &poly_progress, signature_type, value_type
                     );
                     debug_log!(
                         "   - Value {} type | sig: {}, value: {}", value_idx,
                         unsafe{&*signature_type}.display_name(&ctx.heap),
                         unsafe{&*value_type}.display_name(&ctx.heap)
                     );
                     if progress_arg {
                         self.expr_queued.insert(value_expr_id);
+                    }
+                }
                 // And for the union type 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_polyvar_constraint(
                     &ctx.heap, extra, &poly_progress, signature_type, expr_type
                 );
                 progress_expr
             },
             Literal::Array(data) => {
                 let expr_elements = data.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 progress_expr = 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
                     )?;
                     progress_expr = progress_expr || 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 [{}]: {}", progress_expr, self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
                 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<(), ParseError> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let extra = self.extra_data.get_mut(&upcast_id).unwrap();
         debug_log!("Call expr '{}': {}", ctx.heap[expr.definition].identifier().value.as_str(), 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(&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(&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<(), ParseError> {
         let upcast_id = id.upcast();
         let var_expr = &ctx.heap[id];
         let var_id = var_expr.declaration.unwrap();
         debug_log!("Variable expr '{}': {}", ctx.heap[var_id].identifier().value.as_str(), 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(ParseError::new_error_at_span(
                 &ctx.module.source, var_decl.identifier().span, format!(
                     "Conflicting types for this variable, previously assigned the type '{}'",
                     var_data.var_type.display_name(&ctx.heap)
+                )
             ).with_info_at_span(
                 &ctx.module.source, var_expr.identifier.span, 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(ParseError::new_error_at_span(
                             &ctx.module.source, var_decl.identifier().span, format!(
                                 "Conflicting types for this variable, assigned the type '{}'",
                                 var_data.var_type.display_name(&ctx.heap)
+                            )
                         ).with_info_at_span(
                             &ctx.module.source, link_decl.identifier().span, 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, ParseError> {
         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), ParseError> {
         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), ParseError> {
         // 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_span = ctx.heap[outer_expr_id].span();
             let (span_name, span) = match expr_id {
                 Some(expr_id) => ("argument's", ctx.heap[expr_id].span()),
                 None => ("type's", outer_span)
             };
             let (signature_display_type, expression_display_type) = unsafe { (
                 (&*signature_type).display_name(&ctx.heap),
                 (&*expression_type).display_name(&ctx.heap)
             ) };
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, outer_span,
                 "failed to fully resolve the types of this expression"
             ).with_info_at_span(
                 &ctx.module.source, span, format!(
                     "because the {} signature has been resolved to '{}', but the expression has been resolved to '{}'",
                     span_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), ParseError> {
         // 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>, ParseError> {
         // 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<(), ParseError> {
         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(_) =>
                 // 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 {
                     debug_assert_eq!(ctx.heap[func_id].return_types.len(), 1);
                     let returned = &ctx.heap[func_id].return_types[0];
                     self.determine_inference_type_from_parser_type_elements(&returned.elements, 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
     ) {
         // 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 arguments (if there are any)
         let num_poly_args = call.parser_type.elements[0].variant.num_embedded();
         let mut poly_args = Vec::with_capacity(num_poly_args);
         for embedded_elements in call.parser_type.iter_embedded(0) {
             poly_args.push(self.determine_inference_type_from_parser_type_elements(embedded_elements, true));
+        }
         // Handle the arguments and return types
         let definition = &ctx.heap[call.definition];
         let (parameters, returned) = match definition {
             Definition::Component(definition) => {
                 debug_assert_eq!(poly_args.len(), definition.poly_vars.len());
                 (&definition.parameters, None)
             },
             Definition::Function(definition) => {
                 debug_assert_eq!(poly_args.len(), definition.poly_vars.len());
                 (&definition.parameters, Some(&definition.return_types))
             },
             Definition::Struct(_) | Definition::Enum(_) | Definition::Union(_) => {
                 unreachable!("insert_initial_call_polymorph data for non-procedure type");
             },
         };
         let mut parameter_types = Vec::with_capacity(parameters.len());
         for parameter_id in parameters.clone().into_iter() { // TODO: @Performance
             let param = &ctx.heap[parameter_id];
             parameter_types.push(self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, false));
+        }
         let return_type = match returned {
             None => {
                 // Component, so returns a "Void"
                 InferenceType::new(false, true, vec![InferenceTypePart::Void])
             },
             Some(returned) => {
                 debug_assert_eq!(returned.len(), 1);
                 let returned = &returned[0];
                 self.determine_inference_type_from_parser_type_elements(&returned.elements, false)
+            }
         };
         self.extra_data.insert(call_id.upcast(), ExtraData {
             poly_vars: poly_args,
             embedded: parameter_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 num_embedded = literal.parser_type.elements[0].variant.num_embedded();
         let mut total_num_poly_parts = 0;
         let mut poly_args = Vec::with_capacity(num_embedded);
         for embedded_elements in literal.parser_type.iter_embedded(0) {
             let poly_type = self.determine_inference_type_from_parser_type_elements(embedded_elements, true);
             total_num_poly_parts += poly_type.parts.len();
             poly_args.push(poly_type);
+        }
         // Handle parser types on struct definition
         let defined_type = ctx.types.get_base_definition(&literal.definition).unwrap();
         let struct_type = defined_type.definition.as_struct();
         debug_assert_eq!(poly_args.len(), defined_type.poly_vars.len());
         // Note: programmer is capable of specifying fields in a struct literal
         // in a different order than on the definition. We take the literal-
         // specified order to be leading.
         let mut embedded_types = Vec::with_capacity(struct_type.fields.len());
         for lit_field in literal.fields.iter() {
             let def_field = &struct_type.fields[lit_field.field_idx];
             let inference_type = self.determine_inference_type_from_parser_type_elements(&def_field.parser_type.elements, 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_args.len() + total_num_poly_parts;
         let mut parts = Vec::with_capacity(parts_reserved);
         parts.push(ITP::Instance(literal.definition, poly_args.len()));
         let mut return_type_done = true;
         for (poly_var_idx, poly_var) in poly_args.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(!poly_args.is_empty(), return_type_done, parts);
         self.extra_data.insert(lit_id.upcast(), ExtraData{
             poly_vars: poly_args,
             embedded: embedded_types,
             returned: return_type,
         });
+    }
     /// Inserts the extra polymorphic data struct for enum expressions. These
     /// can never be determined from the enum itself, but may be inferred from
     /// the use of the enum.
     fn insert_initial_enum_polymorph_data(
         &mut self, ctx: &Ctx, lit_id: LiteralExpressionId
     ) {
         use InferenceTypePart as ITP;
         let literal = ctx.heap[lit_id].value.as_enum();
         // Handle polymorphic arguments to the enum
         let num_poly_args = literal.parser_type.elements[0].variant.num_embedded();
         let mut total_num_poly_parts = 0;
         let mut poly_args = Vec::with_capacity(num_poly_args);
         for embedded_elements in literal.parser_type.iter_embedded(0) {
             let poly_type = self.determine_inference_type_from_parser_type_elements(embedded_elements, true);
             total_num_poly_parts += poly_type.parts.len();
             poly_args.push(poly_type);
+        }
         // Handle enum type itself
         let parts_reserved = 1 + poly_args.len() + total_num_poly_parts;
         let mut parts = Vec::with_capacity(parts_reserved);
         parts.push(ITP::Instance(literal.definition, poly_args.len()));
         let mut enum_type_done = true;
         for (poly_var_idx, poly_var) in poly_args.iter().enumerate() {
             if !poly_var.is_done { enum_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 enum_type = InferenceType::new(!poly_args.is_empty(), enum_type_done, parts);
         self.extra_data.insert(lit_id.upcast(), ExtraData{
             poly_vars: poly_args,
             embedded: Vec::new(),
             returned: enum_type,
         });
+    }
     /// Inserts the extra polymorphic data struct for unions. The polymorphic
     /// arguments may be partially determined from embedded values in the union.
     fn insert_initial_union_polymorph_data(
         &mut self, ctx: &Ctx, lit_id: LiteralExpressionId
     ) {
         use InferenceTypePart as ITP;
         let literal = ctx.heap[lit_id].value.as_union();
         // Construct the polymorphic variables
         let num_poly_args = literal.parser_type.elements[0].variant.num_embedded();
         let mut total_num_poly_parts = 0;
         let mut poly_args = Vec::with_capacity(num_poly_args);
         for embedded_elements in literal.parser_type.iter_embedded(0) {
             let poly_type = self.determine_inference_type_from_parser_type_elements(embedded_elements, true);
             total_num_poly_parts += poly_type.parts.len();
             poly_args.push(poly_type);
+        }
         // Handle any of the embedded values in the variant, if specified
         let definition_id = literal.definition;
         let type_definition = ctx.types.get_base_definition(&definition_id).unwrap();
         let union_definition = type_definition.definition.as_union();
         debug_assert_eq!(poly_args.len(), type_definition.poly_vars.len());
         let variant_definition = &union_definition.variants[literal.variant_idx];
         debug_assert_eq!(variant_definition.embedded.len(), literal.values.len());
         let mut embedded = Vec::with_capacity(variant_definition.embedded.len());
         for embedded_parser_type in &variant_definition.embedded {
             let inference_type = self.determine_inference_type_from_parser_type_elements(&embedded_parser_type.elements, false);
             embedded.push(inference_type);
+        }
         // Handle the type of the union itself
         let parts_reserved = 1 + poly_args.len() + total_num_poly_parts;
         let mut parts = Vec::with_capacity(parts_reserved);
         parts.push(ITP::Instance(definition_id, poly_args.len()));
         let mut union_type_done = true;
         for (poly_var_idx, poly_var) in poly_args.iter().enumerate() {
             if !poly_var.is_done { union_type_done = false; }
             parts.push(ITP::MarkerBody(poly_var_idx));
             parts.extend(poly_var.parts.iter().cloned());
+        }
         debug_assert_eq!(parts_reserved, parts.len());
         let union_type = InferenceType::new(!poly_args.is_empty(), union_type_done, parts);
         self.extra_data.insert(lit_id.upcast(), ExtraData{
             poly_vars: poly_args,
             embedded,
             returned: union_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 = expr.field.as_symbolic();
         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
         // TODO: @Performance: we can immediately set the polyvars of the subject's 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![
                 ITP::MarkerBody(poly_idx), ITP::Unknown,
             ]));
             struct_parts.push(ITP::MarkerBody(poly_idx));
             struct_parts.push(ITP::Unknown);
+        }
         debug_assert_eq!(struct_parts.len(), struct_parts_reserved);
         // Generate initial field type
         let field_type = self.determine_inference_type_from_parser_type_elements(&definition.fields[field_idx].parser_type.elements, false);
         self.extra_data.insert(select_id.upcast(), ExtraData{
             poly_vars,
             embedded: vec![InferenceType::new(num_poly_vars != 0, num_poly_vars == 0, struct_parts)],
             returned: field_type
         });
+    }
     /// Determines the initial InferenceType from the provided ParserType. This
     /// may be called with two kinds of intentions:
     /// 1. To resolve a ParserType within the body of a function, or on
     ///     polymorphic arguments to calls/instantiations within that body. This
     ///     means that the polymorphic variables are known and can be replaced
     ///     with the monomorph we're instantiating.
     /// 2. To resolve a ParserType on a called function's definition or on
     ///     an instantiated datatype's members. This means that the polymorphic
     ///     arguments inside those ParserTypes refer to the polymorphic
     ///     variables in the called/instantiated type's definition.
     /// In the second case we place InferenceTypePart::Marker instances such
     /// that we can perform type inference on the polymorphic variables.
     fn determine_inference_type_from_parser_type_elements(
         &mut self, elements: &[ParserTypeElement],
         parser_type_in_body: bool
     ) -> InferenceType {
         use ParserTypeVariant as PTV;
         use InferenceTypePart as ITP;
         let mut infer_type = Vec::with_capacity(elements.len());
         let mut has_inferred = false;
         let mut has_markers = false;
         for element in elements {
             match &element.variant {
                 PTV::Message => {
                     // TODO: @types Remove the Message -> Byte hack at some point...
                     infer_type.push(ITP::Message);
                     infer_type.push(ITP::UInt8);
                 },
                 PTV::Bool => { infer_type.push(ITP::Bool); },
                 PTV::UInt8 => { infer_type.push(ITP::UInt8); },
                 PTV::UInt16 => { infer_type.push(ITP::UInt16); },
                 PTV::UInt32 => { infer_type.push(ITP::UInt32); },
                 PTV::UInt64 => { infer_type.push(ITP::UInt64); },
                 PTV::SInt8 => { infer_type.push(ITP::SInt8); },
                 PTV::SInt16 => { infer_type.push(ITP::SInt16); },
                 PTV::SInt32 => { infer_type.push(ITP::SInt32); },
                 PTV::SInt64 => { infer_type.push(ITP::SInt64); },
                 PTV::Character => { infer_type.push(ITP::Character); },
                 PTV::String => { infer_type.push(ITP::String); },
                 PTV::IntegerLiteral => { unreachable!("integer literal type on variable type"); },
                 PTV::Inferred => {
                     infer_type.push(ITP::Unknown);
                     has_inferred = true;
                 },
                 PTV::Array => { infer_type.push(ITP::Array); },
                 PTV::Input => { infer_type.push(ITP::Input); },
                 PTV::Output => { infer_type.push(ITP::Output); },
                 PTV::PolymorphicArgument(belongs_to_definition, poly_arg_idx) => {
                     let poly_arg_idx = *poly_arg_idx;
                     if parser_type_in_body {
                         // Refers to polymorphic argument on procedure we're currently processing.
                         // This argument is already known.
                         debug_assert_eq!(*belongs_to_definition, self.definition_type.definition_id());
                         debug_assert!((poly_arg_idx as usize) < self.poly_vars.len());
                         infer_type.push(ITP::MarkerDefinition(poly_arg_idx as usize));
                         for concrete_part in &self.poly_vars[poly_arg_idx].parts {
                             infer_type.push(ITP::from(*concrete_part));
+                        }
                     } else {
                         // Polymorphic argument has to be inferred
                         has_markers = true;
                         has_inferred = true;
                         infer_type.push(ITP::MarkerBody(poly_arg_idx));
                         infer_type.push(ITP::Unknown)
+                    }
                 },
                 PTV::Definition(definition_id, num_embedded) => {
                     infer_type.push(ITP::Instance(*definition_id, *num_embedded));
+                }
+            }
+        }
         InferenceType::new(has_markers, !has_inferred, infer_type)
+    }
     /// Construct an error when an expression's type does not match. This
     /// happens if we infer the expression type from its arguments (e.g. the
     /// expression type of an addition operator is the type of the arguments)
     /// But the expression type was already set due to our parent (e.g. an
     /// "if statement" or a "logical not" always expecting a boolean)
     fn construct_expr_type_error(
         &self, ctx: &Ctx, expr_id: ExpressionId, arg_id: ExpressionId
     ) -> ParseError {
         // TODO: Expand and provide more meaningful information for humans
         let expr = &ctx.heap[expr_id];
         let arg_expr = &ctx.heap[arg_id];
         let expr_type = self.expr_types.get(&expr_id).unwrap();
         let arg_type = self.expr_types.get(&arg_id).unwrap();
         return ParseError::new_error_at_span(
             &ctx.module.source, expr.span(), format!(
                 "incompatible types: this expression expected a '{}'",
                 expr_type.display_name(&ctx.heap)
+            )
         ).with_info_at_span(
             &ctx.module.source, arg_expr.span(), format!(
                 "but this expression yields a '{}'",
                 arg_type.display_name(&ctx.heap)
+            )
+        )
+    }
     fn construct_arg_type_error(
         &self, ctx: &Ctx, expr_id: ExpressionId,
         arg1_id: ExpressionId, arg2_id: ExpressionId
     ) -> ParseError {
         let expr = &ctx.heap[expr_id];
         let arg1 = &ctx.heap[arg1_id];
         let arg2 = &ctx.heap[arg2_id];
         let arg1_type = self.expr_types.get(&arg1_id).unwrap();
         let arg2_type = self.expr_types.get(&arg2_id).unwrap();
         return ParseError::new_error_str_at_span(
             &ctx.module.source, expr.span(),
             "incompatible types: cannot apply this expression"
         ).with_info_at_span(
             &ctx.module.source, arg1.span(), format!(
                 "Because this expression has type '{}'",
                 arg1_type.display_name(&ctx.heap)
+            )
         ).with_info_at_span(
             &ctx.module.source, arg2.span(), format!(
                 "But this expression has type '{}'",
                 arg2_type.display_name(&ctx.heap)
+            )
+        )
+    }
     fn construct_template_type_error(
         &self, ctx: &Ctx, expr_id: ExpressionId, template: &[InferenceTypePart]
     ) -> ParseError {
         let expr = &ctx.heap[expr_id];
         let expr_type = self.expr_types.get(&expr_id).unwrap();
         return ParseError::new_error_at_span(
             &ctx.module.source, expr.span(), format!(
                 "incompatible types: got a '{}' but expected a '{}'",
                 expr_type.display_name(&ctx.heap),
                 InferenceType::partial_display_name(&ctx.heap, template)
+            )
+        )
+    }
     /// Constructs a human interpretable error in the case that type inference
     /// on a polymorphic variable to a function call or literal construction
     /// failed. This may only be caused by a pair of inference types (which may
     /// come from arguments or the return type) having two different inferred
     /// values for that polymorphic variable.
     ///
     /// So we find this pair and construct the error using it.
     ///
     /// We assume that the expression is a function call or a struct literal,
     /// and that an actual error has occurred.
     fn construct_poly_arg_error(
         ctx: &Ctx, poly_data: &ExtraData, expr_id: ExpressionId
     ) -> ParseError {
         // Helper function to check for polymorph mismatch between two inference
         // types.
         fn has_poly_mismatch<'a>(type_a: &'a InferenceType, type_b: &'a InferenceType) -> Option<(usize, &'a [InferenceTypePart], &'a [InferenceTypePart])> {
             if !type_a.has_body_marker || !type_b.has_body_marker {
                 return None
+            }
             for (marker_a, section_a) in type_a.body_marker_iter() {
                 for (marker_b, section_b) in type_b.body_marker_iter() {
                     if marker_a != marker_b {
                         // Not the same polymorphic variable
                         continue;
+                    }
                     if !InferenceType::check_subtrees(section_a, 0, section_b, 0) {
                         // Not compatible
                         return Some((marker_a, section_a, section_b))
+                    }
+                }
+            }
             None
+        }
         // Helpers function to retrieve polyvar name and definition name
         fn get_poly_var_and_definition_name<'a>(ctx: &'a Ctx, poly_var_idx: usize, definition_id: DefinitionId) -> (&'a str, &'a str) {
             let definition = &ctx.heap[definition_id];
             let poly_var = definition.poly_vars()[poly_var_idx].value.as_str();
             let func_name = definition.identifier().value.as_str();
             (poly_var, func_name)
+        }
         // Helper function to construct initial error
         fn construct_main_error(ctx: &Ctx, poly_var_idx: usize, expr: &Expression) -> ParseError {
             match expr {
                 Expression::Call(expr) => {
                     let (poly_var, func_name) = get_poly_var_and_definition_name(ctx, poly_var_idx, expr.definition);
                     return ParseError::new_error_at_span(
                         &ctx.module.source, expr.span, format!(
                             "Conflicting type for polymorphic variable '{}' of '{}'",
                             poly_var, func_name
+                        )
+                    )
                 },
                 Expression::Literal(expr) => {
                     let definition_id = match &expr.value {
                         Literal::Struct(v) => v.definition,
                         Literal::Enum(v) => v.definition,
                         Literal::Union(v) => v.definition,
                         _ => unreachable!(),
                     };
                     let (poly_var, type_name) = get_poly_var_and_definition_name(ctx, poly_var_idx, definition_id);
                     return ParseError::new_error_at_span(
                         &ctx.module.source, expr.span, format!(
                             "Conflicting type for polymorphic variable '{}' of instantiation of '{}'",
                             poly_var, type_name
+                        )
                     );
                 },
                 Expression::Select(expr) => {
                     let field = expr.field.as_symbolic();
                     let (poly_var, struct_name) = get_poly_var_and_definition_name(ctx, poly_var_idx, field.definition.unwrap());
                     return ParseError::new_error_at_span(
                         &ctx.module.source, expr.span, format!(
                             "Conflicting type for polymorphic variable '{}' while accessing field '{}' of '{}'",
                             poly_var, field.identifier.value.as_str(), struct_name
+                        )
+                    )
+                }
                 _ => unreachable!("called construct_poly_arg_error without an expected expression, got: {:?}", expr)
+            }
+        }
         // Actual checking
         let expr = &ctx.heap[expr_id];
         let (expr_args, expr_return_name) = match expr {
             Expression::Call(expr) =>
+                (
                     expr.arguments.clone(),
                     "return type"
                 ),
             Expression::Literal(expr) => {
                 let expressions = match &expr.value {
                     Literal::Struct(v) => v.fields.iter()
                         .map(|f| f.value)
                         .collect(),
                     Literal::Enum(_) => Vec::new(),
                     Literal::Union(v) => v.values.clone(),
                     _ => unreachable!()
                 };
                 ( expressions, "literal" )
             },
             Expression::Select(expr) =>
                 // Select expression uses the polymorphic variables of the
                 // struct it is accessing, so get the subject expression.
+                (
                     vec![expr.subject],
                     "selected field"
                 ),
             _ => unreachable!(),
         };
         // - check return type with itself
         if let Some((poly_idx, section_a, section_b)) = has_poly_mismatch(
             &poly_data.returned, &poly_data.returned
         ) {
             return construct_main_error(ctx, poly_idx, expr)
                 .with_info_at_span(
                     &ctx.module.source, expr.span(), format!(
                         "The {} inferred the conflicting types '{}' and '{}'",
                         expr_return_name,
                         InferenceType::partial_display_name(&ctx.heap, section_a),
                         InferenceType::partial_display_name(&ctx.heap, section_b)
+                    )
                 );
+        }
         // - check arguments with each other argument and with return type
         for (arg_a_idx, arg_a) in poly_data.embedded.iter().enumerate() {
             for (arg_b_idx, arg_b) in poly_data.embedded.iter().enumerate() {
                 if arg_b_idx > arg_a_idx {
                     break;
+                }
                 if let Some((poly_idx, section_a, section_b)) = has_poly_mismatch(&arg_a, &arg_b) {
                     let error = construct_main_error(ctx, poly_idx, expr);
                     if arg_a_idx == arg_b_idx {
                         // Same argument
                         let arg = &ctx.heap[expr_args[arg_a_idx]];
                         return error.with_info_at_span(
                             &ctx.module.source, arg.span(), format!(
                                 "This argument inferred the conflicting types '{}' and '{}'",
                                 InferenceType::partial_display_name(&ctx.heap, section_a),
                                 InferenceType::partial_display_name(&ctx.heap, section_b)
+                            )
                         );
                     } else {
                         let arg_a = &ctx.heap[expr_args[arg_a_idx]];
                         let arg_b = &ctx.heap[expr_args[arg_b_idx]];
                         return error.with_info_at_span(
                             &ctx.module.source, arg_a.span(), format!(
                                 "This argument inferred it to '{}'",
                                 InferenceType::partial_display_name(&ctx.heap, section_a)
+                            )
                         ).with_info_at_span(
                             &ctx.module.source, arg_b.span(), format!(
                                 "While this argument inferred it to '{}'",
                                 InferenceType::partial_display_name(&ctx.heap, section_b)
+                            )
+                        )
+                    }
+                }
+            }
             // Check with return type
             if let Some((poly_idx, section_arg, section_ret)) = has_poly_mismatch(arg_a, &poly_data.returned) {
                 let arg = &ctx.heap[expr_args[arg_a_idx]];
                 return construct_main_error(ctx, poly_idx, expr)
                     .with_info_at_span(
                         &ctx.module.source, arg.span(), format!(
                             "This argument inferred it to '{}'",
                             InferenceType::partial_display_name(&ctx.heap, section_arg)
+                        )
+                    )
                     .with_info_at_span(
                         &ctx.module.source, expr.span(), format!(
                             "While the {} inferred it to '{}'",
                             expr_return_name,
                             InferenceType::partial_display_name(&ctx.heap, section_ret)
+                        )
                     );
+            }
+        }
         unreachable!("construct_poly_arg_error without actual error found?")
+    }
+}
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::protocol::arena::Id;
     use InferenceTypePart as ITP;
     use InferenceType as IT;
     #[test]
     fn test_single_part_inference() {
         // lhs argument inferred from rhs
         let pairs = [
             (ITP::NumberLike, ITP::UInt8),
             (ITP::IntegerLike, ITP::SInt32),
             (ITP::Unknown, ITP::UInt64),
             (ITP::Unknown, ITP::String)
         ];
         for (lhs, rhs) in pairs.iter() {
             // Using infer-both
             let mut lhs_type = IT::new(false, false, vec![lhs.clone()]);
             let mut rhs_type = IT::new(false, true, vec![rhs.clone()]);
             let result = unsafe{ IT::infer_subtrees_for_both_types(
                 &mut lhs_type, 0, &mut rhs_type, 0
             ) };
             assert_eq!(DualInferenceResult::First, result);
             assert_eq!(lhs_type.parts, rhs_type.parts);
             // Using infer-single
             let mut lhs_type = IT::new(false, false, vec![lhs.clone()]);
             let rhs_type = IT::new(false, true, vec![rhs.clone()]);
             let result = IT::infer_subtree_for_single_type(
                 &mut lhs_type, 0, &rhs_type.parts, 0
             );
             assert_eq!(SingleInferenceResult::Modified, result);
             assert_eq!(lhs_type.parts, rhs_type.parts);
+        }
+    }
     #[test]
     fn test_multi_part_inference() {
         let pairs = [
             (vec![ITP::ArrayLike, ITP::NumberLike], vec![ITP::Slice, ITP::SInt8]),
             (vec![ITP::Unknown], vec![ITP::Input, ITP::Array, ITP::String]),
             (vec![ITP::PortLike, ITP::SInt32], vec![ITP::Input, ITP::SInt32]),
             (vec![ITP::Unknown], vec![ITP::Output, ITP::SInt32]),
+            (
                 vec![ITP::Instance(Id::new(0), 2), ITP::Input, ITP::Unknown, ITP::Output, ITP::Unknown],
                 vec![ITP::Instance(Id::new(0), 2), ITP::Input, ITP::Array, ITP::SInt32, ITP::Output, ITP::SInt32]
+            )
         ];
         for (lhs, rhs) in pairs.iter() {
             let mut lhs_type = IT::new(false, false, lhs.clone());
             let mut rhs_type = IT::new(false, true, rhs.clone());
             let result = unsafe{ IT::infer_subtrees_for_both_types(
                 &mut lhs_type, 0, &mut rhs_type, 0
             ) };
             assert_eq!(DualInferenceResult::First, result);
             assert_eq!(lhs_type.parts, rhs_type.parts);
             let mut lhs_type = IT::new(false, false, lhs.clone());
             let rhs_type = IT::new(false, true, rhs.clone());
             let result = IT::infer_subtree_for_single_type(
                 &mut lhs_type, 0, &rhs_type.parts, 0
             );
             assert_eq!(SingleInferenceResult::Modified, result);
             assert_eq!(lhs_type.parts, rhs_type.parts)
+        }
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/pass_validation_linking.rs

➞

Show inline comments

 use crate::collections::{ScopedBuffer};
 use crate::protocol::ast::*;
 use crate::protocol::input_source::*;
 use crate::protocol::parser::symbol_table::*;
 use crate::protocol::parser::type_table::*;
 use super::visitor::{
     STMT_BUFFER_INIT_CAPACITY,
     EXPR_BUFFER_INIT_CAPACITY,
     Ctx,
     Visitor2,
     VisitorResult
 };
 use crate::protocol::parser::ModuleCompilationPhase;
 #[derive(PartialEq, Eq)]
 enum DefinitionType {
     Primitive(ComponentDefinitionId),
     Composite(ComponentDefinitionId),
     Function(FunctionDefinitionId)
+}
 impl DefinitionType {
     fn is_primitive(&self) -> bool { if let Self::Primitive(_) = self { true } else { false } }
     fn is_composite(&self) -> bool { if let Self::Composite(_) = self { true } else { false } }
     fn is_function(&self) -> bool { if let Self::Function(_) = self { true } else { false } }
     fn definition_id(&self) -> DefinitionId {
         match self {
             DefinitionType::Primitive(v) => v.upcast(),
             DefinitionType::Composite(v) => v.upcast(),
             DefinitionType::Function(v) => v.upcast(),
+        }
+    }
+}
 /// This particular visitor will go through the entire AST in a recursive manner
 /// and check if all statements and expressions are legal (e.g. no "return"
 /// statements in component definitions), and will link certain AST nodes to
 /// their appropriate targets (e.g. goto statements, or function calls).
 ///
 /// This visitor will not perform control-flow analysis (e.g. making sure that
 /// each function actually returns) and will also not perform type checking. So
 /// the linking of function calls and component instantiations will be checked
 /// and linked to the appropriate definitions, but the return types and/or
 /// arguments will not be checked for validity.
 ///
 ///
 /// Because of this scheme expressions will not be visited in the breadth-first
 /// pass.
 pub(crate) struct PassValidationLinking {
     /// `in_sync` is `Some(id)` if the visitor is visiting the children of a
     /// synchronous statement. A single value is sufficient as nested
     /// synchronous statements are not allowed
     in_sync: Option<SynchronousStatementId>,
     /// `in_while` contains the last encountered `While` statement. This is used
     /// to resolve unlabeled `Continue`/`Break` statements.
     in_while: Option<WhileStatementId>,
     // Traversal state: current scope (which can be used to find the parent
     // scope), the definition variant we are considering, and whether the
     // visitor is performing breadthwise block statement traversal.
     cur_scope: Option<Scope>,
     def_type: DefinitionType,
     // Parent expression (the previous stmt/expression we visited that could be
     // used as an expression parent)
     expr_parent: ExpressionParent,
     // Keeping track of relative position in block in the breadth-first pass.
     // May not correspond to block.statement[index] if any statements are
     // inserted after the breadth-pass
     relative_pos_in_block: u32,
     definition_buffer: ScopedBuffer<DefinitionId>,
     // Single buffer of statement IDs that we want to traverse in a block.
     // Required to work around Rust borrowing rules and to prevent constant
     // cloning of vectors.
     statement_buffer: ScopedBuffer<StatementId>,
     // Another buffer, now with expression IDs, to prevent constant cloning of
     // vectors while working around rust's borrowing rules
     expression_buffer: ScopedBuffer<ExpressionId>,
+}
 impl PassValidationLinking {
     pub(crate) fn new() -> Self {
         Self{
             in_sync: None,
             in_while: None,
             cur_scope: None,
             expr_parent: ExpressionParent::None,
             def_type: DefinitionType::Function(FunctionDefinitionId::new_invalid()),
             relative_pos_in_block: 0,
             definition_buffer: ScopedBuffer::new_reserved(128),
             statement_buffer: ScopedBuffer::new_reserved(STMT_BUFFER_INIT_CAPACITY),
             expression_buffer: ScopedBuffer::new_reserved(EXPR_BUFFER_INIT_CAPACITY),
+        }
+    }
     fn reset_state(&mut self) {
         self.in_sync = None;
         self.in_while = None;
         self.cur_scope = None;
         self.expr_parent = ExpressionParent::None;
         self.def_type = DefinitionType::Function(FunctionDefinitionId::new_invalid());
         self.relative_pos_in_block = 0;
+    }
+}
 impl Visitor2 for PassValidationLinking {
     fn visit_module(&mut self, ctx: &mut Ctx) -> VisitorResult {
         debug_assert_eq!(ctx.module.phase, ModuleCompilationPhase::TypesAddedToTable);
         let root = &ctx.heap[ctx.module.root_id];
         let section = self.definition_buffer.start_section_initialized(&root.definitions);
         for definition_idx in 0..section.len() {
             let definition_id = section[definition_idx];
             self.visit_definition(ctx, definition_id)?;
+        }
         section.forget();
         ctx.module.phase = ModuleCompilationPhase::ValidatedAndLinked;
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Definition visitors
     //--------------------------------------------------------------------------
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {
         self.reset_state();
         self.def_type = match &ctx.heap[id].variant {
             ComponentVariant::Primitive => DefinitionType::Primitive(id),
             ComponentVariant::Composite => DefinitionType::Composite(id),
         };
         self.cur_scope = Some(Scope::Definition(id.upcast()));
         self.expr_parent = ExpressionParent::None;
         // Visit statements in component body
         let body_id = ctx.heap[id].body;
         self.visit_block_stmt(ctx, body_id)?;
         Ok(())
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionDefinitionId) -> VisitorResult {
         self.reset_state();
         // Set internal statement indices
         self.def_type = DefinitionType::Function(id);
         self.cur_scope = Some(Scope::Definition(id.upcast()));
         self.expr_parent = ExpressionParent::None;
         // Visit statements in function body
         let body_id = ctx.heap[id].body;
         self.visit_block_stmt(ctx, body_id)?;
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Statement visitors
     //--------------------------------------------------------------------------
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         self.visit_block_stmt_with_hint(ctx, id, None)
+    }
     fn visit_local_memory_stmt(&mut self, _ctx: &mut Ctx, _id: MemoryStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_local_channel_stmt(&mut self, _ctx: &mut Ctx, _id: ChannelStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_labeled_stmt(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> VisitorResult {
         let body_id = ctx.heap[id].body;
         self.visit_stmt(ctx, body_id)?;
         Ok(())
+    }
     fn visit_if_stmt(&mut self, ctx: &mut Ctx, id: IfStatementId) -> VisitorResult {
         // Traverse expression and bodies
         let (test_id, true_id, false_id) = {
             let stmt = &ctx.heap[id];
             (stmt.test, stmt.true_body, stmt.false_body)
         };
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         self.expr_parent = ExpressionParent::If(id);
         self.visit_expr(ctx, test_id)?;
         self.expr_parent = ExpressionParent::None;
         self.visit_block_stmt(ctx, true_id)?;
         if let Some(false_id) = false_id {
             self.visit_block_stmt(ctx, false_id)?;
+        }
         Ok(())
+    }
     fn visit_while_stmt(&mut self, ctx: &mut Ctx, id: WhileStatementId) -> VisitorResult {
         let (test_id, body_id) = {
             let stmt = &ctx.heap[id];
             (stmt.test, stmt.body)
         };
         let old_while = self.in_while.replace(id);
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         self.expr_parent = ExpressionParent::While(id);
         self.visit_expr(ctx, test_id)?;
         self.expr_parent = ExpressionParent::None;
         self.visit_block_stmt(ctx, body_id)?;
         self.in_while = old_while;
         Ok(())
+    }
     fn visit_break_stmt(&mut self, ctx: &mut Ctx, id: BreakStatementId) -> VisitorResult {
         // Resolve break target
         let target_end_while = {
             let stmt = &ctx.heap[id];
             let target_while_id = self.resolve_break_or_continue_target(ctx, stmt.span, &stmt.label)?;
             let target_while = &ctx.heap[target_while_id];
             debug_assert!(target_while.end_while.is_some());
             target_while.end_while.unwrap()
         };
         let stmt = &mut ctx.heap[id];
         stmt.target = Some(target_end_while);
         Ok(())
+    }
     fn visit_continue_stmt(&mut self, ctx: &mut Ctx, id: ContinueStatementId) -> VisitorResult {
         // Resolve continue target
         let target_while_id = {
             let stmt = &ctx.heap[id];
             self.resolve_break_or_continue_target(ctx, stmt.span, &stmt.label)?
         };
         let stmt = &mut ctx.heap[id];
         stmt.target = Some(target_while_id);
         Ok(())
+    }
     fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {
         // Check for validity of synchronous statement
         let cur_sync_span = ctx.heap[id].span;
         if self.in_sync.is_some() {
             // Nested synchronous statement
             let old_sync_span = ctx.heap[self.in_sync.unwrap()].span;
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, cur_sync_span, "Illegal nested synchronous statement"
             ).with_info_str_at_span(
                 &ctx.module.source, old_sync_span, "It is nested in this synchronous statement"
             ));
+        }
         if !self.def_type.is_primitive() {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, cur_sync_span,
                 "synchronous statements may only be used in primitive components"
             ));
+        }
         let sync_body = ctx.heap[id].body;
         let old = self.in_sync.replace(id);
         self.visit_block_stmt_with_hint(ctx, sync_body, Some(id))?;
         self.in_sync = old;
         Ok(())
+    }
     fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {
         // Check if "return" occurs within a function
         let stmt = &ctx.heap[id];
         if !self.def_type.is_function() {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, stmt.span,
                 "return statements may only appear in function bodies"
             ));
+        }
         // If here then we are within a function
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         debug_assert_eq!(ctx.heap[id].expressions.len(), 1);
         self.expr_parent = ExpressionParent::Return(id);
         self.visit_expr(ctx, ctx.heap[id].expressions[0])?;
         self.expr_parent = ExpressionParent::None;
         Ok(())
+    }
     fn visit_goto_stmt(&mut self, ctx: &mut Ctx, id: GotoStatementId) -> VisitorResult {
         let target_id = self.find_label(ctx, &ctx.heap[id].label)?;
         ctx.heap[id].target = Some(target_id);
         let target = &ctx.heap[target_id];
         if self.in_sync != target.in_sync {
             // We can only goto the current scope or outer scopes. Because
             // nested sync statements are not allowed so if the value does
             // not match, then we must be inside a sync scope
             debug_assert!(self.in_sync.is_some());
             let goto_stmt = &ctx.heap[id];
             let sync_stmt = &ctx.heap[self.in_sync.unwrap()];
             return Err(
                 ParseError::new_error_str_at_span(&ctx.module.source, goto_stmt.span, "goto may not escape the surrounding synchronous block")
                 .with_info_str_at_span(&ctx.module.source, target.label.span, "this is the target of the goto statement")
                 .with_info_str_at_span(&ctx.module.source, sync_stmt.span, "which will jump past this statement")
             );
+        }
         Ok(())
+    }
     fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {
         // Make sure the new statement occurs inside a composite component
         if !self.def_type.is_composite() {
             let new_stmt = &ctx.heap[id];
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, new_stmt.span,
                 "instantiating components may only be done in composite components"
             ));
+        }
         // Recurse into call expression (which will check the expression parent
         // to ensure that the "new" statment instantiates a component)
         let call_expr_id = ctx.heap[id].expression;
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         self.expr_parent = ExpressionParent::New(id);
         self.visit_call_expr(ctx, call_expr_id)?;
         self.expr_parent = ExpressionParent::None;
         Ok(())
+    }
     fn visit_expr_stmt(&mut self, ctx: &mut Ctx, id: ExpressionStatementId) -> VisitorResult {
         let expr_id = ctx.heap[id].expression;
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         self.expr_parent = ExpressionParent::ExpressionStmt(id);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = ExpressionParent::None;
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Expression visitors
     //--------------------------------------------------------------------------
     fn visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let assignment_expr = &mut ctx.heap[id];
         let left_expr_id = assignment_expr.left;
         let right_expr_id = assignment_expr.right;
         let old_expr_parent = self.expr_parent;
         assignment_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, left_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, right_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let conditional_expr = &mut ctx.heap[id];
         let test_expr_id = conditional_expr.test;
         let true_expr_id = conditional_expr.true_expression;
         let false_expr_id = conditional_expr.false_expression;
         let old_expr_parent = self.expr_parent;
         conditional_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, test_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, true_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 2);
         self.visit_expr(ctx, false_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let binary_expr = &mut ctx.heap[id];
         let left_expr_id = binary_expr.left;
         let right_expr_id = binary_expr.right;
         let old_expr_parent = self.expr_parent;
         binary_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, left_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, right_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> VisitorResult {
         let unary_expr = &mut ctx.heap[id];
         let expr_id = unary_expr.expression;
         let old_expr_parent = self.expr_parent;
         unary_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(id.upcast(), 0);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let indexing_expr = &mut ctx.heap[id];
         let subject_expr_id = indexing_expr.subject;
         let index_expr_id = indexing_expr.index;
         let old_expr_parent = self.expr_parent;
         indexing_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, subject_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, index_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let slicing_expr = &mut ctx.heap[id];
         let subject_expr_id = slicing_expr.subject;
         let from_expr_id = slicing_expr.from_index;
         let to_expr_id = slicing_expr.to_index;
         let old_expr_parent = self.expr_parent;
         slicing_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, subject_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, from_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 2);
         self.visit_expr(ctx, to_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> VisitorResult {
         let select_expr = &mut ctx.heap[id];
         let expr_id = select_expr.subject;
         let old_expr_parent = self.expr_parent;
         select_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(id.upcast(), 0);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> VisitorResult {
         let literal_expr = &mut ctx.heap[id];
         let old_expr_parent = self.expr_parent;
         literal_expr.parent = old_expr_parent;
         match &mut literal_expr.value {
             Literal::Null | Literal::True | Literal::False |
             Literal::Character(_) | Literal::String(_) | Literal::Integer(_) => {
                 // Just the parent has to be set, done above
             },
             Literal::Struct(literal) => {
                 let upcast_id = id.upcast();
                 // Retrieve type definition
                 let type_definition = ctx.types.get_base_definition(&literal.definition).unwrap();
                 let struct_definition = type_definition.definition.as_struct();
                 // Make sure all fields are specified, none are specified twice
                 // and all fields exist on the struct definition
                 let mut specified = Vec::new(); // TODO: @performance
                 specified.resize(struct_definition.fields.len(), false);
                 for field in &mut literal.fields {
                     // Find field in the struct definition
                     let field_idx = struct_definition.fields.iter().position(|v| v.identifier == field.identifier);
                     if field_idx.is_none() {
                         let field_span = field.identifier.span;
                         let literal = ctx.heap[id].value.as_struct();
                         let ast_definition = &ctx.heap[literal.definition];
                         return Err(ParseError::new_error_at_span(
                             &ctx.module.source, field_span, format!(
                                 "This field does not exist on the struct '{}'",
                                 ast_definition.identifier().value.as_str()
+                            )
                         ));
+                    }
                     field.field_idx = field_idx.unwrap();
                     // Check if specified more than once
                     if specified[field.field_idx] {
                         return Err(ParseError::new_error_str_at_span(
                             &ctx.module.source, field.identifier.span,
                             "This field is specified more than once"
                         ));
+                    }
                     specified[field.field_idx] = true;
+                }
                 if !specified.iter().all(|v| *v) {
                     // Some fields were not specified
                     let mut not_specified = String::new();
                     let mut num_not_specified = 0;
                     for (def_field_idx, is_specified) in specified.iter().enumerate() {
                         if !is_specified {
                             if !not_specified.is_empty() { not_specified.push_str(", ") }
                             let field_ident = &struct_definition.fields[def_field_idx].identifier;
                             not_specified.push_str(field_ident.value.as_str());
                             num_not_specified += 1;
+                        }
+                    }
                     debug_assert!(num_not_specified > 0);
                     let msg = if num_not_specified == 1 {
                         format!("not all fields are specified, '{}' is missing", not_specified)
                     } else {
                         format!("not all fields are specified, [{}] are missing", not_specified)
                     };
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, literal.parser_type.elements[0].full_span, msg
                     ));
+                }
                 // Need to traverse fields expressions in struct and evaluate
                 // the poly args
                 let mut expr_section = self.expression_buffer.start_section();
                 for field in &literal.fields {
                     expr_section.push(field.value);
+                }
                 for expr_idx in 0..expr_section.len() {
                     let expr_id = expr_section[expr_idx];
                     self.expr_parent = ExpressionParent::Expression(upcast_id, expr_idx as u32);
                     self.visit_expr(ctx, expr_id)?;
+                }
                 expr_section.forget();
             },
             Literal::Enum(literal) => {
                 // Make sure the variant exists
                 let type_definition = ctx.types.get_base_definition(&literal.definition).unwrap();
                 let enum_definition = type_definition.definition.as_enum();
                 let variant_idx = enum_definition.variants.iter().position(|v| {
                     v.identifier == literal.variant
                 });
                 if variant_idx.is_none() {
                     let literal = ctx.heap[id].value.as_enum();
                     let ast_definition = ctx.heap[literal.definition].as_enum();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, literal.parser_type.elements[0].full_span, format!(
                             "the variant '{}' does not exist on the enum '{}'",
                             literal.variant.value.as_str(), ast_definition.identifier.value.as_str()
+                        )
                     ));
+                }
                 literal.variant_idx = variant_idx.unwrap();
             },
             Literal::Union(literal) => {
                 // Make sure the variant exists
                 let type_definition = ctx.types.get_base_definition(&literal.definition).unwrap();
                 let union_definition = type_definition.definition.as_union();
                 let variant_idx = union_definition.variants.iter().position(|v| {
                     v.identifier == literal.variant
                 });
                 if variant_idx.is_none() {
                     let literal = ctx.heap[id].value.as_union();
                     let ast_definition = ctx.heap[literal.definition].as_union();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, literal.parser_type.elements[0].full_span, format!(
                             "the variant does '{}' does not exist on the union '{}'",
                             literal.variant.value.as_str(), ast_definition.identifier.value.as_str()
+                        )
                     ));
+                }
                 literal.variant_idx = variant_idx.unwrap();
                 // Make sure the number of specified values matches the expected
                 // number of embedded values in the union variant.
                 let union_variant = &union_definition.variants[literal.variant_idx];
                 if union_variant.embedded.len() != literal.values.len() {
                     let literal = ctx.heap[id].value.as_union();
                     let ast_definition = ctx.heap[literal.definition].as_union();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, literal.parser_type.elements[0].full_span, format!(
                             "The variant '{}' of union '{}' expects {} embedded values, but {} were specified",
                             literal.variant.value.as_str(), ast_definition.identifier.value.as_str(),
                             union_variant.embedded.len(), literal.values.len()
                         ),
                     ))
+                }
                 // Traverse embedded values of union (if any) and evaluate the
                 // polymorphic arguments
                 let upcast_id = id.upcast();
                 let mut expr_section = self.expression_buffer.start_section();
                 for value in &literal.values {
                     expr_section.push(*value);
+                }
                 for expr_idx in 0..expr_section.len() {
                     let expr_id = expr_section[expr_idx];
                     self.expr_parent = ExpressionParent::Expression(upcast_id, expr_idx as u32);
                     self.visit_expr(ctx, expr_id)?;
+                }
                 expr_section.forget();
             },
             Literal::Array(literal) => {
                 // Visit all expressions in the array
                 let upcast_id = id.upcast();
                 let expr_section = self.expression_buffer.start_section_initialized(literal);
                 for expr_idx in 0..expr_section.len() {
                     let expr_id = expr_section[expr_idx];
                     self.expr_parent = ExpressionParent::Expression(upcast_id, expr_idx as u32);
                     self.visit_expr(ctx, expr_id)?;
+                }
                 expr_section.forget();
+            }
+        }
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {
         let call_expr = &mut ctx.heap[id];
         // Check whether the method is allowed to be called within the code's
         // context (in sync, definition type, etc.)
         let mut expected_wrapping_new_stmt = false;
         match &mut call_expr.method {
             Method::Get => {
                 if !self.def_type.is_primitive() {
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, call_expr.span,
                         "a call to 'get' may only occur in primitive component definitions"
                     ));
+                }
                 if self.in_sync.is_none() {
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, call_expr.span,
                         "a call to 'get' may only occur inside synchronous blocks"
                     ));
+                }
             },
             Method::Put => {
                 if !self.def_type.is_primitive() {
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, call_expr.span,
                         "a call to 'put' may only occur in primitive component definitions"
                     ));
+                }
                 if self.in_sync.is_none() {
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, call_expr.span,
                         "a call to 'put' may only occur inside synchronous blocks"
                     ));
+                }
             },
             Method::Fires => {
                 if !self.def_type.is_primitive() {
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, call_expr.span,
                         "a call to 'fires' may only occur in primitive component definitions"
                     ));
+                }
                 if self.in_sync.is_none() {
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, call_expr.span,
                         "a call to 'fires' may only occur inside synchronous blocks"
                     ));
+                }
             },
             Method::Create => {},
             Method::Length => {},
             Method::Assert => {
                 if self.def_type.is_function() {
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, call_expr.span,
                         "assert statement may only occur in components"
                     ));
+                }
                 if self.in_sync.is_none() {
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, call_expr.span,
                         "assert statements may only occur inside synchronous blocks"
                     ));
+                }
             },
             Method::UserFunction => {},
             Method::UserComponent => {
                 expected_wrapping_new_stmt = true;
             },
+        }
         if expected_wrapping_new_stmt {
             if !self.expr_parent.is_new() {
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module.source, call_expr.span,
                     "cannot call a component, it can only be instantiated by using 'new'"
                 ));
+            }
         } else {
             if self.expr_parent.is_new() {
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module.source, call_expr.span,
                     "only components can be instantiated, this is a function"
                 ));
+            }
+        }
         // Check the number of arguments
         let call_definition = ctx.types.get_base_definition(&call_expr.definition).unwrap();
         let num_expected_args = match &call_definition.definition {
             DefinedTypeVariant::Function(definition) => definition.arguments.len(),
             DefinedTypeVariant::Component(definition) => definition.arguments.len(),
             v => unreachable!("encountered {} type in call expression", v.type_class()),
         };
         let num_provided_args = call_expr.arguments.len();
         if num_provided_args != num_expected_args {
             let argument_text = if num_expected_args == 1 { "argument" } else { "arguments" };
             return Err(ParseError::new_error_at_span(
                 &ctx.module.source, call_expr.span, format!(
                     "expected {} {}, but {} were provided",
                     num_expected_args, argument_text, num_provided_args
+                )
             ));
+        }
         // Recurse into all of the arguments and set the expression's parent
         let upcast_id = id.upcast();
         let section = self.expression_buffer.start_section_initialized(&call_expr.arguments);
         let old_expr_parent = self.expr_parent;
         call_expr.parent = old_expr_parent;
         for arg_expr_idx in 0..section.len() {
             let arg_expr_id = section[arg_expr_idx];
             self.expr_parent = ExpressionParent::Expression(upcast_id, arg_expr_idx as u32);
             self.visit_expr(ctx, arg_expr_id)?;
+        }
         section.forget();
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {
         let var_expr = &ctx.heap[id];
         let variable_id = self.find_variable(ctx, self.relative_pos_in_block, &var_expr.identifier)?;
         let var_expr = &mut ctx.heap[id];
         var_expr.declaration = Some(variable_id);
         var_expr.parent = self.expr_parent;
         Ok(())
+    }
+}
 impl PassValidationLinking {
     //--------------------------------------------------------------------------
     // Special traversal
     //--------------------------------------------------------------------------
     fn visit_block_stmt_with_hint(&mut self, ctx: &mut Ctx, id: BlockStatementId, hint: Option<SynchronousStatementId>) -> VisitorResult {
         // Set parent scope and relative position in the parent scope. Remember
         // these values to set them back to the old values when we're done with
         // the traversal of the block's statements.
         let body = &mut ctx.heap[id];
         body.parent_scope = self.cur_scope.clone();
         body.relative_pos_in_parent = self.relative_pos_in_block;
         let old_scope = self.cur_scope.replace(match hint {
             Some(sync_id) => Scope::Synchronous((sync_id, id)),
             None => Scope::Regular(id),
         });
         let old_relative_pos = self.relative_pos_in_block;
         // Copy statement IDs into buffer
         let statement_section = self.statement_buffer.start_section_initialized(&body.statements);
         // Perform the breadth-first pass. Its main purpose is to find labeled
         // statements such that we can find the `goto`-targets immediately when
         // performing the depth pass
         for stmt_idx in 0..statement_section.len() {
             self.relative_pos_in_block = stmt_idx as u32;
             self.visit_statement_for_locals_labels_and_in_sync(ctx, self.relative_pos_in_block, statement_section[stmt_idx])?;
+        }
         for stmt_idx in 0..statement_section.len() {
             self.relative_pos_in_block = stmt_idx as u32;
             self.visit_stmt(ctx, statement_section[stmt_idx])?;
+        }
         self.cur_scope = old_scope;
         self.relative_pos_in_block = old_relative_pos;
         statement_section.forget();
         Ok(())
+    }
     fn visit_statement_for_locals_labels_and_in_sync(&mut self, ctx: &mut Ctx, relative_pos: u32, id: StatementId) -> VisitorResult {
         let statement = &mut ctx.heap[id];
         match statement {
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Memory(local) => {
                         let variable_id = local.variable;
                         self.checked_local_add(ctx, relative_pos, variable_id)?;
                     },
                     LocalStatement::Channel(local) => {
                         let from_id = local.from;
                         let to_id = local.to;
                         self.checked_local_add(ctx, relative_pos, from_id)?;
                         self.checked_local_add(ctx, relative_pos, to_id)?;
+                    }
+                }
+            }
             Statement::Labeled(stmt) => {
                 let stmt_id = stmt.this;
                 let body_id = stmt.body;
                 self.checked_label_add(ctx, relative_pos, self.in_sync, stmt_id)?;
                 self.visit_statement_for_locals_labels_and_in_sync(ctx, relative_pos, body_id)?;
             },
             Statement::While(stmt) => {
                 stmt.in_sync = self.in_sync;
             },
             _ => {},
+        }
         return Ok(())
+    }
     //--------------------------------------------------------------------------
     // Utilities
     //--------------------------------------------------------------------------
     /// Adds a local variable to the current scope. It will also annotate the
     /// `Local` in the AST with its relative position in the block.
     fn checked_local_add(&mut self, ctx: &mut Ctx, relative_pos: u32, id: LocalId) -> Result<(), ParseError> {
         debug_assert!(self.cur_scope.is_some());
         // Make sure we do not conflict with any global symbols
         let cur_scope = SymbolScope::Definition(self.def_type.definition_id());
+        {
             let ident = &ctx.heap[id].identifier;
             if let Some(symbol) = ctx.symbols.get_symbol_by_name(cur_scope, &ident.value.as_bytes()) {
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module.source, ident.span,
                     "local variable declaration conflicts with symbol"
                 ).with_info_str_at_span(
                     &ctx.module.source, symbol.variant.span_of_introduction(&ctx.heap), "the conflicting symbol is introduced here"
                 ));
+            }
+        }
         let local = &mut ctx.heap[id];
         local.relative_pos_in_block = relative_pos;
         // Make sure we do not shadow any variables in any of the scopes. Note
         // that variables in parent scopes may be declared later
         let local = &ctx.heap[id];
         let mut scope = self.cur_scope.as_ref().unwrap();
         let mut local_relative_pos = self.relative_pos_in_block;
         loop {
             debug_assert!(scope.is_block(), "scope is not a block");
             let block = &ctx.heap[scope.to_block()];
             for other_local_id in &block.locals {
                 let other_local = &ctx.heap[*other_local_id];
                 // Position check in case another variable with the same name
                 // is defined in a higher-level scope, but later than the scope
                 // in which the current variable resides.
                 if local.this != *other_local_id &&
                     local_relative_pos >= other_local.relative_pos_in_block &&
                     local.identifier == other_local.identifier {
                     // Collision within this scope
                     return Err(
                         ParseError::new_error_str_at_span(
                             &ctx.module.source, local.identifier.span, "Local variable name conflicts with another variable"
                         ).with_info_str_at_span(
                             &ctx.module.source, other_local.identifier.span, "Previous variable is found here"
+                        )
                     );
+                }
+            }
             // Current scope is fine, move to parent scope if any
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();
             if let Scope::Definition(definition_id) = scope {
                 // At outer scope, check parameters of function/component
                 for parameter_id in ctx.heap[*definition_id].parameters() {
                     let parameter = &ctx.heap[*parameter_id];
                     if local.identifier == parameter.identifier {
                         return Err(
                             ParseError::new_error_str_at_span(
                                 &ctx.module.source, local.identifier.span, "Local variable name conflicts with parameter"
                             ).with_info_str_at_span(
                                 &ctx.module.source, parameter.span, "Parameter definition is found here"
+                            )
                         );
+                    }
+                }
                 break;
+            }
             // If here, then we are dealing with a block-like parent block
             local_relative_pos = ctx.heap[scope.to_block()].relative_pos_in_parent;
+        }
         // No collisions at all
         let block = &mut ctx.heap[self.cur_scope.as_ref().unwrap().to_block()];
         block.locals.push(id);
         Ok(())
+    }
     /// Finds a variable in the visitor's scope that must appear before the
     /// specified relative position within that block.
     fn find_variable(&self, ctx: &Ctx, mut relative_pos: u32, identifier: &Identifier) -> Result<VariableId, ParseError> {
         debug_assert!(self.cur_scope.is_some());
         // TODO: May still refer to an alias of a global symbol using a single
         //  identifier in the namespace.
         // No need to use iterator over namespaces if here
         let mut scope = self.cur_scope.as_ref().unwrap();
         loop {
             debug_assert!(scope.is_block());
             let block = &ctx.heap[scope.to_block()];
             for local_id in &block.locals {
                 let local = &ctx.heap[*local_id];
                 if local.relative_pos_in_block < relative_pos && identifier == &local.identifier {
                     return Ok(local_id.upcast());
+                }
+            }
             debug_assert!(block.parent_scope.is_some());
             scope = block.parent_scope.as_ref().unwrap();
             if !scope.is_block() {
                 // Definition scope, need to check arguments to definition
                 match scope {
                     Scope::Definition(definition_id) => {
                         let definition = &ctx.heap[*definition_id];
                         for parameter_id in definition.parameters() {
                             let parameter = &ctx.heap[*parameter_id];
                             if identifier == &parameter.identifier {
                                 return Ok(parameter_id.upcast());
+                            }
+                        }
                     },
                     _ => unreachable!(),
+                }
                 // Variable could not be found
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module.source, identifier.span, "unresolved variable"
                 ));
             } else {
                 relative_pos = block.relative_pos_in_parent;
+            }
+        }
+    }
     /// Adds a particular label to the current scope. Will return an error if
     /// there is another label with the same name visible in the current scope.
     fn checked_label_add(&mut self, ctx: &mut Ctx, relative_pos: u32, in_sync: Option<SynchronousStatementId>, id: LabeledStatementId) -> Result<(), ParseError> {
         debug_assert!(self.cur_scope.is_some());
         // Make sure label is not defined within the current scope or any of the
         // parent scope.
         let label = &mut ctx.heap[id];
         label.relative_pos_in_block = relative_pos;
         label.in_sync = in_sync;
         let label = &ctx.heap[id];
         let mut scope = self.cur_scope.as_ref().unwrap();
         loop {
             debug_assert!(scope.is_block(), "scope is not a block");
             let block = &ctx.heap[scope.to_block()];
             for other_label_id in &block.labels {
                 let other_label = &ctx.heap[*other_label_id];
                 if other_label.label == label.label {
                     // Collision
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, label.label.span, "label name is used more than once"
                     ).with_info_str_at_span(
                         &ctx.module.source, other_label.label.span, "the other label is found here"
                     ));
+                }
+            }
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();
             if !scope.is_block() {
                 break;
+            }
+        }
         // No collisions
         let block = &mut ctx.heap[self.cur_scope.as_ref().unwrap().to_block()];
         block.labels.push(id);
         Ok(())
+    }
     /// Finds a particular labeled statement by its identifier. Once found it
     /// will make sure that the target label does not skip over any variable
     /// declarations within the scope in which the label was found.
     fn find_label(&self, ctx: &Ctx, identifier: &Identifier) -> Result<LabeledStatementId, ParseError> {
         debug_assert!(self.cur_scope.is_some());
         let mut scope = self.cur_scope.as_ref().unwrap();
         loop {
             debug_assert!(scope.is_block(), "scope is not a block");
             let relative_scope_pos = ctx.heap[scope.to_block()].relative_pos_in_parent;
             let block = &ctx.heap[scope.to_block()];
             for label_id in &block.labels {
                 let label = &ctx.heap[*label_id];
                 if label.label == *identifier {
                     for local_id in &block.locals {
                         // TODO: Better to do this in control flow analysis, it
                         //  is legal to skip over a variable declaration if it
                         //  is not actually being used. I might be missing
                         //  something here when laying out the bytecode...
                         let local = &ctx.heap[*local_id];
                         if local.relative_pos_in_block > relative_scope_pos && local.relative_pos_in_block < label.relative_pos_in_block {
                             return Err(
                                 ParseError::new_error_str_at_span(&ctx.module.source, identifier.span, "this target label skips over a variable declaration")
                                 .with_info_str_at_span(&ctx.module.source, label.label.span, "because it jumps to this label")
                                 .with_info_str_at_span(&ctx.module.source, local.identifier.span, "which skips over this variable")
                             );
+                        }
+                    }
                     return Ok(*label_id);
+                }
+            }
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();
             if !scope.is_block() {
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module.source, identifier.span, "could not find this label"
                 ));
+            }
+        }
+    }
     /// This function will check if the provided while statement ID has a block
     /// statement that is one of our current parents.
     fn has_parent_while_scope(&self, ctx: &Ctx, id: WhileStatementId) -> bool {
         debug_assert!(self.cur_scope.is_some());
         let mut scope = self.cur_scope.as_ref().unwrap();
         let while_stmt = &ctx.heap[id];
         loop {
             debug_assert!(scope.is_block());
             let block = scope.to_block();
             if while_stmt.body == block {
                 return true;
+            }
             let block = &ctx.heap[block];
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();
             if !scope.is_block() {
                 return false;
+            }
+        }
+    }
     /// This function should be called while dealing with break/continue
     /// statements. It will try to find the targeted while statement, using the
     /// target label if provided. If a valid target is found then the loop's
     /// ID will be returned, otherwise a parsing error is constructed.
     /// The provided input position should be the position of the break/continue
     /// statement.
     fn resolve_break_or_continue_target(&self, ctx: &Ctx, span: InputSpan, label: &Option<Identifier>) -> Result<WhileStatementId, ParseError> {
         let target = match label {
             Some(label) => {
                 let target_id = self.find_label(ctx, label)?;
                 // Make sure break target is a while statement
                 let target = &ctx.heap[target_id];
                 if let Statement::While(target_stmt) = &ctx.heap[target.body] {
                     // Even though we have a target while statement, the break might not be
                     // present underneath this particular labeled while statement
                     if !self.has_parent_while_scope(ctx, target_stmt.this) {
                         return Err(ParseError::new_error_str_at_span(
                             &ctx.module.source, label.span, "break statement is not nested under the target label's while statement"
                         ).with_info_str_at_span(
                             &ctx.module.source, target.label.span, "the targeted label is found here"
                         ));
+                    }
                     target_stmt.this
                 } else {
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, label.span, "incorrect break target label, it must target a while loop"
                     ).with_info_str_at_span(
                         &ctx.module.source, target.label.span, "The targeted label is found here"
                     ));
+                }
             },
             None => {
                 // Use the enclosing while statement, the break must be
                 // nested within that while statement
                 if self.in_while.is_none() {
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, span, "Break statement is not nested under a while loop"
                     ));
+                }
                 self.in_while.unwrap()
+            }
         };
         // We have a valid target for the break statement. But we need to
         // make sure we will not break out of a synchronous block
+        {
             let target_while = &ctx.heap[target];
             if target_while.in_sync != self.in_sync {
                 // Break is nested under while statement, so can only escape a
                 // sync block if the sync is nested inside the while statement.
                 debug_assert!(self.in_sync.is_some());
                 let sync_stmt = &ctx.heap[self.in_sync.unwrap()];
                 return Err(
                     ParseError::new_error_str_at_span(&ctx.module.source, span, "break may not escape the surrounding synchronous block")
                         .with_info_str_at_span(&ctx.module.source, target_while.span, "the break escapes out of this loop")
                         .with_info_str_at_span(&ctx.module.source, sync_stmt.span, "And would therefore escape this synchronous block")
                 );
+            }
+        }
         Ok(target)
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/token_parsing.rs

➞

Show inline comments

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

src/protocol/parser/tokens.rs

➞

Show inline comments

 use crate::protocol::input_source::{
     InputPosition as InputPosition,
     InputSpan
 };
 /// Represents a particular kind of token. Some tokens represent
 /// variable-character tokens. Such a token is always followed by a
 /// `TokenKind::SpanEnd` token.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub enum TokenKind {
     // Variable-character tokens, followed by a SpanEnd token
     Ident,          // regular identifier
     Pragma,         // identifier with prefixed `#`, range includes `#`
     Integer,        // integer literal
     String,         // string literal, range includes `"`
     Character,      // character literal, range includes `'`
     LineComment,    // line comment, range includes leading `//`, but not newline
     BlockComment,   // block comment, range includes leading `/*` and trailing `*/`
     // Punctuation (single character)
     Exclamation,    // !
     Question,       // ?
     Pound,          // #
     OpenAngle,      // <
     OpenCurly,      // {
     OpenParen,      // (
     OpenSquare,     // [
     CloseAngle,     // >
     CloseCurly,     // }
     CloseParen,     // )
     CloseSquare,    // ]
     Colon,          // :
     Comma,          // ,
     Dot,            // .
     SemiColon,      // ;
     // Operator-like (single character)
     At,             // @
     Plus,           // +
     Minus,          // -
     Star,           // *
     Slash,          // /
     Percent,        // %
     Caret,          // ^
     And,            // &
     Or,             // |
     Tilde,          // ~
     Equal,          // =
     // Punctuation (two characters)
     ColonColon,     // ::
     DotDot,         // ..
     ArrowRight,     // ->
     // Operator-like (two characters)
     PlusPlus,       // ++
     PlusEquals,     // +=
     MinusMinus,     // --
     MinusEquals,    // -=
     StarEquals,     // *=
     SlashEquals,    // /=
     PercentEquals,  // %=
     CaretEquals,    // ^=
     AndAnd,         // &&
     AndEquals,      // &=
     OrOr,           // ||
     OrEquals,       // |=
     EqualEqual,     // ==
     NotEqual,       // !=
     ShiftLeft,      // <<
     LessEquals,     // <=
     ShiftRight,     // >>
     GreaterEquals,  // >=
     // Operator-like (three characters)
     ShiftLeftEquals,// <<=
     ShiftRightEquals, // >>=
     // Special marker token to indicate end of variable-character tokens
     SpanEnd,
+}
 impl TokenKind {
     /// Returns true if the next expected token is the special `TokenKind::SpanEnd` token. This is
     /// the case for tokens of variable length (e.g. an identifier).
     fn has_span_end(&self) -> bool {
         return *self <= TokenKind::BlockComment
+    }
     /// Returns the number of characters associated with the token. May only be called on tokens
     /// that do not have a variable length.
     fn num_characters(&self) -> u32 {
         debug_assert!(!self.has_span_end() && *self != TokenKind::SpanEnd);
         if *self <= TokenKind::Equal {
         } else if *self <= TokenKind::ShiftRight {
         } else {
+        }
+    }
     /// Returns the characters that are represented by the token, may only be called on tokens that
     /// do not have a variable length.
     pub fn token_chars(&self) -> &'static str {
         debug_assert!(!self.has_span_end() && *self != TokenKind::SpanEnd);
         use TokenKind as TK;
         match self {
             TK::Exclamation => "!",
             TK::Question => "?",
             TK::Pound => "#",
             TK::OpenAngle => "<",
             TK::OpenCurly => "{",
             TK::OpenParen => "(",
             TK::OpenSquare => "[",
             TK::CloseAngle => ">",
             TK::CloseCurly => "}",
             TK::CloseParen => ")",
             TK::CloseSquare => "]",
             TK::Colon => ":",
             TK::Comma => ",",
             TK::Dot => ".",
             TK::SemiColon => ";",
             TK::At => "@",
             TK::Plus => "+",
             TK::Minus => "-",
             TK::Star => "*",
             TK::Slash => "/",
             TK::Percent => "%",
             TK::Caret => "^",
             TK::And => "&",
             TK::Or => "|",
             TK::Tilde => "~",
             TK::Equal => "=",
             TK::ColonColon => "::",
             TK::DotDot => "..",
             TK::ArrowRight => "->",
             TK::PlusPlus => "++",
             TK::PlusEquals => "+=",
             TK::MinusMinus => "--",
             TK::MinusEquals => "-=",
             TK::StarEquals => "*=",
             TK::SlashEquals => "/=",
             TK::PercentEquals => "%=",
             TK::CaretEquals => "^=",
             TK::AndAnd => "&&",
             TK::AndEquals => "&=",
             TK::OrOr => "||",
             TK::OrEquals => "|=",
             TK::EqualEqual => "==",
             TK::NotEqual => "!=",
             TK::ShiftLeft => "<<",
             TK::LessEquals => "<=",
             TK::ShiftRight => ">>",
             TK::GreaterEquals => ">=",
             TK::ShiftLeftEquals => "<<=",
             TK::ShiftRightEquals => ">>=",
             // Lets keep these in explicitly for now, in case we want to add more symbols
             TK::Ident | TK::Pragma | TK::Integer | TK::String | TK::Character |
             TK::LineComment | TK::BlockComment | TK::SpanEnd => unreachable!(),
+        }
+    }
+}
 /// Represents a single token at a particular position.
 pub struct Token {
     pub kind: TokenKind,
     pub pos: InputPosition,
+}
 impl Token {
     pub(crate) fn new(kind: TokenKind, pos: InputPosition) -> Self {
         Self{ kind, pos }
+    }
+}
 /// The kind of token ranges that are specially parsed by the tokenizer.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum TokenRangeKind {
     Module,
     Pragma,
     Import,
     Definition,
     Code,
+}
 pub const NO_RELATION: i32 = -1;
 pub const NO_SIBLING: i32 = NO_RELATION;
 /// A range of tokens with a specific meaning. Such a range is part of a tree
 /// where each parent tree envelops all of its children.
 #[derive(Debug)]
 pub struct TokenRange {
     // Index of parent in `TokenBuffer.ranges`, does not have a parent if the
     // range kind is Module, in that case the parent index points to itself.
     pub parent_idx: usize,
     // range kind is Module, in that case the parent index is -1.
     pub parent_idx: i32,
     pub range_kind: TokenRangeKind,
     pub curly_depth: u32,
     // Offsets into `TokenBuffer.ranges`: the tokens belonging to this range.
     pub start: u32,             // first token (inclusive index)
     pub end: u32,               // last token (exclusive index)
     // Child ranges
     pub num_child_ranges: u32,  // Number of subranges
     pub first_child_idx: u32,   // First subrange (or points to self if no subranges)
     pub last_child_idx: u32,    // Last subrange (or points to self if no subranges)
     pub next_sibling_idx: Option<u32>,
     pub first_child_idx: i32,   // First subrange (or -1 if no subranges)
     pub last_child_idx: i32,    // Last subrange (or -1 if no subranges)
     pub next_sibling_idx: i32,  // Next subrange (or -1 if no next subrange)
+}
 pub struct TokenBuffer {
     pub tokens: Vec<Token>,
     pub ranges: Vec<TokenRange>,
+}
 impl TokenBuffer {
     pub(crate) fn new() -> Self {
         Self{ tokens: Vec::new(), ranges: Vec::new() }
+    }
     pub(crate) fn iter_range<'a>(&'a self, range: &TokenRange) -> TokenIter<'a> {
         TokenIter::new(self, range.start as usize, range.end as usize)
+    }
     pub(crate) fn start_pos(&self, range: &TokenRange) -> InputPosition {
         self.tokens[range.start as usize].pos
+    }
     pub(crate) fn end_pos(&self, range: &TokenRange) -> InputPosition {
         let last_token = &self.tokens[range.end as usize - 1];
         if last_token.kind == TokenKind::SpanEnd {
             return last_token.pos
         } else {
             debug_assert!(!last_token.kind.has_span_end());
             return last_token.pos.with_offset(last_token.kind.num_characters());
+        }
+    }
+}
 /// Iterator over tokens within a specific `TokenRange`.
 pub(crate) struct TokenIter<'a> {
     tokens: &'a Vec<Token>,
     cur: usize,
     end: usize,
+}
 impl<'a> TokenIter<'a> {
     fn new(buffer: &'a TokenBuffer, start: usize, end: usize) -> Self {
         Self{ tokens: &buffer.tokens, cur: start, end }
+    }
     /// Returns the next token (may include comments), or `None` if at the end
     /// of the range.
     pub(crate) fn next_including_comments(&self) -> Option<TokenKind> {
         if self.cur >= self.end {
             return None;
+        }
         let token = &self.tokens[self.cur];
         Some(token.kind)
+    }
     /// Returns the next token (but skips over comments), or `None` if at the
     /// end of the range
     pub(crate) fn next(&mut self) -> Option<TokenKind> {
         while let Some(token_kind) = self.next_including_comments() {
             if token_kind != TokenKind::LineComment && token_kind != TokenKind::BlockComment {
                 return Some(token_kind);
+            }
             self.consume();
+        }
         return None
+    }
     /// Peeks ahead by one token (i.e. the one that comes after `next()`), and
     /// skips over comments
     pub(crate) fn peek(&self) -> Option<TokenKind> {
         for next_idx in self.cur + 1..self.end {
             let next_kind = self.tokens[next_idx].kind;
             if next_kind != TokenKind::LineComment && next_kind != TokenKind::BlockComment && next_kind != TokenKind::SpanEnd {
                 return Some(next_kind);
+            }
+        }
         return None;
+    }
     /// Returns the start position belonging to the token returned by `next`. If
     /// there is not a next token, then we return the end position of the
     /// previous token.
     pub(crate) fn last_valid_pos(&self) -> InputPosition {
         if self.cur < self.end {
             // Return token position
             return self.tokens[self.cur].pos
+        }
         // Return previous token end
         let token = &self.tokens[self.cur - 1];
         return if token.kind == TokenKind::SpanEnd {
             token.pos
         } else {
             token.pos.with_offset(token.kind.num_characters())
         };
+    }
     /// Returns the token range belonging to the token returned by `next`. This
     /// assumes that we're not at the end of the range we're iterating over.
     /// TODO: @cleanup Phase out?
     pub(crate) fn next_positions(&self) -> (InputPosition, InputPosition) {
         debug_assert!(self.cur < self.end);
         let token = &self.tokens[self.cur];
         if token.kind.has_span_end() {
             let span_end = &self.tokens[self.cur + 1];
             debug_assert_eq!(span_end.kind, TokenKind::SpanEnd);
             (token.pos, span_end.pos)
         } else {
             let offset = token.kind.num_characters();
             (token.pos, token.pos.with_offset(offset))
+        }
+    }
     /// See `next_positions`
     pub(crate) fn next_span(&self) -> InputSpan {
         let (begin, end) = self.next_positions();
         return InputSpan::from_positions(begin, end)
+    }
     /// Advances the iterator to the next (meaningful) token.
     pub(crate) fn consume(&mut self) {
         if let Some(kind) = self.next() {
             if kind.has_span_end() {
                 self.cur += 2;
             } else {
                 self.cur += 1;
+            }
+        }
+    }
     /// Saves the current iteration position, may be passed to `load` to return
     /// the iterator to a previous position.
     pub(crate) fn save(&self) -> (usize, usize) {
         (self.cur, self.end)
+    }
     pub(crate) fn load(&mut self, saved: (usize, usize)) {
         self.cur = saved.0;
         self.end = saved.1;
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/visitor.rs

➞

Show inline comments

 use crate::protocol::ast::*;
 use crate::protocol::input_source::ParseError;
 use crate::protocol::parser::{type_table::*, Module};
 use crate::protocol::symbol_table::{SymbolTable};
 type Unit = ();
 pub(crate) type VisitorResult = Result<Unit, ParseError>;
 /// Globally configured vector capacity for statement buffers in visitor
 /// implementations
 pub(crate) const STMT_BUFFER_INIT_CAPACITY: usize = 256;
 /// Globally configured vector capacity for expression buffers in visitor
 /// implementations
 pub(crate) const EXPR_BUFFER_INIT_CAPACITY: usize = 256;
 /// General context structure that is used while traversing the AST.
 pub(crate) struct Ctx<'p> {
     pub heap: &'p mut Heap,
     pub module: &'p Module,
+    pub module: &'p mut Module,
     pub symbols: &'p mut SymbolTable,
     pub types: &'p mut TypeTable,
+}
 /// Visitor is a generic trait that will fully walk the AST. The default
 /// implementation of the visitors is to not recurse. The exception is the
 /// top-level `visit_definition`, `visit_stmt` and `visit_expr` methods, which
 /// call the appropriate visitor function.
 pub(crate) trait Visitor2 {
     // Entry point
     fn visit_module(&mut self, ctx: &mut Ctx) -> VisitorResult {
         let mut def_index = 0;
         loop {
             let definition_id = {
                 let root = &ctx.heap[ctx.module.root_id];
                 if def_index >= root.definitions.len() {
                     return Ok(())
+                }
                 root.definitions[def_index]
             };
             self.visit_definition(ctx, definition_id)?;
             def_index += 1;
+        }
+    }
     // Definitions
     // --- enum matching
     fn visit_definition(&mut self, ctx: &mut Ctx, id: DefinitionId) -> VisitorResult {
         match &ctx.heap[id] {
             Definition::Enum(def) => {
                 let def = def.this;
                 self.visit_enum_definition(ctx, def)
             },
             Definition::Union(def) => {
                 let def = def.this;
                 self.visit_union_definition(ctx, def)
+            }
             Definition::Struct(def) => {
                 let def = def.this;
                 self.visit_struct_definition(ctx, def)
             },
             Definition::Component(def) => {
                 let def = def.this;
                 self.visit_component_definition(ctx, def)
             },
             Definition::Function(def) => {
                 let def = def.this;
                 self.visit_function_definition(ctx, def)
+            }
+        }
+    }
     // --- enum variant handling
     fn visit_enum_definition(&mut self, _ctx: &mut Ctx, _id: EnumDefinitionId) -> VisitorResult { Ok(()) }
     fn visit_union_definition(&mut self, _ctx: &mut Ctx, _id: UnionDefinitionId) -> VisitorResult{ Ok(()) }
     fn visit_struct_definition(&mut self, _ctx: &mut Ctx, _id: StructDefinitionId) -> VisitorResult { Ok(()) }
     fn visit_component_definition(&mut self, _ctx: &mut Ctx, _id: ComponentDefinitionId) -> VisitorResult { Ok(()) }
     fn visit_function_definition(&mut self, _ctx: &mut Ctx, _id: FunctionDefinitionId) -> VisitorResult { Ok(()) }
     // Statements
     // --- enum matching
     fn visit_stmt(&mut self, ctx: &mut Ctx, id: StatementId) -> VisitorResult {
         match &ctx.heap[id] {
             Statement::Block(stmt) => {
                 let this = stmt.this;
                 self.visit_block_stmt(ctx, this)
             },
             Statement::Local(stmt) => {
                 let this = stmt.this();
                 self.visit_local_stmt(ctx, this)
             },
             Statement::Labeled(stmt) => {
                 let this = stmt.this;
                 self.visit_labeled_stmt(ctx, this)
             },
             Statement::If(stmt) => {
                 let this = stmt.this;
                 self.visit_if_stmt(ctx, this)
             },
             Statement::EndIf(_stmt) => Ok(()),
             Statement::While(stmt) => {
                 let this = stmt.this;
                 self.visit_while_stmt(ctx, this)
             },
             Statement::EndWhile(_stmt) => Ok(()),
             Statement::Break(stmt) => {
                 let this = stmt.this;
                 self.visit_break_stmt(ctx, this)
             },
             Statement::Continue(stmt) => {
                 let this = stmt.this;
                 self.visit_continue_stmt(ctx, this)
             },
             Statement::Synchronous(stmt) => {
                 let this = stmt.this;
                 self.visit_synchronous_stmt(ctx, this)
             },
             Statement::EndSynchronous(_stmt) => Ok(()),
             Statement::Return(stmt) => {
                 let this = stmt.this;
                 self.visit_return_stmt(ctx, this)
             },
             Statement::Goto(stmt) => {
                 let this = stmt.this;
                 self.visit_goto_stmt(ctx, this)
             },
             Statement::New(stmt) => {
                 let this = stmt.this;
                 self.visit_new_stmt(ctx, this)
             },
             Statement::Expression(stmt) => {
                 let this = stmt.this;
                 self.visit_expr_stmt(ctx, this)
+            }
+        }
+    }
     fn visit_local_stmt(&mut self, ctx: &mut Ctx, id: LocalStatementId) -> VisitorResult {
         match &ctx.heap[id] {
             LocalStatement::Channel(stmt) => {
                 let this = stmt.this;
                 self.visit_local_channel_stmt(ctx, this)
             },
             LocalStatement::Memory(stmt) => {
                 let this = stmt.this;
                 self.visit_local_memory_stmt(ctx, this)
             },
+        }
+    }
     // --- enum variant handling
     fn visit_block_stmt(&mut self, _ctx: &mut Ctx, _id: BlockStatementId) -> VisitorResult { Ok(()) }
     fn visit_local_memory_stmt(&mut self, _ctx: &mut Ctx, _id: MemoryStatementId) -> VisitorResult { Ok(()) }
     fn visit_local_channel_stmt(&mut self, _ctx: &mut Ctx, _id: ChannelStatementId) -> VisitorResult { Ok(()) }
     fn visit_labeled_stmt(&mut self, _ctx: &mut Ctx, _id: LabeledStatementId) -> VisitorResult { Ok(()) }
     fn visit_if_stmt(&mut self, _ctx: &mut Ctx, _id: IfStatementId) -> VisitorResult { Ok(()) }
     fn visit_while_stmt(&mut self, _ctx: &mut Ctx, _id: WhileStatementId) -> VisitorResult { Ok(()) }
     fn visit_break_stmt(&mut self, _ctx: &mut Ctx, _id: BreakStatementId) -> VisitorResult { Ok(()) }
     fn visit_continue_stmt(&mut self, _ctx: &mut Ctx, _id: ContinueStatementId) -> VisitorResult { Ok(()) }
     fn visit_synchronous_stmt(&mut self, _ctx: &mut Ctx, _id: SynchronousStatementId) -> VisitorResult { Ok(()) }
     fn visit_return_stmt(&mut self, _ctx: &mut Ctx, _id: ReturnStatementId) -> VisitorResult { Ok(()) }
     fn visit_goto_stmt(&mut self, _ctx: &mut Ctx, _id: GotoStatementId) -> VisitorResult { Ok(()) }
     fn visit_new_stmt(&mut self, _ctx: &mut Ctx, _id: NewStatementId) -> VisitorResult { Ok(()) }
     fn visit_expr_stmt(&mut self, _ctx: &mut Ctx, _id: ExpressionStatementId) -> VisitorResult { Ok(()) }
     // Expressions
     // --- enum matching
     fn visit_expr(&mut self, ctx: &mut Ctx, id: ExpressionId) -> VisitorResult {
         match &ctx.heap[id] {
             Expression::Assignment(expr) => {
                 let this = expr.this;
                 self.visit_assignment_expr(ctx, this)
             },
             Expression::Binding(expr) => {
                 let this = expr.this;
                 self.visit_binding_expr(ctx, this)
+            }
             Expression::Conditional(expr) => {
                 let this = expr.this;
                 self.visit_conditional_expr(ctx, this)
+            }
             Expression::Binary(expr) => {
                 let this = expr.this;
                 self.visit_binary_expr(ctx, this)
+            }
             Expression::Unary(expr) => {
                 let this = expr.this;
                 self.visit_unary_expr(ctx, this)
+            }
             Expression::Indexing(expr) => {
                 let this = expr.this;
                 self.visit_indexing_expr(ctx, this)
+            }
             Expression::Slicing(expr) => {
                 let this = expr.this;
                 self.visit_slicing_expr(ctx, this)
+            }
             Expression::Select(expr) => {
                 let this = expr.this;
                 self.visit_select_expr(ctx, this)
+            }
             Expression::Literal(expr) => {
                 let this = expr.this;
                 self.visit_literal_expr(ctx, this)
+            }
             Expression::Call(expr) => {
                 let this = expr.this;
                 self.visit_call_expr(ctx, this)
+            }
             Expression::Variable(expr) => {
                 let this = expr.this;
                 self.visit_variable_expr(ctx, this)
+            }
+        }
+    }
     fn visit_assignment_expr(&mut self, _ctx: &mut Ctx, _id: AssignmentExpressionId) -> VisitorResult { Ok(()) }
     fn visit_binding_expr(&mut self, _ctx: &mut Ctx, _id: BindingExpressionId) -> VisitorResult { Ok(()) }
     fn visit_conditional_expr(&mut self, _ctx: &mut Ctx, _id: ConditionalExpressionId) -> VisitorResult { Ok(()) }
     fn visit_binary_expr(&mut self, _ctx: &mut Ctx, _id: BinaryExpressionId) -> VisitorResult { Ok(()) }
     fn visit_unary_expr(&mut self, _ctx: &mut Ctx, _id: UnaryExpressionId) -> VisitorResult { Ok(()) }
     fn visit_indexing_expr(&mut self, _ctx: &mut Ctx, _id: IndexingExpressionId) -> VisitorResult { Ok(()) }
     fn visit_slicing_expr(&mut self, _ctx: &mut Ctx, _id: SlicingExpressionId) -> VisitorResult { Ok(()) }
     fn visit_select_expr(&mut self, _ctx: &mut Ctx, _id: SelectExpressionId) -> VisitorResult { Ok(()) }
     fn visit_literal_expr(&mut self, _ctx: &mut Ctx, _id: LiteralExpressionId) -> VisitorResult { Ok(()) }
     fn visit_call_expr(&mut self, _ctx: &mut Ctx, _id: CallExpressionId) -> VisitorResult { Ok(()) }
     fn visit_variable_expr(&mut self, _ctx: &mut Ctx, _id: VariableExpressionId) -> VisitorResult { Ok(()) }
+}
@@ \ No newline at end of file @@

src/protocol/tests/lexer.rs

➞

Show inline comments

 /// lexer.rs
 ///
 /// Simple tests for the lexer. Only tests the lexing of the input source and
 /// the resulting AST without relying on the validation/typing pass
 use super::*;
 #[test]
 fn test_disallowed_inference() {
     Tester::new_single_source_expect_err(
         "argument auto inference",
-            "int func(auto arg) { return 0; }"
+            "s32 func(auto arg) { return 0; }"
     ).error(|e| { e
         .assert_msg_has(0, "inference is not allowed")
         .assert_occurs_at(0, "auto arg");
     });
     Tester::new_single_source_expect_err(
         "return type auto inference",
-        "auto func(int arg) { return 0; }"
+        "auto func(s32 arg) { return 0; }"
     ).error(|e| { e
         .assert_msg_has(0, "inference is not allowed")
         .assert_occurs_at(0, "auto func");
     });
     Tester::new_single_source_expect_err(
         "implicit polymorph argument auto inference",
-        "int func(in port) { return port; }"
+        "s32 func(in port) { return port; }"
     ).error(|e| { e
         .assert_msg_has(0, "inference is not allowed")
         .assert_occurs_at(0, "in port");
     });
     Tester::new_single_source_expect_err(
         "explicit polymorph argument auto inference",
-        "int func(in<auto> port) { return port; }"
+        "s32 func(in<auto> port) { return port; }"
     ).error(|e| { e
         .assert_msg_has(0, "inference is not allowed")
         .assert_occurs_at(0, "auto> port");
     });
     Tester::new_single_source_expect_err(
         "implicit polymorph return type auto inference",
         "in func(in<msg> a, in<msg> b) { return a; }"
     ).error(|e| { e
         .assert_msg_has(0, "inference is not allowed")
         .assert_occurs_at(0, "in func");
     });
     Tester::new_single_source_expect_err(
         "explicit polymorph return type auto inference",
         "in<auto> func(in<msg> a) { return a; }"
     ).error(|e| { e
         .assert_msg_has(0, "inference is not allowed")
         .assert_occurs_at(0, "auto> func");
     });
+}
 #[test]
 fn test_simple_struct_definition() {
     Tester::new_single_source_expect_ok(
         "empty struct",
         "struct Foo{}"
     ).for_struct("Foo", |t| { t.assert_num_fields(0); });
     Tester::new_single_source_expect_ok(
         "single field, no comma",
-        "struct Foo{ int field }"
+        "struct Foo{ s32 field }"
     ).for_struct("Foo", |t| { t
         .assert_num_fields(1)
         .for_field("field", |f| {
-            f.assert_parser_type("int");
+            f.assert_parser_type("s32");
         });
     });
     Tester::new_single_source_expect_ok(
         "single field, with comma",
-        "struct Foo{ int field, }"
+        "struct Foo{ s32 field, }"
     ).for_struct("Foo", |t| { t
         .assert_num_fields(1)
         .for_field("field", |f| { f
-            .assert_parser_type("int");
+            .assert_parser_type("s32");
         });
     });
     Tester::new_single_source_expect_ok(
         "multiple fields, no comma",
-        "struct Foo{ byte a, short b, int c }"
+        "struct Foo{ u8 a, s16 b, s32 c }"
     ).for_struct("Foo", |t| { t
         .assert_num_fields(3)
         .for_field("a", |f| { f.assert_parser_type("byte"); })
         .for_field("b", |f| { f.assert_parser_type("short"); })
         .for_field("c", |f| { f.assert_parser_type("int"); });
         .for_field("a", |f| { f.assert_parser_type("u8"); })
         .for_field("b", |f| { f.assert_parser_type("s16"); })
         .for_field("c", |f| { f.assert_parser_type("s32"); });
     });
     Tester::new_single_source_expect_ok(
         "multiple fields, with comma",
         "struct Foo{
             byte a,
             short b,
             int c,
             u8 a,
             s16 b,
             s32 c,
         }"
     ).for_struct("Foo", |t| { t
         .assert_num_fields(3)
         .for_field("a", |f| { f.assert_parser_type("byte"); })
         .for_field("b", |f| { f.assert_parser_type("short"); })
         .for_field("c", |f| { f.assert_parser_type("int"); });
         .for_field("a", |f| { f.assert_parser_type("u8"); })
         .for_field("b", |f| { f.assert_parser_type("s16"); })
         .for_field("c", |f| { f.assert_parser_type("s32"); });
     });
+}
@@ \ No newline at end of file @@

src/protocol/tests/parser_imports.rs

➞

Show inline comments

 /// parser_imports.rs
 ///
 /// Simple import tests
 use super::*;
 #[test]
 fn test_module_import() {
     Tester::new("single domain name")
         .with_source("
         #module external
-        struct Foo { int field }
+        struct Foo { s32 field }
         ")
         .with_source("
         import external;
-        int caller() {
+        s32 caller() {
             auto a = external::Foo{ field: 0 };
             return a.field;
+        }
         ")
         .compile()
         .expect_ok();
     Tester::new("multi domain name")
         .with_source("
         #module external.domain
-        struct Foo { int field }
+        struct Foo { s32 field }
         ")
         .with_source("
         import external.domain;
-        int caller() {
+        s32 caller() {
             auto a = domain::Foo{ field: 0 };
             return a.field;
+        }
         ")
         .compile()
         .expect_ok();
     Tester::new("aliased domain name")
         .with_source("
         #module external
-        struct Foo { int field }
+        struct Foo { s32 field }
         ")
         .with_source("
         import external as aliased;
-        int caller() {
+        s32 caller() {
             auto a = aliased::Foo{ field: 0 };
             return a.field;
+        }
         ")
         .compile()
         .expect_ok();
+}
 #[test]
 fn test_single_symbol_import() {
     Tester::new("specific symbol")
         .with_source("
         #module external
-        struct Foo { int field }
+        struct Foo { s32 field }
         ")
         .with_source("
         import external::Foo;
-        int caller() {
+        s32 caller() {
             auto a = Foo{ field: 1 };
             auto b = Foo{ field: 2 };
             return a.field + b.field;
         }")
         .compile()
         .expect_ok();
     Tester::new("specific aliased symbol")
         .with_source("
         #module external
-        struct Foo { int field }
+        struct Foo { s32 field }
         ")
         .with_source("
         import external::Foo as Bar;
-        int caller() {
+        s32 caller() {
             return Bar{ field: 0 }.field;
+        }
         ")
         .compile()
         .expect_ok();
     // TODO: Re-enable once std lib is properly implemented
     // Tester::new("import all")
     //     .with_source("
     //     #module external
-    //     struct Foo { int field }
+    //     struct Foo { s32 field }
     //     ")
     //     .with_source("
     //     import external::*;
-    //     int caller() { return Foo{field:0}.field; }
+    //     s32 caller() { return Foo{field:0}.field; }
     //     ")
     //     .compile()
     //     .expect_ok();
+}
 #[test]
 fn test_multi_symbol_import() {
     Tester::new("specific symbols")
         .with_source("
         #module external
         struct Foo { byte f }
         struct Bar { byte b }
         struct Foo { s8 f }
         struct Bar { s8 b }
         ")
         .with_source("
         import external::{Foo, Bar};
-        byte caller() {
+        s8 caller() {
             return Foo{f:0}.f + Bar{b:1}.b;
+        }
         ")
         .compile()
         .expect_ok();
     Tester::new("aliased symbols")
         .with_source("
         #module external
         struct Foo { byte in_foo }
         struct Bar { byte in_bar }
         struct Foo { s8 in_foo }
         struct Bar { s8 in_bar }
         ")
         .with_source("
         import external::{Foo as Bar, Bar as Foo};
-        byte caller() {
+        s8 caller() {
             return Foo{in_bar:0}.in_bar + Bar{in_foo:0}.in_foo;
         }")
         .compile()
         .expect_ok();
     // TODO: Re-enable once std lib is properly implemented
     // Tester::new("import all")
     //     .with_source("
     //     #module external
     //     struct Foo { byte f };
     //     struct Bar { byte b };
     //     struct Foo { s8 f };
     //     struct Bar { s8 b };
     //     ")
     //     .with_source("
     //     import external::*;
-    //     byte caller() {
+    //     s8 caller() {
     //         auto f = Foo{f:0};
     //         auto b = Bar{b:0};
     //         return f.f + b.b;
     //     }
     //     ")
     //     .compile()
     //     .expect_ok();
+}
 #[test]
 fn test_illegal_import_use() {
     Tester::new("unexpected polymorphic args")
         .with_source("
         #module external
-        struct Foo { byte f }
+        struct Foo { s8 f }
         ")
         .with_source("
         import external;
         byte caller() {
             auto foo = external::Foo<int>{ f: 0 };
         s8 caller() {
             auto foo = external::Foo<s32>{ f: 0 };
             return foo.f;
+        }
         ")
         .compile()
         .expect_err()
         .error(|e| { e
             .assert_msg_has(0, "the type Foo is not polymorphic");
         });
     Tester::new("mismatched polymorphic args")
         .with_source("
         #module external
         struct Foo<T>{ T f }
         ")
         .with_source("
         import external;
         byte caller() {
             auto foo = external::Foo<byte, int>{ f: 0 };
         s8 caller() {
             auto foo = external::Foo<s8, s32>{ f: 0 };
             return foo.f;
         }")
         .compile()
         .expect_err()
         .error(|e| { e
             .assert_msg_has(0, "expected 1 polymorphic")
             .assert_msg_has(0, "2 were specified");
         });
     Tester::new("module as type")
         .with_source("
         #module external
         ")
         .with_source("
         import external;
-        byte caller() {
+        s8 caller() {
             auto foo = external{ f: 0 };
             return 0;
+        }
         ")
         .compile()
         .expect_err()
         .error(|e| { e
             .assert_msg_has(0, "resolved to a namespace");
         });
     Tester::new("more namespaces than needed, not polymorphic")
         .with_source("
         #module external
-        struct Foo { byte f }
+        struct Foo { s8 f }
         ")
         .with_source("
         import external;
-        byte caller() {
+        s8 caller() {
             auto foo = external::Foo::f{ f: 0 };
             return 0;
         }")
         .compile()
         .expect_err()
         .error(|e| { e
             .assert_msg_has(0, "not fully resolve this identifier")
             .assert_msg_has(0, "able to match 'external::Foo'");
         });
     Tester::new("import from another import")
         .with_source("
         #module mod1
-        struct Foo { byte f }
+        struct Foo { s8 f }
         ")
         .with_source("
         #module mod2
         import mod1::Foo;
         struct Bar { Foo f }
         ")
         .with_source("
         import mod2;
-        byte caller() {
+        s8 caller() {
             auto bar = mod2::Bar{ f: mod2::Foo{ f: 0 } };
             return var.f.f;
         }")
         .compile()
         .expect_err()
         .error(|e| { e
             .assert_msg_has(0, "Could not resolve this identifier")
             .assert_occurs_at(0, "mod2::Foo");
         });
+}
@@ \ 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) {
+        func call(u8 b, u16 s, u32 i, u64 l) -> u32 {
             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");
+            .assert_concrete_type("u8");
         })
         .for_variable("s2", |v| { v
             .assert_parser_type("auto")
-            .assert_concrete_type("short");
+            .assert_concrete_type("u16");
         })
         .for_variable("i2", |v| { v
             .assert_parser_type("auto")
-            .assert_concrete_type("int");
+            .assert_concrete_type("u32");
         })
         .for_variable("l2", |v| { v
             .assert_parser_type("auto")
-            .assert_concrete_type("long");
+            .assert_concrete_type("u64");
         });
     });
     Tester::new_single_source_expect_ok(
         "by assignment",
+        "
         int call() {
             byte b1 = 0; short s1 = 0; int i1 = 0; long l1 = 0;
         func call() -> u32 {
             u8 b1 = 0; u16 s1 = 0; u32 i1 = 0; u64 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");
+            .assert_concrete_type("u8");
         })
         .for_variable("s2", |v| { v
             .assert_parser_type("auto")
-            .assert_concrete_type("short");
+            .assert_concrete_type("u16");
         })
         .for_variable("i2", |v| { v
             .assert_parser_type("auto")
-            .assert_concrete_type("int");
+            .assert_concrete_type("u32");
         })
         .for_variable("l2", |v| { v
             .assert_parser_type("auto")
-            .assert_concrete_type("long");
+            .assert_concrete_type("u64");
         });
     });
+}
 #[test]
 fn test_binary_expr_inference() {
     Tester::new_single_source_expect_ok(
         "compatible types",
         "int call() {
             byte b0 = 0;
             byte b1 = 1;
             short s0 = 0;
             short s1 = 1;
             int i0 = 0;
             int i1 = 1;
             long l0 = 0;
             long l1 = 1;
         "func call() -> s32 {
             s8 b0 = 0;
             s8 b1 = 1;
             s16 s0 = 0;
             s16 s1 = 1;
             s32 i0 = 0;
             s32 i1 = 1;
             s64 l0 = 0;
             s64 l1 = 1;
             auto b = b0 + b1;
             auto s = s0 + s1;
             auto i = i0 + i1;
             auto l = l0 + l1;
             return i;
         }"
     ).for_function("call", |f| { f
         .for_expression_by_source(
             "b0 + b1", "+",
-            |e| { e.assert_concrete_type("byte"); }
+            |e| { e.assert_concrete_type("s8"); }
+        )
         .for_expression_by_source(
             "s0 + s1", "+",
-            |e| { e.assert_concrete_type("short"); }
+            |e| { e.assert_concrete_type("s16"); }
+        )
         .for_expression_by_source(
             "i0 + i1", "+",
-            |e| { e.assert_concrete_type("int"); }
+            |e| { e.assert_concrete_type("s32"); }
+        )
         .for_expression_by_source(
             "l0 + l1", "+",
-            |e| { e.assert_concrete_type("long"); }
+            |e| { e.assert_concrete_type("s64"); }
         );
     });
     Tester::new_single_source_expect_err(
         "incompatible types",
         "int call() {
             byte b = 0;
             long l = 1;
         "func call() -> s32 {
             s8 b = 0;
             s64 l = 1;
             auto r = b + l;
             return 0;
         }"
     ).error(|e| { e
         .assert_ctx_has(0, "b + l")
         .assert_msg_has(0, "cannot apply")
         .assert_occurs_at(0, "+")
         .assert_msg_has(1, "has type 'byte'")
         .assert_msg_has(2, "has type 'long'");
         .assert_msg_has(1, "has type 's8'")
         .assert_msg_has(2, "has type 's64'");
     });
+}
 #[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) {
+        func construct<T1, T2>(T1 first, T2 second) -> Pair<T1, T2> {
             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() {
         func fix_t1<T2>(Pair<s8, T2> arg) -> s32 { return 0; }
         func fix_t2<T1>(Pair<T1, s32> arg) -> s32 { return 0; }
         func test() -> s32 {
             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");
+            .assert_concrete_type("s8");
         })
         .for_variable("second", |v| { v
             .assert_parser_type("auto")
-            .assert_concrete_type("int");
+            .assert_concrete_type("s32");
         })
         .for_variable("pair", |v| { v
             .assert_parser_type("auto")
-            .assert_concrete_type("Pair<byte,int>");
+            .assert_concrete_type("Pair<s8,s32>");
         });
     });
     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) {
+        func construct<T1, T2>(T1 first, T2 second) -> Pair<T1, T2> {
             return Pair{ first: first, second: second };
+        }
-        int test() {
+        test() -> s32 {
             auto first = 0;
             auto second = 1;
             auto pair = construct(first, second);
             byte assign_first = 0;
             long assign_second = 1;
             s8 assign_first = 0;
             s64 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");
+            .assert_concrete_type("s8");
         })
         .for_variable("second", |v| { v
             .assert_parser_type("auto")
-            .assert_concrete_type("long");
+            .assert_concrete_type("s64");
         })
         .for_variable("pair", |v| { v
             .assert_parser_type("auto")
-            .assert_concrete_type("Pair<byte,long>");
+            .assert_concrete_type("Pair<s8,s64>");
         });
     });
     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;
         func construct<T1, T2>(T1 l, T2 r) -> Node<T1, T2> {
             return Node{ l: l, r: r };
+        }
         func fix_poly<T>(Node<T, T> a) -> s32 { return 0; }
         func test() -> s32 {
             s8 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("Node<byte,Node<byte,byte>>");
+            .assert_concrete_type("Node<s8,Node<s8,s8>>");
         });
     });
+}
 #[test]
 fn test_enum_inference() {
     Tester::new_single_source_expect_ok(
         "no polymorphic vars",
+        "
         enum Choice { A, B }
-        int test_instances() {
+        test_instances() -> s32 {
             auto foo = Choice::A;
             auto bar = Choice::B;
             return 0;
+        }
+        "
     ).for_function("test_instances", |f| { f
         .for_variable("foo", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("Choice");
         })
         .for_variable("bar", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("Choice");
         });
     });
     Tester::new_single_source_expect_ok(
         "one polymorphic var",
+        "
         enum Choice<T>{
             A,
             B,
+        }
         int fix_as_byte(Choice<byte> arg) { return 0; }
         int fix_as_int(Choice<int> arg) { return 0; }
         int test_instances() {
             auto choice_byte = Choice::A;
             auto choice_int1 = Choice::B;
             Choice<auto> choice_int2 = Choice::B;
             fix_as_byte(choice_byte);
             fix_as_int(choice_int1);
             return fix_as_int(choice_int2);
         func fix_as_s8(Choice<s8> arg) -> s32 { return 0; }
         fix_as_s32(Choice<s32> arg) -> s32 { return 0; }
         test_instances() -> s32 {
             auto choice_s8 = Choice::A;
             auto choice_s32_1 = Choice::B;
             Choice<auto> choice_s32_2 = Choice::B;
             fix_as_s8(choice_s8);
             fix_as_s32(choice_s32_1);
             return fix_as_int(choice_s32_2);
+        }
+        "
     ).for_function("test_instances", |f| { f
-        .for_variable("choice_byte", |v| { v
+        .for_variable("choice_s8", |v| { v
             .assert_parser_type("auto")
-            .assert_concrete_type("Choice<byte>");
+            .assert_concrete_type("Choice<s8>");
         })
         .for_variable("choice_int1", |v| { v
             .assert_parser_type("auto")
             .assert_concrete_type("Choice<int>");
         })
         .for_variable("choice_int2", |v| { v
             .assert_parser_type("Choice<auto>")
             .assert_concrete_type("Choice<int>");
         });
     });
     Tester::new_single_source_expect_ok(
         "two polymorphic vars",
+        "
         enum Choice<T1, T2>{ A, B, }
         int fix_t1<T>(Choice<byte, T> arg) { return 0; }
         int fix_t2<T>(Choice<T, int> arg) { return 0; }
         int test_instances() {
             Choice<byte, auto> choice1 = Choice::A;
         fix_t1<T>(Choice<s8, T> arg) -> s32 { return 0; }
         fix_t2<T>(Choice<T, int> arg) -> s32 { return 0; }
         test_instances() -> int {
             Choice<s8, auto> choice1 = Choice::A;
             Choice<auto, int> choice2 = Choice::A;
             Choice<auto, auto> choice3 = Choice::B;
             auto choice4 = Choice::B;
             fix_t1(choice1); fix_t1(choice2); fix_t1(choice3); fix_t1(choice4);
             fix_t2(choice1); fix_t2(choice2); fix_t2(choice3); fix_t2(choice4);
             return 0;
+        }
+        "
     ).for_function("test_instances", |f| { f
         .for_variable("choice1", |v| { v
             .assert_parser_type("Choice<byte,auto>")
             .assert_concrete_type("Choice<byte,int>");
             .assert_parser_type("Choice<s8,auto>")
             .assert_concrete_type("Choice<s8,int>");
         })
         .for_variable("choice2", |v| { v
             .assert_parser_type("Choice<auto,int>")
-            .assert_concrete_type("Choice<byte,int>");
+            .assert_concrete_type("Choice<s8,int>");
         })
         .for_variable("choice3", |v| { v
             .assert_parser_type("Choice<auto,auto>")
-            .assert_concrete_type("Choice<byte,int>");
+            .assert_concrete_type("Choice<s8,int>");
         })
         .for_variable("choice4", |v| { v
             .assert_parser_type("auto")
-            .assert_concrete_type("Choice<byte,int>");
+            .assert_concrete_type("Choice<s8,int>");
         });
     });
+}
 #[test]
 fn test_failed_polymorph_inference() {
     Tester::new_single_source_expect_err(
         "function call inference mismatch",
+        "
         int poly<T>(T a, T b) { return 0; }
         int call() {
             byte first_arg = 5;
             long second_arg = 2;
         func poly<T>(T a, T b) -> s32 { return 0; }
         func call() -> s32 {
             s8 first_arg = 5;
             s64 second_arg = 2;
             return poly(first_arg, second_arg);
+        }
+        "
     ).error(|e| { e
         .assert_num(3)
         .assert_ctx_has(0, "poly(first_arg, second_arg)")
         .assert_occurs_at(0, "poly")
         .assert_msg_has(0, "Conflicting type for polymorphic variable 'T'")
         .assert_occurs_at(1, "second_arg")
-        .assert_msg_has(1, "inferred it to 'long'")
+        .assert_msg_has(1, "inferred it to 's64'")
         .assert_occurs_at(2, "first_arg")
-        .assert_msg_has(2, "inferred it to 'byte'");
+        .assert_msg_has(2, "inferred it to 's8'");
     });
     Tester::new_single_source_expect_err(
         "struct literal inference mismatch",
+        "
         struct Pair<T>{ T first, T second }
         int call() {
             byte first_arg = 5;
             long second_arg = 2;
         call() -> s32 {
             s8 first_arg = 5;
             s64 second_arg = 2;
             auto pair = Pair{ first: first_arg, second: second_arg };
             return 3;
+        }
+        "
     ).error(|e| { e
         .assert_num(3)
         .assert_ctx_has(0, "Pair{ first: first_arg, second: second_arg }")
         .assert_occurs_at(0, "Pair{")
         .assert_msg_has(0, "Conflicting type for polymorphic variable 'T'")
         .assert_occurs_at(1, "second_arg")
-        .assert_msg_has(1, "inferred it to 'long'")
+        .assert_msg_has(1, "inferred it to 's64'")
         .assert_occurs_at(2, "first_arg")
-        .assert_msg_has(2, "inferred it to 'byte'");
+        .assert_msg_has(2, "inferred it to 's8'");
     });
     // Cannot really test literal inference error, but this comes close
     Tester::new_single_source_expect_err(
         "enum literal inference mismatch",
+        "
         enum Uninteresting<T>{ Variant }
         int fix_t<T>(Uninteresting<T> arg) { return 0; }
         int call() {
         func fix_t<T>(Uninteresting<T> arg) -> s32 { return 0; }
         func call() -> s32 {
             auto a = Uninteresting::Variant;
-            fix_t<byte>(a);
+            fix_t<s8>(a);
             fix_t<int>(a);
             return 4;
+        }
+        "
     ).error(|e| { e
         .assert_num(2)
-        .assert_any_msg_has("type 'Uninteresting<byte>'")
+        .assert_any_msg_has("type 'Uninteresting<s8>'")
         .assert_any_msg_has("type 'Uninteresting<int>'");
     });
     Tester::new_single_source_expect_err(
         "field access inference mismatch",
+        "
         struct Holder<Shazam>{ Shazam a }
         int call() {
             byte to_hold = 0;
         func call() -> s32 {
             s8 to_hold = 0;
             auto holder = Holder{ a: to_hold };
             return holder.a;
+        }
+        "
     ).error(|e| { e
         .assert_num(3)
         .assert_ctx_has(0, "holder.a")
         .assert_occurs_at(0, ".")
         .assert_msg_has(0, "Conflicting type for polymorphic variable 'Shazam'")
-        .assert_msg_has(1, "inferred it to 'byte'")
+        .assert_msg_has(1, "inferred it to 's8'")
         .assert_msg_has(2, "inferred it to 'int'");
     });
     // TODO: Needs better error messages anyway, but this failed before
     Tester::new_single_source_expect_err(
         "nested field access inference mismatch",
+        "
         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;
             long another = 1;
         func construct<T1, T2>(T1 l, T2 r) -> Node<T1, T2> { return Node{ l: l, r: r }; }
         func fix_poly<T>(Node<T, T> a) -> s32 { return 0; }
         func test() -> s32 {
             s8 assigned = 0;
             s64 another = 1;
             auto thing = construct(assigned, construct(another, 1));
             fix_poly(thing.r);
             thing.r.r = assigned;
             return 0;
+        }
         ",
     );
+}
@@ \ No newline at end of file @@

src/protocol/tests/parser_monomorphs.rs

➞

Show inline comments

 /// parser_monomorphs.rs
 ///
 /// Simple tests to make sure that all of the appropriate monomorphs are
 /// instantiated
 use super::*;
 #[test]
 fn test_struct_monomorphs() {
     Tester::new_single_source_expect_ok(
         "no polymorph",
-        "struct Integer{ int field }"
+        "struct Integer{ s32 field }"
     ).for_struct("Integer", |s| { s
         .assert_num_monomorphs(0);
     });
     Tester::new_single_source_expect_ok(
         "single polymorph",
+        "
         struct Number<T>{ T number }
         int instantiator() {
             auto a = Number<byte>{ number: 0 };
             auto b = Number<byte>{ number: 1 };
             auto c = Number<int>{ number: 2 };
             auto d = Number<long>{ number: 3 };
             auto e = Number<Number<short>>{ number: Number{ number: 4 }};
         s32 instantiator() {
             auto a = Number<s8>{ number: 0 };
             auto b = Number<s8>{ number: 1 };
             auto c = Number<s32>{ number: 2 };
             auto d = Number<s64>{ number: 3 };
             auto e = Number<Number<s16>>{ number: Number{ number: 4 }};
             return 0;
+        }
+        "
     ).for_struct("Number", |s| { s
         .assert_has_monomorph("byte")
         .assert_has_monomorph("short")
         .assert_has_monomorph("int")
         .assert_has_monomorph("long")
         .assert_has_monomorph("Number<short>")
         .assert_has_monomorph("s8")
         .assert_has_monomorph("s16")
         .assert_has_monomorph("s32")
         .assert_has_monomorph("s64")
         .assert_has_monomorph("Number<s16>")
         .assert_num_monomorphs(5);
     }).for_function("instantiator", |f| { f
         .for_variable("a", |v| {v.assert_concrete_type("Number<byte>");} )
         .for_variable("e", |v| {v.assert_concrete_type("Number<Number<short>>");} );
         .for_variable("a", |v| {v.assert_concrete_type("Number<s8>");} )
         .for_variable("e", |v| {v.assert_concrete_type("Number<Number<s16>>");} );
     });
+}
 #[test]
 fn test_enum_monomorphs() {
     Tester::new_single_source_expect_ok(
         "no polymorph",
+        "
         enum Answer{ Yes, No }
-        int do_it() { auto a = Answer::Yes; return 0; }
+        s32 do_it() { auto a = Answer::Yes; return 0; }
+        "
     ).for_enum("Answer", |e| { e
         .assert_num_monomorphs(0);
     });
     Tester::new_single_source_expect_ok(
         "single polymorph",
+        "
         enum Answer<T> { Yes, No }
         int instantiator() {
             auto a = Answer<byte>::Yes;
             auto b = Answer<byte>::No;
             auto c = Answer<int>::Yes;
             auto d = Answer<Answer<Answer<long>>>::No;
         s32 instantiator() {
             auto a = Answer<s8>::Yes;
             auto b = Answer<s8>::No;
             auto c = Answer<s32>::Yes;
             auto d = Answer<Answer<Answer<s64>>>::No;
             return 0;
+        }
+        "
     ).for_enum("Answer", |e| { e
         .assert_num_monomorphs(3)
         .assert_has_monomorph("byte")
         .assert_has_monomorph("int")
         .assert_has_monomorph("Answer<Answer<long>>");
         .assert_has_monomorph("s8")
         .assert_has_monomorph("s32")
         .assert_has_monomorph("Answer<Answer<s64>>");
     });
+}
 #[test]
 fn test_union_monomorphs() {
     Tester::new_single_source_expect_ok(
         "no polymorph",
+        "
         union Trinary { Undefined, Value(boolean) }
-        int do_it() { auto a = Trinary::Value(true); return 0; }
+        s32 do_it() { auto a = Trinary::Value(true); return 0; }
+        "
     ).for_union("Trinary", |e| { e
         .assert_num_monomorphs(0);
     });
     // TODO: Does this do what we want? Or do we expect the embedded monomorph
-    //  Result<byte,int> to be instantiated as well? I don't think so.
+    //  Result<s8,s32> to be instantiated as well? I don't think so.
     Tester::new_single_source_expect_ok(
         "polymorphs",
+        "
         union Result<T, E>{ Ok(T), Err(E) }
         int instantiator() {
             short a_short = 5;
             auto a = Result<byte, boolean>::Ok(0);
             auto b = Result<boolean, byte>::Ok(true);
             auto c = Result<Result<byte, int>, Result<short, long>>::Err(Result::Ok(5));
             auto d = Result<Result<byte, int>, auto>::Err(Result<auto, long>::Ok(a_short));
         s32 instantiator() {
             s16 a_s16 = 5;
             auto a = Result<s8, boolean>::Ok(0);
             auto b = Result<boolean, s8>::Ok(true);
             auto c = Result<Result<s8, s32>, Result<s16, s64>>::Err(Result::Ok(5));
             auto d = Result<Result<s8, s32>, auto>::Err(Result<auto, s64>::Ok(a_s16));
             return 0;
+        }
+        "
     ).for_union("Result", |e| { e
         .assert_num_monomorphs(4)
         .assert_has_monomorph("byte;bool")
         .assert_has_monomorph("bool;byte")
         .assert_has_monomorph("Result<byte,int>;Result<short,long>")
         .assert_has_monomorph("short;long");
         .assert_has_monomorph("s8;bool")
         .assert_has_monomorph("bool;s8")
         .assert_has_monomorph("Result<s8,s32>;Result<s16,s64>")
         .assert_has_monomorph("s16;s64");
     }).for_function("instantiator", |f| { f
         .for_variable("d", |v| { v
             .assert_parser_type("auto")
-            .assert_concrete_type("Result<Result<byte,int>,Result<short,long>>");
+            .assert_concrete_type("Result<Result<s8,s32>,Result<s16,s64>>");
         });
     });
+}
@@ \ 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 }; }
         struct Foo { s32 a }
         Foo bar(s32 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 }; }
         struct Foo { s32 a, s32 b }
         Foo bar(s32 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 }; }
+        Foo<s32> bar(s32 arg) { return Foo<s32>{ field: arg }; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "single field, implicit polymorph",
+        "
         struct Foo<T>{ T field }
-        int bar(int arg) {
+        s32 bar(s32 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 };
         s32 bar(s32 arg) {
             auto qux = Pair<s32, s32>{ 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) {
+        s32 bar(s32 arg) {
             auto wup = Pair{ first: arg, second: arg };
             return arg;
+        }
+        "
     );
     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 };
         s32 bar(s32 arg1, s8 arg2) {
             auto shoo = Pair<s32, s8>{ 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) {
+        s32 bar(s32 arg1, s8 arg2) {
             auto shrubbery = Pair{ first: arg1, second: arg2 };
             return arg1;
+        }
+        "
     );
+}
 #[test]
 fn test_incorrect_struct_instance() {
     Tester::new_single_source_expect_err(
         "reused field in definition",
-        "struct Foo{ int a, byte a }"
+        "struct Foo{ s32 a, s8 a }"
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "a }")
         .assert_msg_has(0, "defined more than once")
         .assert_occurs_at(1, "a, ")
         .assert_msg_has(1, "other struct field");
     });
     Tester::new_single_source_expect_err(
         "reused field in instance",
+        "
         struct Foo{ int a, int b }
         int bar() {
             auto foo = Foo{ a: 5, a: 3 };
             return 0;
+        }
+        "
     ).error(|e| { e
         .assert_occurs_at(0, "a: 3")
         .assert_msg_has(0, "field is specified more than once");
     });
     Tester::new_single_source_expect_err(
         "missing field",
+        "
         struct Foo { int a, int b }
         int bar() {
             auto foo = Foo{ a: 2 };
             return 0;
+        }
+        "
     ).error(|e| { e
         .assert_occurs_at(0, "Foo{")
         .assert_msg_has(0, "'b' is missing");
     });
     Tester::new_single_source_expect_err(
         "missing fields",
+        "
         struct Foo { int a, int b, int c }
         int bar() {
             auto foo = Foo{ a: 2 };
             return 0;
+        }
+        "
     ).error(|e| { e
         .assert_occurs_at(0, "Foo{")
         .assert_msg_has(0, "[b, c] are missing");
     });
+}
 #[test]
 fn test_correct_enum_instance() {
     Tester::new_single_source_expect_ok(
         "single variant",
+        "
         enum Foo { A }
         Foo bar() { return Foo::A; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple variants",
+        "
         enum Foo { A=15, B = 0xF }
         Foo bar() { auto a = Foo::A; return Foo::B; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "explicit single polymorph",
+        "
         enum Foo<T>{ A }
         Foo<int> bar() { return Foo::A; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "explicit multi-polymorph",
+        "
         enum Foo<A, B>{ A, B }
-        Foo<byte, int> bar() { return Foo::B; }
+        Foo<s8, int> bar() { return Foo::B; }
+        "
     );
+}
 #[test]
 fn test_incorrect_enum_instance() {
     Tester::new_single_source_expect_err(
         "variant name reuse",
+        "
         enum Foo { A, A }
         Foo bar() { return Foo::A; }
+        "
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "A }")
         .assert_msg_has(0, "defined more than once")
         .assert_occurs_at(1, "A, ")
         .assert_msg_has(1, "other enum variant is defined here");
     });
     Tester::new_single_source_expect_err(
         "undefined variant",
+        "
         enum Foo { A }
         Foo bar() { return Foo::B; }
+        "
     ).error(|e| { e
         .assert_num(1)
         .assert_msg_has(0, "variant 'B' does not exist on the enum 'Foo'");
     });
+}
 #[test]
 fn test_correct_union_instance() {
     Tester::new_single_source_expect_ok(
         "single tag",
+        "
         union Foo { A }
         Foo bar() { return Foo::A; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple tags",
+        "
         union Foo { A, B }
         Foo bar() { return Foo::B; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "single embedded",
+        "
         union Foo { A(int) }
         Foo bar() { return Foo::A(5); }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple embedded",
+        "
-        union Foo { A(int), B(byte) }
+        union Foo { A(int), B(s8) }
         Foo bar() { return Foo::B(2); }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple values in embedded",
+        "
-        union Foo { A(int, byte) }
+        union Foo { A(int, s8) }
         Foo bar() { return Foo::A(0, 2); }
+        "
     );
     Tester::new_single_source_expect_ok(
         "mixed tag/embedded",
+        "
         union OptionInt { None, Some(int) }
         OptionInt bar() { return OptionInt::Some(3); }
+        "
     );
     Tester::new_single_source_expect_ok(
         "single polymorphic var",
+        "
         union Option<T> { None, Some(T) }
         Option<int> bar() { return Option::Some(3); }"
     );
     Tester::new_single_source_expect_ok(
         "multiple polymorphic vars",
+        "
         union Result<T, E> { Ok(T), Err(E), }
-        Result<int, byte> bar() { return Result::Ok(3); }
+        Result<int, s8> bar() { return Result::Ok(3); }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple polymorphic in one variant",
+        "
         union MaybePair<T1, T2>{ None, Some(T1, T2) }
-        MaybePair<byte, int> bar() { return MaybePair::Some(1, 2); }
+        MaybePair<s8, int> bar() { return MaybePair::Some(1, 2); }
+        "
     );
+}
 #[test]
 fn test_incorrect_union_instance() {
     Tester::new_single_source_expect_err(
         "tag-variant name reuse",
+        "
         union Foo{ A, A }
+        "
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "A }")
         .assert_msg_has(0, "union variant is defined more than once")
         .assert_occurs_at(1, "A, ")
         .assert_msg_has(1, "other union variant");
     });
     Tester::new_single_source_expect_err(
         "embedded-variant name reuse",
+        "
-        union Foo{ A(int), A(byte) }
+        union Foo{ A(int), A(s8) }
+        "
     ).error(|e| { e
         .assert_num(2)
-        .assert_occurs_at(0, "A(byte)")
+        .assert_occurs_at(0, "A(s8)")
         .assert_msg_has(0, "union variant is defined more than once")
         .assert_occurs_at(1, "A(int)")
         .assert_msg_has(1, "other union variant");
     });
     Tester::new_single_source_expect_err(
         "undefined variant",
+        "
-        union Silly{ Thing(byte) }
+        union Silly{ Thing(s8) }
         Silly bar() { return Silly::Undefined(5); }
+        "
     ).error(|e| { e
         .assert_msg_has(0, "variant 'Undefined' does not exist on the union 'Silly'");
     });
     Tester::new_single_source_expect_err(
         "using tag instead of embedded",
+        "
         union Foo{ A(int) }
         Foo bar() { return Foo::A; }
+        "
     ).error(|e| { e
         .assert_msg_has(0, "variant 'A' of union 'Foo' expects 1 embedded values, but 0 were");
     });
     Tester::new_single_source_expect_err(
         "using embedded instead of tag",
+        "
         union Foo{ A }
         Foo bar() { return Foo::A(3); }
+        "
     ).error(|e| { e
         .assert_msg_has(0, "The variant 'A' of union 'Foo' expects 0");
     });
     Tester::new_single_source_expect_err(
         "wrong embedded value",
+        "
         union Foo{ A(int) }
         Foo bar() { return Foo::A(false); }
+        "
     ).error(|e| { e
         .assert_occurs_at(0, "Foo::A")
         .assert_msg_has(0, "Failed to fully resolve")
         .assert_occurs_at(1, "false")
         .assert_msg_has(1, "has been resolved to 'int'")
         .assert_msg_has(1, "has been resolved to 'bool'");
     });
+}
@@ \ No newline at end of file @@

src/protocol/tests/utils.rs

➞

Show inline comments

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