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

Changeset - e9af393acc7d

Parent rev.

Child rev.

[Not reviewed]

0 3 0

mh - 4 years ago 2021-12-10 15:19:32
contact@maxhenger.nl

Support for tuples in ParserType parser

3 files changed with 532 insertions and 37 deletions:

src/protocol/input_source.rs

src/protocol/parser/pass_definitions.rs

src/protocol/parser/pass_definitions_types.rs

518

0 comments (0 inline, 0 general)

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 {
     // This will only be used for builtin functions
     #[inline]
     pub fn new() -> InputSpan {
         InputSpan{ begin: InputPosition{ line: 0, offset: 0 }, end: InputPosition{ line: 0, offset: 0 }}
+    }
     #[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 + 1); // for lookup_line_end, intentionally adding one character
         // 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. Note that the
         // end position is exclusive. So we only need to compensate for a
         // "\r\n"
         if offset_usize > 0 && offset_usize < self.input.len() && self.input[offset_usize] == b'\n' && self.input[offset_usize - 1] == b'\r' {
             offset - 1
         } else {
             offset
+        }
+    }
+}
 #[derive(Debug)]
 pub enum StatementKind {
     Info,
     Error
+}
 #[derive(Debug)]
 pub enum ContextKind {
     SingleLine,
     MultiLine,
+}
 #[derive(Debug)]
 pub struct ErrorStatement {
     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 ErrorStatement {
     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,
+        }
+    }
     pub(crate) 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: span.begin.line,
             start_column,
             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 ErrorStatement {
     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);
             // If the first index exceeds the size of the context then we should
             // have a message placed at the newline character
             let first_idx = first_col as usize - 1;
             let last_idx = last_col as usize - 1;
             if first_idx >= source.len() {
                 // If any of these fail then the logic behind reporting errors
                 // is incorrect.
                 debug_assert_eq!(first_idx, source.len());
                 debug_assert_eq!(first_idx + 1, last_idx);
                 target.push(extend_char);
             } else {
                 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 + 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<ErrorStatement>
+}
 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!(ErrorStatement::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!(ErrorStatement::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!(ErrorStatement::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!(ErrorStatement::from_source_at_span(
             StatementKind::Error, source, span, message.to_string()
         )) }
+    }
     pub fn with_at_span(mut self, error_type: StatementKind, source: &InputSource, span: InputSpan, message: String) -> Self {
         self.statements.push(ErrorStatement::from_source_at_span(error_type, source, span, message.to_string()));
         self
+    }
     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_pos(self, source: &InputSource, pos: InputPosition, msg: &str) -> Self {
         self.with_at_span(
             StatementKind::Info, source,
             InputSpan::from_positions(pos, pos.with_offset(1)),
             msg.to_string()
+        )
+    }
     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/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 super::pass_definitions_types::*;
 use crate::protocol::input_source::{InputSource, InputPosition, InputSpan, ParseError};
 use crate::collections::*;
 /// Parses all the tokenized definitions into actual AST nodes.
 pub(crate) struct PassDefinitions {
     // State associated with the definition currently being processed
     cur_definition: DefinitionId,
     // Itty bitty parsing machines
     type_parser: ParserTypeParser,
     // Temporary buffers of various kinds
     buffer: String,
     struct_fields: ScopedBuffer<StructFieldDefinition>,
     enum_variants: ScopedBuffer<EnumVariantDefinition>,
     union_variants: ScopedBuffer<UnionVariantDefinition>,
     variables: ScopedBuffer<VariableId>,
     expressions: ScopedBuffer<ExpressionId>,
     statements: ScopedBuffer<StatementId>,
     parser_types: ScopedBuffer<ParserType>,
+}
 impl PassDefinitions {
     pub(crate) fn new() -> Self {
         Self{
             cur_definition: DefinitionId::new_invalid(),
             type_parser: ParserTypeParser::new(),
             buffer: String::with_capacity(128),
             struct_fields: ScopedBuffer::new_reserved(128),
             enum_variants: ScopedBuffer::new_reserved(128),
             union_variants: ScopedBuffer::new_reserved(128),
             variables: ScopedBuffer::new_reserved(128),
             expressions: ScopedBuffer::new_reserved(128),
             statements: ScopedBuffer::new_reserved(128),
             parser_types: ScopedBuffer::new_reserved(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 => {
                     // Already fully parsed, fall through and go to next range
                 },
                 TokenRangeKind::Definition | TokenRangeKind::Code => {
                     // Visit range even if it is a "code" range to provide
                     // proper error messages.
                     self.visit_range(modules, module_idx, ctx, range_idx_usize)?;
                 },
+            }
             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 a keyword marking the start of a definition"
                 )),
+            }
+        }
+    }
     fn visit_struct_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         consume_exact_ident(&module.source, iter, KW_STRUCT)?;
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated DefinitionId
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         // Parse struct definition
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         let mut fields_section = self.struct_fields.start_section();
         consume_comma_separated(
             TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
                 let poly_vars = ctx.heap[definition_id].poly_vars();
                 let start_pos = iter.last_valid_pos();
                 let parser_type = 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 mut types_section = self.parser_types.start_section();
                 let has_embedded = maybe_consume_comma_separated(
                     TokenKind::OpenParen, TokenKind::CloseParen, source, iter, ctx,
                     |source, iter, ctx| {
                         let poly_vars = ctx.heap[definition_id].poly_vars();
                         consume_parser_type(
                             source, iter, &ctx.symbols, &ctx.heap, poly_vars,
                             module_scope, definition_id, false, 0
+                        )
                     },
                     &mut types_section, "an embedded type", Some(&mut close_pos)
                 )?;
                 let value = if has_embedded {
                     types_section.into_vec()
                 } else {
                     types_section.forget();
                     Vec::new()
                 };
                 Ok(UnionVariantDefinition{
                     span: InputSpan::from_positions(identifier.span.begin, close_pos),
                     identifier,
                     value
                 })
             },
             &mut variants_section, "a union variant", "a list of union variants", None
         )?;
         // Transfer to AST
         let union_def = ctx.heap[definition_id].as_union_mut();
         union_def.variants = variants_section.into_vec();
         Ok(())
+    }
     fn visit_function_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         // Retrieve function name
         consume_exact_ident(&module.source, iter, KW_FUNCTION)?;
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated DefinitionId
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         // Parse function's argument list
         let mut parameter_section = self.variables.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 return_types = self.parser_types.start_section();
         let mut open_curly_pos = iter.last_valid_pos(); // bogus value
         consume_comma_separated_until(
             TokenKind::OpenCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
                 let poly_vars = ctx.heap[definition_id].poly_vars();
                 consume_parser_type(source, iter, &ctx.symbols, &ctx.heap, poly_vars, module_scope, definition_id, false, 0)
             },
             &mut return_types, "a return type", Some(&mut open_curly_pos)
         )?;
         let return_types = return_types.into_vec();
         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> {
         // Consume component variant and name
         let (_variant_text, _) = consume_any_ident(&module.source, iter)?;
         debug_assert!(_variant_text == KW_PRIMITIVE || _variant_text == KW_COMPOSITE);
         let (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.variables.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();
             let statements = statements.into_vec();
             let id = ctx.heap.alloc_block_statement(|this| BlockStatement{
                 this,
                 is_implicit: true,
                 span: InputSpan::from_positions(wrap_begin_pos, wrap_end_pos),
                 statements,
                 end_block: EndBlockStatementId::new_invalid(),
                 scope_node: ScopeNode::new_invalid(),
                 first_unique_id_in_scope: -1,
                 next_unique_id_in_scope: -1,
                 relative_pos_in_parent: 0,
                 locals: Vec::new(),
                 labels: Vec::new(),
                 next: StatementId::new_invalid(),
             });
             let end_block = ctx.heap.alloc_end_block_statement(|this| EndBlockStatement{
                 this, start_block: id, next: StatementId::new_invalid()
             });
             let block_stmt = &mut ctx.heap[id];
             block_stmt.end_block = end_block;
             Ok(id)
+        }
+    }
     /// 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 = 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: StatementId::new_invalid()
                 });
                 section.push(end_if.upcast());
                 let if_stmt = &mut ctx.heap[id];
                 if_stmt.end_if = 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: StatementId::new_invalid()
                 });
                 section.push(end_while.upcast());
                 let while_stmt = &mut ctx.heap[id];
                 while_stmt.end_while = 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: StatementId::new_invalid()
                 });
                 section.push(end_sync.upcast());
                 let sync_stmt = &mut ctx.heap[id];
                 sync_stmt.end_sync = end_sync;
             } else if ident == KW_STMT_FORK {
                 let id = self.consume_fork_statement(module, iter, ctx)?;
                 section.push(id.upcast());
                 let end_fork = ctx.heap.alloc_end_fork_statement(|this| EndForkStatement{
                     this,
                     start_fork: id,
                     next: StatementId::new_invalid(),
                 });
                 section.push(end_fork.upcast());
                 let fork_stmt = &mut ctx.heap[id];
                 fork_stmt.end_fork = end_fork;
             } 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 normal
                 // 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());
+                }
+            }
         } 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;
         let id = ctx.heap.alloc_block_statement(|this| BlockStatement{
             this,
             is_implicit: false,
             span: block_span,
             statements,
             end_block: EndBlockStatementId::new_invalid(),
             scope_node: ScopeNode::new_invalid(),
             first_unique_id_in_scope: -1,
             next_unique_id_in_scope: -1,
             relative_pos_in_parent: 0,
             locals: Vec::new(),
             labels: Vec::new(),
             next: StatementId::new_invalid(),
         });
         let end_block = ctx.heap.alloc_end_block_statement(|this| EndBlockStatement{
             this, start_block: id, next: StatementId::new_invalid()
         });
         let block_stmt = &mut ctx.heap[id];
         block_stmt.end_block = end_block;
         Ok(id)
+    }
     fn consume_if_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<IfStatementId, ParseError> {
         let if_span = consume_exact_ident(&module.source, iter, KW_STMT_IF)?;
         consume_token(&module.source, iter, TokenKind::OpenParen)?;
         let test = self.consume_expression(module, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::CloseParen)?;
         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: EndIfStatementId::new_invalid(),
         }))
+    }
     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: EndWhileStatementId::new_invalid(),
             in_sync: SynchronousStatementId::new_invalid(),
         }))
+    }
     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: EndSynchronousStatementId::new_invalid(),
         }))
+    }
     fn consume_fork_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ForkStatementId, ParseError> {
         let fork_span = consume_exact_ident(&module.source, iter, KW_STMT_FORK)?;
         let left_body = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
         let right_body = if has_ident(&module.source, iter, KW_STMT_OR) {
             iter.consume();
             let right_body = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
             Some(right_body)
         } else {
             None
         };
         Ok(ctx.heap.alloc_fork_statement(|this| ForkStatement{
             this,
             span: fork_span,
             left_body,
             right_body,
             end_fork: EndForkStatementId::new_invalid(),
         }))
+    }
     fn consume_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, "an 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)?;
         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: StatementId::new_invalid(),
         }))
+    }
     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 (inner_port_type, end_pos) = 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();
             let parser_type = consume_parser_type(
                 &module.source, iter, &ctx.symbols, &ctx.heap,
                 poly_vars, SymbolScope::Module(module.root_id), definition_id,
                 true, 1
             )?;
             (parser_type.elements, parser_type.full_span.end)
         } else {
             // Assume inferred
+            (
                 vec![ParserTypeElement{
                     element_span: channel_span,
                     variant: ParserTypeVariant::Inferred
                 }],
                 channel_span.end
+            )
         };
         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 port_type_span = InputSpan::from_positions(channel_span.begin, end_pos);
         let port_type_len = inner_port_type.len() + 1;
         let mut from_port_type = ParserType{ elements: Vec::with_capacity(port_type_len), full_span: port_type_span };
         from_port_type.elements.push(ParserTypeElement{
             element_span: channel_span,
             variant: ParserTypeVariant::Output,
         });
         from_port_type.elements.extend_from_slice(&inner_port_type);
         let from = ctx.heap.alloc_variable(|this| Variable{
             this,
             kind: VariableKind::Local,
             identifier: from_identifier,
             parser_type: from_port_type,
             relative_pos_in_block: 0,
             unique_id_in_scope: -1,
         });
         let mut to_port_type = ParserType{ elements: Vec::with_capacity(port_type_len), full_span: port_type_span };
         to_port_type.elements.push(ParserTypeElement{
             element_span: channel_span,
             variant: ParserTypeVariant::Input
         });
         to_port_type.elements.extend_from_slice(&inner_port_type);
         let to = ctx.heap.alloc_variable(|this|Variable{
             this,
             kind: VariableKind::Local,
             identifier: to_identifier,
             parser_type: to_port_type,
             relative_pos_in_block: 0,
             unique_id_in_scope: -1,
         });
         // Construct the channel
         Ok(ctx.heap.alloc_channel_statement(|this| ChannelStatement{
             this,
             span: channel_span,
             from, to,
             relative_pos_in_block: 0,
             next: StatementId::new_invalid(),
         }))
+    }
     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: SynchronousStatementId::new_invalid(),
         });
         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.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_variable(|this| Variable{
                     this,
                     kind: VariableKind::Local,
                     identifier: identifier.clone(),
                     parser_type,
                     relative_pos_in_block: 0,
                     unique_id_in_scope: -1,
                 });
                 let memory_stmt_id = ctx.heap.alloc_memory_statement(|this| MemoryStatement{
                     this,
                     span: memory_span,
                     variable: local_id,
                     next: StatementId::new_invalid()
                 });
                 // Allocate the initial assignment
                 let variable_expr_id = ctx.heap.alloc_variable_expression(|this| VariableExpression{
                     this,
                     identifier,
                     declaration: None,
                     used_as_binding_target: false,
                     parent: ExpressionParent::None,
                     unique_id_in_definition: -1,
                 });
                 let assignment_expr_id = ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{
                     this,
                     operator_span: assign_span,
                     full_span: InputSpan::from_positions(memory_span.begin, initial_expr_end_pos),
                     left: variable_expr_id.upcast(),
                     operation: AssignmentOperator::Set,
                     right: initial_expr_id,
                     parent: ExpressionParent::None,
                     unique_id_in_definition: -1,
                 });
                 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: StatementId::new_invalid(),
                 });
                 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: StatementId::new_invalid(),
         }))
+    }
     //--------------------------------------------------------------------------
     // Expression Parsing
     //--------------------------------------------------------------------------
     // TODO: @Cleanup This is fine for now. But I prefer my stacktraces not to
     //  look like enterprise Java code...
     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::AtEquals            => Some(AO::Concatenated),
                 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 operator_span = iter.next_span();
             iter.consume();
             let left = expr;
             let right = self.consume_expression(module, iter, ctx)?;
             let full_span = InputSpan::from_positions(
                 ctx.heap[left].full_span().begin,
                 ctx.heap[right].full_span().end,
             );
             Ok(ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{
                 this, operator_span, full_span, left, operation, right,
                 parent: ExpressionParent::None,
                 unique_id_in_definition: -1,
             }).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 operator_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)?;
             let full_span = InputSpan::from_positions(
                 ctx.heap[test].full_span().begin,
                 ctx.heap[false_expression].full_span().end,
             );
             Ok(ctx.heap.alloc_conditional_expression(|this| ConditionalExpression{
                 this, operator_span, full_span, test, true_expression, false_expression,
                 parent: ExpressionParent::None,
                 unique_id_in_definition: -1,
             }).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<UnaryOperator> {
             use TokenKind as TK;
             use UnaryOperator as UO;
             match token {
                 Some(TK::Plus) => Some(UO::Positive),
                 Some(TK::Minus) => Some(UO::Negative),
                 Some(TK::Tilde) => Some(UO::BitwiseNot),
                 Some(TK::Exclamation) => Some(UO::LogicalNot),
                 _ => None
+            }
+        }
         let next = iter.next();
         if let Some(operation) = parse_prefix_token(next) {
             let operator_span = iter.next_span();
             iter.consume();
             let expression = self.consume_prefix_expression(module, iter, ctx)?;
             let full_span = InputSpan::from_positions(
                 operator_span.begin, ctx.heap[expression].full_span().end,
             );
             Ok(ctx.heap.alloc_unary_expression(|this| UnaryExpression {
                 this, operator_span, full_span, operation, expression,
                 parent: ExpressionParent::None,
                 unique_id_in_definition: -1,
             }).upcast())
         } else if next == Some(TokenKind::PlusPlus) {
             return Err(ParseError::new_error_str_at_span(
                 &module.source, iter.next_span(), "prefix increment is not supported in the language"
             ));
         } else if next == Some(TokenKind::MinusMinus) {
             return Err(ParseError::new_error_str_at_span(
                 &module.source, iter.next_span(), "prefix decrement is not supported in this language"
             ));
         } else {
             self.consume_postfix_expression(module, iter, ctx)
+        }
+    }
     fn consume_postfix_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         fn has_matching_postfix_token(token: Option<TokenKind>) -> bool {
             use TokenKind as TK;
             if token.is_none() { return false; }
             match token.unwrap() {
                 TK::PlusPlus | TK::MinusMinus | TK::OpenSquare | TK::Dot => true,
                 _ => false
+            }
+        }
         let mut result = self.consume_primary_expression(module, iter, ctx)?;
         let mut next = iter.next();
         while has_matching_postfix_token(next) {
             let token = next.unwrap();
             let mut operator_span = iter.next_span();
             iter.consume();
             if token == TokenKind::PlusPlus {
                 return Err(ParseError::new_error_str_at_span(
                     &module.source, operator_span, "postfix increment is not supported in this language"
                 ));
             } else if token == TokenKind::MinusMinus {
                 return Err(ParseError::new_error_str_at_span(
                     &module.source, operator_span, "prefix increment is not supported in this language"
                 ));
             } else if token == TokenKind::OpenSquare {
                 let subject = result;
                 let from_index = self.consume_expression(module, iter, ctx)?;
                 // Check if we have an indexing or slicing operation
                 next = iter.next();
                 if Some(TokenKind::DotDot) == next {
                     iter.consume();
                     let to_index = self.consume_expression(module, iter, ctx)?;
                     let end_span = consume_token(&module.source, iter, TokenKind::CloseSquare)?;
                     operator_span.end = end_span.end;
                     let full_span = InputSpan::from_positions(
                         ctx.heap[subject].full_span().begin, operator_span.end
                     );
                     result = ctx.heap.alloc_slicing_expression(|this| SlicingExpression{
                         this,
                         slicing_span: operator_span,
                         full_span, subject, from_index, to_index,
                         parent: ExpressionParent::None,
                         unique_id_in_definition: -1,
                     }).upcast();
                 } else if Some(TokenKind::CloseSquare) == next {
                     let end_span = consume_token(&module.source, iter, TokenKind::CloseSquare)?;
                     operator_span.end = end_span.end;
                     let full_span = InputSpan::from_positions(
                         ctx.heap[subject].full_span().begin, operator_span.end
                     );
                     result = ctx.heap.alloc_indexing_expression(|this| IndexingExpression{
                         this, operator_span, full_span, subject,
                         index: from_index,
                         parent: ExpressionParent::None,
                         unique_id_in_definition: -1,
                     }).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_name = consume_ident_interned(&module.source, iter, ctx)?;
                 let full_span = InputSpan::from_positions(
                     ctx.heap[subject].full_span().begin, field_name.span.end
                 );
                 result = ctx.heap.alloc_select_expression(|this| SelectExpression{
                     this, operator_span, full_span, subject, field_name,
                     parent: ExpressionParent::None,
                     unique_id_in_definition: -1,
                 }).upcast();
+            }
             next = iter.next();
+        }
         Ok(result)
+    }
     fn consume_primary_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         let next = iter.next();
         let result = if next == Some(TokenKind::OpenParen) {
             // 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,
                 unique_id_in_definition: -1,
             }).upcast()
         } else if next == Some(TokenKind::Integer) {
             let (literal, span) = consume_integer_literal(&module.source, iter, &mut self.buffer)?;
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this, span,
                 value: Literal::Integer(LiteralInteger{ unsigned_value: literal, negated: false }),
                 parent: ExpressionParent::None,
                 unique_id_in_definition: -1,
             }).upcast()
         } else if next == Some(TokenKind::String) {
             let span = consume_string_literal(&module.source, iter, &mut self.buffer)?;
             let interned = ctx.pool.intern(self.buffer.as_bytes());
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this, span,
                 value: Literal::String(interned),
                 parent: ExpressionParent::None,
                 unique_id_in_definition: -1,
             }).upcast()
         } else if next == Some(TokenKind::Character) {
             let (character, span) = consume_character_literal(&module.source, iter)?;
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this, span,
                 value: Literal::Character(character),
                 parent: ExpressionParent::None,
                 unique_id_in_definition: -1,
             }).upcast()
         } else if next == Some(TokenKind::Ident) {
             // May be a variable, a type instantiation or a function call. If we
             // have a single identifier that we cannot find in the type table
             // then we're going to assume that we're dealing with a variable.
             let ident_span = iter.next_span();
             let ident_text = module.source.section_at_span(ident_span);
             let symbol = ctx.symbols.get_symbol_by_name(SymbolScope::Module(module.root_id), ident_text);
             if symbol.is_some() {
                 // The first bit looked like a symbol, so we're going to follow
                 // that all the way through, assume we arrive at some kind of
                 // function call or type instantiation
                 use ParserTypeVariant as PTV;
                 let symbol_scope = SymbolScope::Definition(self.cur_definition);
                 let poly_vars = ctx.heap[self.cur_definition].poly_vars();
                 let parser_type = 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 fields", Some(&mut last_token)
                                 )?;
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, last_token),
                                     value: Literal::Struct(LiteralStruct{
                                         parser_type,
                                         fields: struct_fields,
                                         definition: target_definition_id,
                                     }),
                                     parent: ExpressionParent::None,
                                     unique_id_in_definition: -1,
                                 }).upcast()
                             },
                             Definition::Enum(_) => {
                                 // Enum literal: consume the variant
                                 consume_token(&module.source, iter, TokenKind::ColonColon)?;
                                 let variant = consume_ident_interned(&module.source, iter, ctx)?;
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, variant.span.end),
                                     value: Literal::Enum(LiteralEnum{
                                         parser_type,
                                         variant,
                                         definition: target_definition_id,
                                         variant_idx: 0
                                     }),
                                     parent: ExpressionParent::None,
                                     unique_id_in_definition: -1,
                                 }).upcast()
                             },
                             Definition::Union(_) => {
                                 // Union literal: consume the variant
                                 consume_token(&module.source, iter, TokenKind::ColonColon)?;
                                 let variant = consume_ident_interned(&module.source, iter, ctx)?;
                                 // Consume any possible embedded values
                                 let mut end_pos = variant.span.end;
                                 let values = if Some(TokenKind::OpenParen) == iter.next() {
                                     self.consume_expression_list(module, iter, ctx, Some(&mut end_pos))?
                                 } else {
                                     Vec::new()
                                 };
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, end_pos),
                                     value: Literal::Union(LiteralUnion{
                                         parser_type, variant, values,
                                         definition: target_definition_id,
                                         variant_idx: 0,
                                     }),
                                     parent: ExpressionParent::None,
                                     unique_id_in_definition: -1,
                                 }).upcast()
                             },
                             Definition::Component(_) => {
                                 // Component instantiation
                                 let func_span = parser_type.full_span;
                                 let mut full_span = func_span;
                                 let arguments = self.consume_expression_list(
                                     module, iter, ctx, Some(&mut full_span.end)
                                 )?;
                                 ctx.heap.alloc_call_expression(|this| CallExpression{
                                     this, func_span, full_span,
                                     parser_type,
                                     method: Method::UserComponent,
                                     arguments,
                                     definition: target_definition_id,
                                     parent: ExpressionParent::None,
                                     unique_id_in_definition: -1,
                                 }).upcast()
                             },
                             Definition::Function(function_definition) => {
                                 // Check whether it is a builtin function
                                 let method = if function_definition.builtin {
                                     match function_definition.identifier.value.as_bytes() {
                                         KW_FUNC_GET => Method::Get,
                                         KW_FUNC_PUT => Method::Put,
                                         KW_FUNC_FIRES => Method::Fires,
                                         KW_FUNC_CREATE => Method::Create,
                                         KW_FUNC_LENGTH => Method::Length,
                                         KW_FUNC_ASSERT => Method::Assert,
                                         KW_FUNC_PRINT => Method::Print,
                                         _ => unreachable!(),
+                                    }
                                 } else {
                                     Method::UserFunction
                                 };
                                 // Function call: consume the arguments
                                 let func_span = parser_type.full_span;
                                 let mut full_span = func_span;
                                 let arguments = self.consume_expression_list(
                                     module, iter, ctx, Some(&mut full_span.end)
                                 )?;
                                 ctx.heap.alloc_call_expression(|this| CallExpression{
                                     this, func_span, full_span, parser_type, method, arguments,
                                     definition: target_definition_id,
                                     parent: ExpressionParent::None,
                                     unique_id_in_definition: -1,
                                 }).upcast()
+                            }
+                        }
                     },
                     _ => {
                         return Err(ParseError::new_error_str_at_span(
                             &module.source, parser_type.full_span, "unexpected type in expression"
                         ))
+                    }
+                }
             } else {
                 // Check for builtin keywords or builtin functions
                 if ident_text == KW_LIT_NULL || ident_text == KW_LIT_TRUE || ident_text == KW_LIT_FALSE {
                     iter.consume();
                     // Parse builtin literal
                     let value = match ident_text {
                         KW_LIT_NULL => Literal::Null,
                         KW_LIT_TRUE => Literal::True,
                         KW_LIT_FALSE => Literal::False,
                         _ => unreachable!(),
                     };
                     ctx.heap.alloc_literal_expression(|this| LiteralExpression {
                         this,
                         span: ident_span,
                         value,
                         parent: ExpressionParent::None,
                         unique_id_in_definition: -1,
                     }).upcast()
                 } else if ident_text == KW_LET {
                     // Binding expression
                     let operator_span = iter.next_span();
                     iter.consume();
                     let bound_to = self.consume_prefix_expression(module, iter, ctx)?;
                     consume_token(&module.source, iter, TokenKind::Equal)?;
                     let bound_from = self.consume_prefix_expression(module, iter, ctx)?;
                     let full_span = InputSpan::from_positions(
                         operator_span.begin, ctx.heap[bound_from].full_span().end,
                     );
                     ctx.heap.alloc_binding_expression(|this| BindingExpression{
                         this, operator_span, full_span, bound_to, bound_from,
                         parent: ExpressionParent::None,
                         unique_id_in_definition: -1,
                     }).upcast()
                 } else if ident_text == KW_CAST {
                     // Casting expression
                     iter.consume();
                     let to_type = if Some(TokenKind::OpenAngle) == iter.next() {
                         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 {
                         // Automatic casting with inferred target type
                         ParserType{
                             elements: vec![ParserTypeElement{
                                 element_span: ident_span,
                                 variant: ParserTypeVariant::Inferred,
                             }],
                             full_span: ident_span
+                        }
                     };
                     consume_token(&module.source, iter, TokenKind::OpenParen)?;
                     let subject = self.consume_expression(module, iter, ctx)?;
                     let mut full_span = iter.next_span();
                     full_span.begin = to_type.full_span.begin;
                     consume_token(&module.source, iter, TokenKind::CloseParen)?;
                     ctx.heap.alloc_cast_expression(|this| CastExpression{
                         this,
                         cast_span: to_type.full_span,
                         full_span, to_type, subject,
                         parent: ExpressionParent::None,
                         unique_id_in_definition: -1,
                     }).upcast()
                 } else {
                     // Not a builtin literal, but also not a known type. So we
                     // assume it is a variable expression. Although if we do,
                     // then if a programmer mistyped a struct/function name the
                     // error messages will be rather cryptic. For polymorphic
                     // arguments we can't really do anything at all (because it
                     // uses the '<' token). In the other cases we try to provide
                     // a better error message.
                     iter.consume();
                     let next = iter.next();
                     if Some(TokenKind::ColonColon) == next {
                         return Err(ParseError::new_error_str_at_span(&module.source, ident_span, "unknown identifier"));
                     } else if Some(TokenKind::OpenParen) == next {
                         return Err(ParseError::new_error_str_at_span(
                             &module.source, ident_span,
                             "unknown identifier, did you mistype a union variant's, component's, or function's name?"
                         ));
                     } else if Some(TokenKind::OpenCurly) == next {
                         return Err(ParseError::new_error_str_at_span(
                             &module.source, ident_span,
                             "unknown identifier, did you mistype a struct type's name?"
                         ))
+                    }
                     let ident_text = ctx.pool.intern(ident_text);
                     let identifier = Identifier { span: ident_span, value: ident_text };
                     ctx.heap.alloc_variable_expression(|this| VariableExpression {
                         this,
                         identifier,
                         declaration: None,
                         used_as_binding_target: false,
                         parent: ExpressionParent::None,
                         unique_id_in_definition: -1,
                     }).upcast()
+                }
+            }
         } else {
             return Err(ParseError::new_error_str_at_pos(
                 &module.source, iter.last_valid_pos(), "expected an expression"
             ));
         };
         Ok(result)
+    }
     //--------------------------------------------------------------------------
     // Expression Utilities
     //--------------------------------------------------------------------------
     #[inline]
     fn consume_generic_binary_expression<
         M: Fn(Option<TokenKind>) -> Option<BinaryOperator>,
         F: Fn(&mut PassDefinitions, &Module, &mut TokenIter, &mut PassCtx) -> Result<ExpressionId, ParseError>
     >(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, match_fn: M, higher_precedence_fn: F
     ) -> Result<ExpressionId, ParseError> {
         let mut result = higher_precedence_fn(self, module, iter, ctx)?;
         while let Some(operation) = match_fn(iter.next()) {
             let operator_span = iter.next_span();
             iter.consume();
             let left = result;
             let right = higher_precedence_fn(self, module, iter, ctx)?;
             let full_span = InputSpan::from_positions(
                 ctx.heap[left].full_span().begin,
                 ctx.heap[right].full_span().end,
             );
             result = ctx.heap.alloc_binary_expression(|this| BinaryExpression{
                 this, operator_span, full_span, left, operation, right,
                 parent: ExpressionParent::None,
                 unique_id_in_definition: -1,
             }).upcast();
+        }
         Ok(result)
+    }
     #[inline]
     fn consume_expression_list(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, end_pos: Option<&mut InputPosition>
     ) -> Result<Vec<ExpressionId>, ParseError> {
         let mut section = self.expressions.start_section();
         consume_comma_separated(
             TokenKind::OpenParen, TokenKind::CloseParen, &module.source, iter, ctx,
             |_source, iter, ctx| self.consume_expression(module, iter, ctx),
             &mut section, "an expression", "a list of expressions", end_pos
         )?;
         Ok(section.into_vec())
+    }
+}
 /// Consumes 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, @Cleanup
 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,
+    }
     // After parsing the array modifier "[]", we need to insert an array type
     // before the most recently parsed type.
     fn insert_array_before(elements: &mut Vec<Entry>, depth: i32, span: InputSpan) {
         let index = elements.iter().rposition(|e| e.depth == depth).unwrap();
         let num_embedded = elements[index].element.variant.num_embedded();
         elements.insert(index, Entry{
             element: ParserTypeElement{ element_span: span, variant: ParserTypeVariant::Array },
             depth,
         });
         // Now the original element, and all of its children, should have their
         // depth incremented by 1
         elements[index + 1].depth += 1;
         if num_embedded != 0 {
             for idx in index + 2..elements.len() {
                 let element = &mut elements[idx];
                 if element.depth >= depth + 1 {
                     element.depth += 1;
                 } else {
                     break;
+                }
+            }
+        }
+    }
     // Most common case we just have one type, perhaps with some array
     // annotations. This is both the hot-path, and simplifies the state machine
     // that follows and is responsible for parsing more complicated types.
     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 num_embedded = element.variant.num_embedded();
         let first_pos = element.element_span.begin;
         let mut last_pos = element.element_span.end;
         let mut elements = Vec::with_capacity(num_embedded + 2); // type itself + embedded + 1 (maybe) array type
         // Consume any potential array elements
         while iter.next() == Some(TokenKind::OpenSquare) {
             let mut array_span = iter.next_span();
             iter.consume();
             let end_span = iter.next_span();
             array_span.end = end_span.end;
             consume_token(source, iter, TokenKind::CloseSquare)?;
             last_pos = end_span.end;
             elements.push(ParserTypeElement{ element_span: array_span, variant: ParserTypeVariant::Array });
+        }
         // Push the element itself
         let element_span = element.element_span;
         elements.push(element);
         // Check if polymorphic arguments are expected
         if num_embedded != 0 {
             if !allow_inference {
                 return Err(ParseError::new_error_str_at_span(source, element_span, "type inference is not allowed here"));
+            }
             for _ in 0..num_embedded {
                 elements.push(ParserTypeElement { element_span, variant: ParserTypeVariant::Inferred });
+            }
+        }
         // When we have applied the initial-open-angle hack (e.g. consuming an
         // explicit type on a channel), then we consume the closing angles as
         // well.
         for _ in 0..first_angle_depth {
             let (_, angle_end_pos) = iter.next_positions();
             last_pos = angle_end_pos;
             consume_token(source, iter, TokenKind::CloseAngle)?;
+        }
         return Ok(ParserType{
             elements,
             full_span: InputSpan::from_positions(first_pos, last_pos)
         });
     };
     // 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();
     let first_pos = element.element_span.begin;
     let mut last_pos = element.element_span.end;
     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 {
                     let (_, end_angle_pos) = iter.next_positions();
                     last_pos = end_angle_pos;
                     angle_depth -= 1;
                     state = State::Close;
                 } else if Some(TokenKind::ShiftRight) == next {
                     let (_, end_angle_pos) = iter.next_positions();
                     last_pos = end_angle_pos;
                     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 {
                     let (_, end_angle_pos) = iter.next_positions();
                     last_pos = end_angle_pos;
                     angle_depth -= 1;
                     state = State::Close;
                 } else if Some(TokenKind::ShiftRight) == next {
                     let (_, end_angle_pos) = iter.next_positions();
                     last_pos = end_angle_pos;
                     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 {
                     let (_, end_angle_pos) = iter.next_positions();
                     last_pos = end_angle_pos;
                     iter.consume();
                     angle_depth -= 1;
                     state = State::Close;
                 } else if Some(TokenKind::ShiftRight) == next {
                     let (_, end_angle_pos) = iter.next_positions();
                     last_pos = end_angle_pos;
                     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 have found the correct number of angle braces.
     // Check for trailing array identifiers
     while Some(TokenKind::OpenSquare) == iter.next() {
         let (array_start, _) = iter.next_positions();
         iter.consume();
         if Some(TokenKind::CloseSquare) != iter.next() {
             return Err(ParseError::new_error_str_at_pos(
                 source, iter.last_valid_pos(),
                 "unexpected token: expected ']'"
             ));
+        }
         let (_, array_end) = iter.next_positions();
         iter.consume();
         insert_array_before(&mut elements, 0, InputSpan::from_positions(array_start, array_end))
+    }
     // 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.
     for idx in 0..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.element_span,
                         "type inference is not allowed here"
                     ));
+                }
                 // Insert the missing types (in reverse order, but they're all
                 // of the "inferred" type anyway).
                 let inserted_span = cur_element.element.element_span;
                 let inserted_depth = cur_element.depth + 1;
                 elements.reserve(expected_subtypes);
                 for _ in 0..expected_subtypes {
                     elements.insert(idx + 1, Entry{
                         element: ParserTypeElement{ element_span: inserted_span, variant: ParserTypeVariant::Inferred },
                         depth: inserted_depth,
                     });
+                }
             } else {
                 // Mismatch in number of embedded types, produce a neat error
                 // message.
                 let type_name = String::from_utf8_lossy(source.section_at_span(cur_element.element.element_span));
                 fn polymorphic_name_text(num: usize) -> &'static str {
                     if num == 1 { "polymorphic argument" } else { "polymorphic arguments" }
+                }
                 fn were_or_was(num: usize) -> &'static str {
                     if num == 1 { "was" } else { "were" }
+                }
                 if expected_subtypes == 0 {
                     return Err(ParseError::new_error_at_span(
                         source, cur_element.element.element_span,
                         format!(
                             "the type '{}' is not polymorphic, yet {} {} {} provided",
                             type_name, encountered_subtypes, polymorphic_name_text(encountered_subtypes),
                             were_or_was(encountered_subtypes)
+                        )
                     ));
+                }
                 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.element_span,
                     format!(
                         "expected {} {}{} for the type '{}', but {} {} provided",
                         expected_subtypes, polymorphic_name_text(expected_subtypes),
                         maybe_infer_text, type_name, encountered_subtypes,
                         were_or_was(encountered_subtypes)
+                    )
                 ));
+            }
+        }
+    }
     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,
         full_span: InputSpan::from_positions(first_pos, last_pos)
     })
+}
 /// 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, or the subsequent specification
 /// of polymorphic arguments.
 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 as u32));
+                }
+            }
             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 a type but got a 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() {
                                 // If the type is imported in the module then notify the programmer
                                 // that imports do not leak outside of a module
                                 let type_name = String::from_utf8_lossy(type_text);
                                 let module_name = String::from_utf8_lossy(old_text);
                                 let suffix = if symbols.get_symbol_by_name(scope, type_text).is_some() {
                                     format!(
                                         ". The module '{}' does import '{}', but these imports are not visible to other modules",
                                         &module_name, &type_name
+                                    )
                                 } else {
                                     String::new()
                                 };
                                 return Err(ParseError::new_error_at_span(
                                     source, next_span,
                                     format!("unknown type '{}' in module '{}'{}", type_name, module_name, suffix)
                                 ));
+                            }
                             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 as u32));
                             break;
+                        }
+                    }
+                }
+            }
             debug_assert!(type_kind.is_some());
             type_kind.unwrap()
         },
     };
     Ok(ParserTypeElement{ element_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<VariableId>, 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(); // Rust being rust, multiple lookups
             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_variable(|this| Variable{
                 this,
                 kind: VariableKind::Parameter,
                 parser_type,
                 identifier,
                 relative_pos_in_block: 0,
                 unique_id_in_scope: -1,
             });
             Ok(parameter_id)
         },
         target, "a parameter", "a parameter list", None
+    )
+}
@@ \ No newline at end of file @@

src/protocol/parser/pass_definitions_types.rs

➞

Show inline comments

 use crate::protocol::*;
 use crate::protocol::parser::*;
 use crate::protocol::parser::token_parsing::*;
 struct Entry {
     element: ParserTypeElement,
     depth: i32,
+}
 #[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 enum DepthKind {
     Tuple, // because we had a `(` token
     PolyArgs, // because we had a `<` token
+}
 struct DepthElement {
     kind: DepthKind,
     entry_index: u32, // in `entries` array of parser
     pos: InputPosition,
+}
 /// Temporarily keep the error around in unevaluated format because sometimes
 /// when we evaluate a `ParserType`, we perform some backtracking if it fails.
 enum ParserTypeError {
     ExpectedAType(InputPosition),
     MessageAt(InputPosition, &'static str),
     TwoMessageAt(InputPosition, &'static str, InputPosition, &'static str),
 /// Current parsing state, for documentation's sake: types may be named, or may
 /// be tuples. Named types may have polymorphic arguments (if the type
 /// declaration allows) and a type may be turned into an array of that type by
 /// postfixing a "[]".
 enum ParseState {
     TypeMaybePolyArgs,  // just parsed a type, might have poly arguments
     TypeNeverPolyArgs,  // just parsed a type that cannot have poly arguments
     PolyArgStart,       // just opened a polymorphic argument list
     TupleStart,         // just opened a tuple list
     ParsedComma,        // just had a comma
+}
 /// Parsers tokens into `ParserType` instances (yes, the name of the struct is
 /// silly). Essentially a little state machine with its own temporary storage.
 pub(crate) struct ParserTypeParser {
     entries: Vec<Entry>,
     depths: Vec<DepthElement>,
     parse_state: ParseState,
     first_pos: InputPosition,
     last_pos: InputPosition,
+}
 impl ParserTypeParser {
     pub(crate) fn new() -> Self {
         return Self{
             entries: Vec::with_capacity(16),
             depths: Vec::with_capacity(16),
             parse_state: ParseState::TypeMaybePolyArgs,
             first_pos: InputPosition{ line: 0, offset: 0 },
             last_pos: InputPosition{ line: 0, offset: 0 }
+        }
+    }
     pub(crate) fn consume_parser_type(
         &mut self,
         source: &InputSource, iter: &mut TokenIter,
         symbols: &SymbolTable, heap: &Heap, poly_vars: &[Identifier],
         cur_scope: SymbolScope, wrapping_definition: DefinitionId,
         &mut self, iter: &mut TokenIter, heap: &Heap, source: &InputSource,
         symbols: &SymbolTable, poly_vars: &[Identifier],
         wrapping_definition: DefinitionId, cur_scope: SymbolScope,
         allow_inference: bool, inside_angular_bracket: Option<InputPosition>,
     ) -> Result<ParserType, ParserTypeError> {
         // Make sure we start in an empty state
         debug_assert!(self.entries.is_empty());
         debug_assert!(self.depths.is_empty());
     ) -> Result<ParserType, ParseError> {
         // Prepare
         self.entries.clear();
         self.depths.clear();
         // Setup processing
         if let Some(bracket_pos) = inside_angular_bracket {
             self.push_depth(DepthKind::PolyArgs, bracket_pos);
+            self.push_depth(DepthKind::PolyArgs, u32::MAX, bracket_pos);
+        }
-        let first_element = match iter.next() {
+        let initial_state = match iter.next() {
             Some(TokenKind::Ident) => {
                 let element = Self::consume_parser_type_element(
                     iter, source, heap, symbols, wrapping_definition, poly_vars, cur_scope, allow_inference
                 )?;
                 self.first_pos = element.element_span.begin;
                 self.last_pos = element.element_span.end;
                 self.entries.push(Entry{
                     element,
                     depth: self.cur_depth(),
                 });
                 ParseState::TypeMaybePolyArgs
             },
             Some(TokenKind::OpenParen) => {
                 let tuple_start_pos = iter.next_start_position();
                 self.push_depth(DepthKind::Tuple, tuple_start_pos);
                 self.first_pos = tuple_start_pos; // last pos will be set later, this is a tuple
                 let tuple_entry_index = self.entries.len() as u32;
                 self.push_depth(DepthKind::Tuple, tuple_entry_index, tuple_start_pos);
                 self.entries.push(Entry{
                     element: ParserTypeElement{
                         element_span: InputSpan::from_positions(tuple_start_pos, tuple_start_pos),
                         variant: ParserTypeVariant::Tuple(0),
                     },
                     depth: self.cur_depth(),
                 });
                 iter.consume();
                 ParseState::PolyArgStart
             },
-            _ => return Err(ParserTypeError::MessageAt(iter.last_valid_pos(), "expected a type")),
+            _ => return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected a type")),
         };
         self.parse_state = initial_state;
         // Depth stack and entries are initialized, continue until depth stack
         // is empty, or until an unexpected set of tokens is encountered
         while !self.depths.is_empty() {
             let next = iter.next();
             match self.parse_state {
                 ParseState::TypeMaybePolyArgs => {
                     // Allowed tokens: , < > >> ) [
                     match next {
                         Some(TokenKind::Comma) => self.consume_comma(iter),
                         Some(TokenKind::OpenAngle) => self.consume_open_angle(iter),
                         Some(TokenKind::CloseAngle) => self.consume_close_angle(source, iter)?,
                         Some(TokenKind::ShiftRight) => self.consume_double_close_angle(source, iter)?,
                         Some(TokenKind::CloseParen) => self.consume_close_paren(source, iter)?,
                         Some(TokenKind::OpenSquare) => self.consume_square_parens(source, iter)?,
                         _ => return Err(ParseError::new_error_str_at_pos(
                             source, iter.last_valid_pos(),
                             "unexpected token: expected ',', '<', '>', '<<', ')' or '['"
                         )),
+                    }
                 },
                 ParseState::TypeNeverPolyArgs => {
                     // Allowed tokens: , > >> ) [
                     match next {
                         Some(TokenKind::Comma) => self.consume_comma(iter),
                         Some(TokenKind::CloseAngle) => self.consume_close_angle(source, iter)?,
                         Some(TokenKind::ShiftRight) => self.consume_double_close_angle(source, iter)?,
                         Some(TokenKind::CloseParen) => self.consume_close_paren(source, iter)?,
                         Some(TokenKind::OpenSquare) => self.consume_square_parens(source, iter)?,
                         _ => return Err(ParseError::new_error_str_at_pos(
                             source, iter.last_valid_pos(),
                             "unexpected token: expected ',', '>', '>>', ')' or '['"
                         )),
+                    }
                 },
                 ParseState::PolyArgStart => {
                     // Allowed tokens: ident (
                     match next {
                         Some(TokenKind::Ident) => self.consume_type_idents(
                             source, heap, symbols, wrapping_definition, poly_vars, cur_scope, allow_inference, iter
                         )?,
                         Some(TokenKind::OpenParen) => self.consume_open_paren(iter),
                         _ => return Err(ParseError::new_error_str_at_pos(
                             source, iter.last_valid_pos(),
                             "unexpected token: expected typename or '('"
                         )),
+                    }
                 },
                 ParseState::TupleStart => {
                     // Allowed tokens: ident )
                     match next {
                         Some(TokenKind::Ident) => self.consume_type_idents(
                             source, heap, symbols, wrapping_definition, poly_vars, cur_scope, allow_inference, iter
                         )?,
                         Some(TokenKind::CloseParen) => self.consume_close_paren(source, iter)?,
                         _ => return Err(ParseError::new_error_str_at_pos(
                             source, iter.last_valid_pos(),
                             "unexpected token: expected typename or ')'"
                         )),
+                    }
                 },
                 ParseState::ParsedComma => {
                     // Allowed tokens: ident ( > >> )
                     match next {
                         Some(TokenKind::Ident) => self.consume_type_idents(
                             source, heap, symbols, wrapping_definition, poly_vars, cur_scope, allow_inference, iter
                         )?,
                         Some(TokenKind::OpenParen) => self.consume_open_paren(iter),
                         Some(TokenKind::CloseAngle) => self.consume_close_angle(source, iter)?,
                         Some(TokenKind::ShiftRight) => self.consume_double_close_angle(source, iter)?,
                         Some(TokenKind::CloseParen) => self.consume_close_paren(source, iter)?,
                         _ => return Err(ParseError::new_error_str_at_pos(
                             source, iter.last_valid_pos(),
                             "unexpected token: expected typename, '(', '>', '>>' or ')'"
                         ))
+                    }
+                }
+            }
+        }
         // If here then we have found the correct number of closing braces.
         // However we might still have any number of array postfixed
         if inside_angular_bracket.is_none() {
             while Some(TokenKind::OpenSquare) == iter.next() {
                 self.consume_square_parens(source, iter)?;
+            }
+        }
         // Type should be completed. But we still need to check the polymorphic
         // arguments and strip tuples with just one embedded type.
         let num_entries = self.entries.len();
         for el_index in 0..num_entries {
             let cur_element = &self.entries[el_index];
             // Peek ahead to see how many embedded types we have
             let mut encountered_embedded = 0;
             for peek_index in el_index + 1..num_entries {
                 let peek_element = &self.entries[peek_index];
                 if peek_element.depth == cur_element.depth + 1 {
                     encountered_embedded += 1;
                 } else if peek_element.depth <= cur_element.depth {
                     break;
+                }
+            }
             // If we're dealing with a tuple then we don't need to determine if
             // the number of embedded types is correct, we simply need to set it
             // to whatever what was encountered.
             if let ParserTypeVariant::Tuple(_) = cur_element.element.variant {
                 self.entries[el_index].element.variant = ParserTypeVariant::Tuple(encountered_embedded);
             } else {
                 let expected_embedded = cur_element.element.variant.num_embedded() as u32;
                 if expected_embedded != encountered_embedded {
                     if encountered_embedded == 0 {
                         // Every polymorphic argument should be inferred
                         if !allow_inference {
                             return Err(ParseError::new_error_str_at_span(
                                 source, cur_element.element.element_span,
                                 "type inference is not allowed here"
                             ));
+                        }
                         // Insert missing types
                         let inserted_span = cur_element.element.element_span;
                         let inserted_depth = cur_element.depth + 1;
                         self.entries.reserve(expected_embedded as usize);
                         self.entries.insert(el_index + 1, Entry{
                             element: ParserTypeElement{
                                 element_span: inserted_span,
                                 variant: ParserTypeVariant::Inferred,
                             },
                             depth: inserted_depth,
                         });
                     } else {
                         // Mismatch in number of embedded types
                         return Err(Self::construct_poly_arg_mismatch_error(
                             source, cur_element.element.element_span, allow_inference,
                             expected_embedded, encountered_embedded
                         ));
+                    }
+                }
+            }
+        }
         // Convert the results from parsing into the `ParserType`
         let mut elements = Vec::with_capacity(self.entries.len());
         debug_assert!(!self.entries.is_empty());
         for entry in self.entries.drain(..) {
             elements.push(entry.element)
+        }
         return Ok(ParserType{
             elements,
             full_span: InputSpan::from_positions(self.first_pos, self.last_pos),
         });
+    }
     /// Consumes an identifier that should resolve to some kind of type. There
     /// may be trailing '::' tokens, commas, or polymorphic arguments.
     fn consume_parser_type_ident(
         &self, iter: &mut TokenIter, symbols: &SymbolTable, poly_vars: &[Identifier],
         allow_inference: bool,
     ) -> Result<ParserTypeElement, ParserTypeError> {
     // --- Parsing Utilities
     #[inline]
     fn consume_type_idents(
         &mut self, source: &InputSource, heap: &Heap, symbols: &SymbolTable,
         wrapping_definition: DefinitionId, poly_vars: &[Identifier],
         cur_scope: SymbolScope, allow_inference: bool, iter: &mut TokenIter
     ) -> Result<(), ParseError> {
         let element = Self::consume_parser_type_element(
             iter, source, heap, symbols, wrapping_definition, poly_vars, cur_scope, allow_inference
         )?;
         let depth = self.cur_depth();
         self.last_pos = element.element_span.end;
         self.entries.push(Entry{ element, depth });
         self.parse_state = ParseState::TypeMaybePolyArgs;
         return Ok(());
+    }
     #[inline]
     fn consume_open_angle(&mut self, iter: &mut TokenIter) {
         // Note: open angular bracket is only consumed when we just parsed an
         //  ident-based type. So the last element of the `entries` array is the
         //  one that this angular bracket starts the polymorphic arguments for.
         let angle_start_pos = iter.next_start_position();
         let entry_index = (self.entries.len() - 1) as u32;
         self.push_depth(DepthKind::PolyArgs, entry_index, angle_start_pos);
         self.parse_state = ParseState::PolyArgStart;
         iter.consume();
+    }
     #[inline]
     fn push_depth(&mut self, kind: DepthKind, pos: InputPosition) {
         self.depths.push(DepthElement{ kind, pos });
     fn consume_close_angle(&mut self, source: &InputSource, iter: &mut TokenIter) -> Result<(), ParseError> {
         let (angle_start_pos, angle_end_pos) = iter.next_positions();
         self.last_pos = angle_end_pos;
         self.pop_depth(source, DepthKind::PolyArgs, angle_start_pos)?;
         self.parse_state = ParseState::TypeNeverPolyArgs;
         iter.consume();
         return Ok(())
+    }
     #[inline]
     fn pop_depth(&mut self, kind: DepthKind, pos: InputPosition) -> Result<(), ParserTypeError> {
     fn consume_double_close_angle(&mut self, source: &InputSource, iter: &mut TokenIter) -> Result<(), ParseError> {
         let (angle_start_pos, angle_end_pos) = iter.next_positions();
         self.last_pos = angle_end_pos;
         self.pop_depth(source, DepthKind::PolyArgs, angle_start_pos)?; // first '>' in '>>'.
         self.pop_depth(source, DepthKind::PolyArgs, angle_start_pos.with_offset(1))?; // second '>' in '>>'
         self.parse_state = ParseState::TypeNeverPolyArgs;
         iter.consume(); // consume once, '>>' is one token
         return Ok(())
+    }
     #[inline]
     fn consume_open_paren(&mut self, iter: &mut TokenIter) {
         let paren_start_pos = iter.next_start_position();
         let cur_depth = self.cur_depth();
         let entry_index = self.entries.len() as u32;
         self.entries.push(Entry{
             element: ParserTypeElement {
                 element_span: InputSpan::from_positions(paren_start_pos, paren_start_pos),
                 variant: ParserTypeVariant::Tuple(0),
             },
             depth: cur_depth,
         });
         self.push_depth(DepthKind::Tuple, entry_index, paren_start_pos);
         self.parse_state = ParseState::TupleStart;
         iter.consume();
+    }
     #[inline]
     fn consume_close_paren(&mut self, source: &InputSource, iter: &mut TokenIter) -> Result<(), ParseError> {
         let (paren_start_pos, paren_end_pos) = iter.next_positions();
         self.last_pos = paren_end_pos;
         let tuple_type_index = self.pop_depth(source, DepthKind::Tuple, paren_start_pos)?;
         self.entries[tuple_type_index as usize].element.element_span.end = paren_end_pos.with_offset(1);
         self.parse_state = ParseState::TypeNeverPolyArgs;
         iter.consume();
         return Ok(())
+    }
     #[inline]
     fn consume_comma(&mut self, iter: &mut TokenIter) {
         iter.consume();
         self.parse_state = ParseState::ParsedComma;
+    }
     #[inline]
     fn consume_square_parens(&mut self, source: &InputSource, iter: &mut TokenIter) -> Result<(), ParseError> {
         // Consume the opening square paren that forms the postfixed array type
         let array_start_pos = iter.next_start_position();
         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 (_, array_end_pos) = iter.next_positions();
         let array_span = InputSpan::from_positions(array_start_pos, array_end_pos);
         self.last_pos = array_end_pos;
         // In the language we put the array specification after a type, in the
         // type tree we need to make the array type the parent, so:
         let insert_depth = self.cur_depth();
         let insert_at = self.entries.iter().rposition(|e| e.depth == insert_depth).unwrap();
         let num_embedded = self.entries[insert_at].element.variant.num_embedded();
         self.entries.insert(insert_at, Entry{
             element: ParserTypeElement{
                 element_span: array_span,
                 variant: ParserTypeVariant::Array,
             },
             depth: insert_depth
         });
         // Need to increment the depth of the child types
         self.entries[insert_at + 1].depth += 1; // element we applied the array type to
         if num_embedded != 0 {
             for index in insert_at + 2..self.entries.len() {
                 let element = &mut self.entries[index];
                 if element.depth >= insert_depth + 1 {
                     element.depth += 1;
                 } else {
                     break;
+                }
+            }
+        }
         return Ok(())
+    }
     /// Consumes a namespaced identifier that should resolve to some kind of
     /// type. There may be commas or polymorphic arguments remaining after this
     /// function has finished.
     fn consume_parser_type_element(
         iter: &mut TokenIter, source: &InputSource, heap: &Heap, symbols: &SymbolTable,
         wrapping_definition: DefinitionId, poly_vars: &[Identifier],
         mut scope: SymbolScope, 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 as u32));
+                    }
+                }
                 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();
                     // Resolving scopes until we reach the intended type
                     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 a type but got a 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() {
                                     // If the type is imported in the module then notify the programmer
                                     // that imports do not leak outside of a module
                                     let type_name = String::from_utf8_lossy(type_text);
                                     let module_name = String::from_utf8_lossy(old_text);
                                     let suffix = if symbols.get_symbol_by_name(scope, type_text).is_some() {
                                         format!(
                                             ". The module '{}' does import '{}', but these imports are not visible to other modules",
                                             &module_name, &type_name
+                                        )
                                     } else {
                                         String::new()
                                     };
                                     let message = format!("unknown type '{}' in module '{}'{}", type_name, module_name, suffix);
                                     return Err(ParseError::new_error_at_span(source, next_span, message));
+                                }
                                 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 as u32));
                                 break;
+                            }
+                        }
+                    }
+                }
                 debug_assert!(type_kind.is_some());
                 type_kind.unwrap()
             },
         };
         Ok(ParserTypeElement{ element_span: type_span, variant })
+    }
     // --- Parsing Depth Management
     #[inline]
     fn push_depth(&mut self, kind: DepthKind, entry_index: u32, pos: InputPosition) {
         self.depths.push(DepthElement{ kind, entry_index, pos });
+    }
     #[inline]
     fn pop_depth(&mut self, source: &InputSource, kind: DepthKind, pos: InputPosition) -> Result<u32, ParseError> {
         if self.depths.is_empty() {
             // More closing parens than opening ones
             let message = match kind {
                 DepthKind::Tuple => "unmatched ')'",
                 DepthKind::PolyArgs => "unmatched '>'",
             };
-            return Err(ParserTypeError::MessageAt(pos, message))
+            return Err(ParseError::new_error_str_at_pos(source, pos, message))
+        }
         let last = *self.depths.last().unwrap();
         if last != kind {
             // Wrong kind of paren
             let (message_second) = match kind {
                 DepthKind::Tuple => "unexpected closing"
+            }
         let last = self.depths.last().unwrap();
         if last.kind != kind {
             // Wrong kind of closing parens
             let (encountered_message, matching_message) = match kind {
                 DepthKind::Tuple => (
                     "unexpected closing ')'",
                     "expected a '>' to match this '<'"
                 ),
                 DepthKind::PolyArgs => (
                     "unexpected closing '>'",
                     "expected a ')' to match this '('"
                 ),
             };
             return Err(
                 ParseError::new_error_str_at_pos(source, pos, encountered_message)
                     .with_info_str_at_pos(source, last.pos, matching_message)
             );
+        }
         let popped = self.depths.pop().unwrap();
         return Ok(popped.entry_index);
+    }
     #[inline]
     fn cur_depth(&self) -> i32 {
         return self.depths.len() as i32;
+    }
     // --- Small Utilities
     fn construct_poly_arg_mismatch_error(
         source: &InputSource, span: InputSpan, allow_inference: bool,
         num_expected: u32, num_encountered: u32
     ) -> ParseError {
         let type_name = String::from_utf8_lossy(source.section_at_span(span));
         fn polymorphic_name_text(num: u32) -> &'static str {
             if num == 1 { "polymorphic argument" } else { "polymorphic arguments" }
+        }
         fn were_or_was(num: u32) -> &'static str {
             if num == 1 { "was" } else { "were" }
+        }
         if num_expected == 0 {
             return ParseError::new_error_at_span(
                 source, span,
                 format!(
                     "the type '{}' is not polymorphic, yet {} {} {} provided",
                     type_name, num_encountered, polymorphic_name_text(num_encountered),
                     were_or_was(num_encountered)
+                )
             );
+        }
         let maybe_infer_text = if allow_inference {
             " (or none, to perform implicit type inference)"
         } else {
             ""
         };
         return ParseError::new_error_at_span(
             source, span,
             format!(
                 "expected {} {}{} for the type '{}', but {} {} provided",
                 num_expected, polymorphic_name_text(num_expected),
                 maybe_infer_text, type_name, num_encountered,
                 were_or_was(num_encountered)
+            )
         );
+    }
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)