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

Changeset - 87aa65714efe

Parent rev.

Child rev.

[Not reviewed]

0 17 0

MH - 4 years ago 2021-05-04 11:13:24
contact@maxhenger.nl

back to a compiling project

17 files changed with 641 insertions and 546 deletions:

src/collections/scoped_buffer.rs

src/collections/string_pool.rs

src/protocol/ast.rs

src/protocol/ast_printer.rs

src/protocol/eval.rs

src/protocol/input_source.rs

src/protocol/parser/pass_definitions.rs

src/protocol/parser/pass_imports.rs

src/protocol/parser/pass_symbols.rs

src/protocol/parser/pass_tokenizer.rs

src/protocol/parser/pass_typing.rs

163

194

src/protocol/parser/pass_validation_linking.rs

src/protocol/parser/symbol_table.rs

src/protocol/parser/token_parsing.rs

src/protocol/parser/tokens.rs

src/protocol/parser/type_table.rs

src/protocol/tests/utils.rs

0 comments (0 inline, 0 general)

src/collections/scoped_buffer.rs

➞

Show inline comments

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

src/collections/string_pool.rs

➞

Show inline comments

 use std::ptr::null_mut;
 use std::hash::{Hash, Hasher};
 use std::marker::PhantomData;
 use std::fmt::{Debug, Display, Result as FmtResult};
 use crate::common::Formatter;
 const SLAB_SIZE: usize = u16::MAX as usize;
 #[derive(Clone)]
 pub struct StringRef<'a> {
     data: *const u8,
     length: usize,
     _phantom: PhantomData<&'a [u8]>,
+}
 // As the StringRef is an immutable thing:
 unsafe impl Sync for StringRef<'_> {}
 unsafe impl Send for StringRef<'_> {}
 impl<'a> StringRef<'a> {
     /// `new` constructs a new StringRef whose data is not owned by the
     /// `StringPool`, hence cannot have a `'static` lifetime.
     pub(crate) fn new(data: &'a [u8]) -> StringRef<'a> {
         // This is an internal (compiler) function: so debug_assert that the
         // string is valid ascii. Most commonly the input will come from the
@@ @@ -35,27 +41,39 @@ impl<'a> StringRef<'a> { @@
         unsafe {
             std::slice::from_raw_parts::<'a, u8>(self.data, self.length)
+        }
+    }
+}
 impl<'a> Debug for StringRef<'a> {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         f.write_str("StringRef{ value: ")?;
         f.write_str(self.as_str())?;
         f.write_str(" }")
+    }
+}
 impl<'a> Display for StringRef<'a> {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         f.write_str(self.as_str())
+    }
+}
 impl PartialEq for StringRef<'_> {
     fn eq(&self, other: &StringRef) -> bool {
         self.as_str() == other.as_str()
+    }
+}
 impl Eq for StringRef<'_> {}
 impl Hash for StringRef<'_> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         unsafe{
         state.write(self.as_bytes());
+    }
+}
+}
 struct StringPoolSlab {
     prev: *mut StringPoolSlab,
     data: Vec<u8>,
     remaining: usize,
+}

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -55,12 +55,13 @@ macro_rules! define_aliased_ast_id { @@
 macro_rules! define_new_ast_id {
     // Variant where we just defined the new type, without any indexing
     ($name:ident, $parent:ty) => {
         #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
         pub struct $name (pub(crate) $parent);
         #[allow(dead_code)]
         impl $name {
             pub(crate) fn new_invalid() -> Self     { Self(<$parent>::new_invalid()) }
             pub(crate) fn is_invalid(&self) -> bool { self.0.is_invalid() }
             pub fn upcast(self) -> $parent          { self.0 }
+        }
     };
@@ @@ -353,13 +354,13 @@ impl PartialEq for Identifier { @@
 impl Display for Identifier {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.value.as_str())
+    }
+}
-#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq)]
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ParserTypeVariant {
     // Basic builtin
     Message,
     Bool,
     UInt8, UInt16, UInt32, UInt64,
     SInt8, SInt16, SInt32, SInt64,
@@ @@ -376,22 +377,29 @@ pub enum ParserTypeVariant { @@
     PolymorphicArgument(DefinitionId, usize), // usize = index into polymorphic variables
     Definition(DefinitionId, usize), // usize = number of following subtypes
+}
 impl ParserTypeVariant {
     pub(crate) fn num_embedded(&self) -> usize {
         use ParserTypeVariant::*;
         match self {
             x if *x <= ParserTypeVariant::Inferred => 0,
             x if *x <= ParserTypeVariant::Output => 1,
             ParserTypeVariant::PolymorphicArgument(_, _) => 0,
             ParserTypeVariant::Definition(_, num) => num,
             _ => { debug_assert!(false); 0 },
             Message | Bool |
             UInt8 | UInt16 | UInt32 | UInt64 |
             SInt8 | SInt16 | SInt32 | SInt64 |
             Character | String | IntegerLiteral |
             Inferred | PolymorphicArgument(_, _) =>
 ,
             Array | Input | Output =>
 ,
             Definition(_, num) => *num,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct ParserTypeElement {
     // TODO: @cleanup, do we ever need the span of a user-defined type after
     //  constructing it?
     pub full_span: InputSpan, // full span of type, including any polymorphic arguments
     pub variant: ParserTypeVariant,
+}
@@ @@ -402,12 +410,67 @@ pub struct ParserTypeElement { @@
 /// not yet determined).
 #[derive(Debug, Clone)]
 pub struct ParserType {
     pub elements: Vec<ParserTypeElement>
+}
 impl ParserType {
     pub(crate) fn iter_embedded(&self, parent_idx: usize) -> ParserTypeIter {
         ParserTypeIter::new(&self.elements, parent_idx)
+    }
+}
 /// Iterator over the embedded elements of a specific element.
 pub struct ParserTypeIter<'a> {
     pub elements: &'a [ParserTypeElement],
     pub cur_embedded_idx: usize,
+}
 impl<'a> ParserTypeIter<'a> {
     fn new(elements: &'a [ParserTypeElement], parent_idx: usize) -> Self {
         debug_assert!(parent_idx < elements.len(), "parent index exceeds number of elements in ParserType");
         if elements[0].variant.num_embedded() == 0 {
             // Parent element does not have any embedded types, place
             // `cur_embedded_idx` at end so we will always return `None`
             Self{ elements, cur_embedded_idx: elements.len() }
         } else {
             // Parent element has an embedded type
             Self{ elements, cur_embedded_idx: parent_idx + 1 }
+        }
+    }
+}
 impl<'a> Iterator for ParserTypeIter<'a> {
     type Item = &'a [ParserTypeElement];
     fn next(&mut self) -> Option<Self::Item> {
         let elements_len = self.elements.len();
         if self.cur_embedded_idx >= elements_len {
             return None;
+        }
         // Seek to the end of the subtree
         let mut depth = 1;
         let start_element = self.cur_embedded_idx;
         while self.cur_embedded_idx < elements_len {
             let cur_element = &self.elements[self.cur_embedded_idx];
             let depth_change = cur_element.variant.num_embedded() as i32 - 1;
             depth += depth_change;
             debug_assert!(depth >= 0, "illegally constructed ParserType: {:?}", self.elements);
             self.cur_embedded_idx += 1;
             if depth == 0 {
                 break;
+            }
+        }
         debug_assert!(depth == 0, "illegally constructed ParserType: {:?}", self.elements);
         return Some(&self.elements[start_element..self.cur_embedded_idx]);
+    }
+}
 /// Specifies whether the symbolic type points to an actual user-defined type,
 /// or whether it points to a polymorphic argument within the definition (e.g.
 /// a defined variable `T var` within a function `int func<T>()`
 #[derive(Debug, Clone)]
 pub enum SymbolicParserTypeVariant {
     Definition(DefinitionId),
@@ @@ -773,25 +836,23 @@ impl Definition { @@
             Definition::Union(def) => &def.identifier,
             Definition::Component(def) => &def.identifier,
             Definition::Function(def) => &def.identifier,
+        }
+    }
     pub fn parameters(&self) -> &Vec<ParameterId> {
         // TODO: Fix this
         static EMPTY_VEC: Vec<ParameterId> = Vec::new();
         match self {
             Definition::Component(com) => &com.parameters,
             Definition::Function(fun) => &fun.parameters,
-            _ => &EMPTY_VEC,
+            _ => panic!("cannot retrieve parameters for {:?}", self),
+        }
+    }
     pub fn body(&self) -> BlockStatementId {
         match self {
             Definition::Component(com) => com.body,
             Definition::Function(fun) => fun.body,
-            _ => panic!("cannot retrieve body (for EnumDefinition/UnionDefinition or StructDefinition)")
+            _ => panic!("cannot retrieve body for {:?}", self),
+        }
+    }
     pub fn poly_vars(&self) -> &Vec<Identifier> {
         match self {
             Definition::Struct(def) => &def.poly_vars,
             Definition::Enum(def) => &def.poly_vars,
@@ @@ -1206,13 +1267,13 @@ impl BlockStatement { @@
             Scope::Synchronous((parent, _)) => {
                 // It is always the case that when this function is called,
                 // the parent of a synchronous statement is a block statement:
                 // nested synchronous statements are flagged illegal,
                 // and that happens before resolving variables that
                 // creates the parent_scope references in the first place.
-                Some(h[parent].parent_scope(h).unwrap().to_block())
                 Some(h[parent].parent_scope.unwrap().to_block())
+            }
             Scope::Regular(parent) => {
                 // A variable scope is either a definition, sync, or block.
                 Some(parent)
+            }
+        }
@@ @@ -1425,12 +1486,21 @@ pub enum ExpressionParent { @@
     Return(ReturnStatementId),
     New(NewStatementId),
     ExpressionStmt(ExpressionStatementId),
     Expression(ExpressionId, u32) // index within expression (e.g LHS or RHS of expression)
+}
 impl ExpressionParent {
     pub fn is_new(&self) -> bool {
         match self {
             ExpressionParent::New(_) => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub enum Expression {
     Assignment(AssignmentExpression),
     Binding(BindingExpression),
     Conditional(ConditionalExpression),
     Binary(BinaryExpression),
@@ @@ -1759,20 +1829,20 @@ pub struct SelectExpression { @@
 #[derive(Debug, Clone)]
 pub struct CallExpression {
     pub this: CallExpressionId,
     // Phase 1: parser
     pub span: InputSpan,
     pub parser_type: ParserType, // of the function call
+    pub parser_type: ParserType, // of the function call, not the return type
     pub method: Method,
     pub arguments: Vec<ExpressionId>,
     pub definition: DefinitionId,
     // Phase 2: linker
     pub parent: ExpressionParent,
     // Phase 3: type checking
     pub concrete_type: ConcreteType,
+    pub concrete_type: ConcreteType, // of the return type
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Method {
     // Builtin
     Get,

src/protocol/ast_printer.rs

➞

Show inline comments

 #![allow(dead_code)]
 use std::fmt::{Debug, Display, Write};
 use std::io::Write as IOWrite;
 use super::ast::*;
 use super::token_parsing::*;
@@ @@ -237,33 +239,30 @@ impl ASTWriter { @@
             Import::Module(import) => {
                 self.kv(indent).with_id(PREFIX_IMPORT_ID, import.this.index)
                     .with_s_key("ImportModule");
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&import.module);
                 self.kv(indent2).with_s_key("Alias").with_identifier_val(&import.alias);
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(import.module_id.as_ref().map(|v| &v.index));
                 self.kv(indent2).with_s_key("Target").with_disp_val(&import.module_id.index);
             },
             Import::Symbols(import) => {
                 self.kv(indent).with_id(PREFIX_IMPORT_ID, import.this.index)
                     .with_s_key("ImportSymbol");
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&import.module);
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(import.module_id.as_ref().map(|v| &v.index));
                 self.kv(indent2).with_s_key("Target").with_disp_val(&import.module_id.index);
                 self.kv(indent2).with_s_key("Symbols");
                 let indent3 = indent2 + 1;
                 let indent4 = indent3 + 1;
                 for symbol in &import.symbols {
                     self.kv(indent3).with_s_key("AliasedSymbol");
                     self.kv(indent4).with_s_key("Name").with_identifier_val(&symbol.name);
                     self.kv(indent4).with_s_key("Alias").with_opt_identifier_val(symbol.alias.as_ref());
                     self.kv(indent4).with_s_key("Definition")
                         .with_opt_disp_val(symbol.definition_id.as_ref().map(|v| &v.index));
                     self.kv(indent4).with_s_key("Definition").with_disp_val(&symbol.definition_id.index);
+                }
+            }
+        }
+    }
     //--------------------------------------------------------------------------
@@ @@ -523,14 +522,16 @@ impl ASTWriter { @@
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Return(stmt) => {
                 self.kv(indent).with_id(PREFIX_RETURN_STMT_ID, stmt.this.0.index)
                     .with_s_key("Return");
                 self.kv(indent2).with_s_key("Expression");
                 self.write_expr(heap, stmt.expression, indent3);
                 self.kv(indent2).with_s_key("Expressions");
                 for expr_id in &stmt.expressions {
                     self.write_expr(heap, *expr_id, indent3);
+                }
             },
             Statement::Goto(stmt) => {
                 self.kv(indent).with_id(PREFIX_GOTO_STMT_ID, stmt.this.0.index)
                     .with_s_key("Goto");
                 self.kv(indent2).with_s_key("Label").with_identifier_val(&stmt.label);
                 self.kv(indent2).with_s_key("Target")
@@ @@ -678,23 +679,25 @@ impl ASTWriter { @@
                 let val = self.kv(indent2).with_s_key("Value");
                 match &expr.value {
                     Literal::Null => { val.with_s_val("null"); },
                     Literal::True => { val.with_s_val("true"); },
                     Literal::False => { val.with_s_val("false"); },
                     Literal::Character(data) => { val.with_disp_val(data); },
                     Literal::String(data) => { val.with_disp_val(data.as_str()); },
                     Literal::String(data) => {
                         // Stupid hack
                         let string = String::from(data.as_str());
                         val.with_disp_val(&string);
                     },
                     Literal::Integer(data) => { val.with_debug_val(data); },
                     Literal::Struct(data) => {
                         val.with_s_val("Struct");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("ParserType")
                             .with_custom_val(|t| write_parser_type(t, heap, &data.parser_type));
                         self.kv(indent3).with_s_key("Definition").with_custom_val(|s| {
                             write_option(s, data.definition.as_ref().map(|v| &v.index));
                         });
                         self.kv(indent3).with_s_key("Definition").with_disp_val(&data.definition.index);
                         for field in &data.fields {
                             self.kv(indent3).with_s_key("Field");
                             self.kv(indent4).with_s_key("Name").with_identifier_val(&field.identifier);
                             self.kv(indent4).with_s_key("Index").with_disp_val(&field.field_idx);
                             self.kv(indent4).with_s_key("ParserType");
@@ @@ -703,26 +706,22 @@ impl ASTWriter { @@
                     },
                     Literal::Enum(data) => {
                         val.with_s_val("Enum");
                         self.kv(indent3).with_s_key("ParserType")
                             .with_custom_val(|t| write_parser_type(t, heap, &data.parser_type));
                         self.kv(indent3).with_s_key("Definition").with_custom_val(|s| {
                             write_option(s, data.definition.as_ref().map(|v| &v.index))
                         });
                         self.kv(indent3).with_s_key("Definition").with_disp_val(&data.definition.index);
                         self.kv(indent3).with_s_key("VariantIdx").with_disp_val(&data.variant_idx);
                     },
                     Literal::Union(data) => {
                         val.with_s_val("Union");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("ParserType")
                             .with_custom_val(|t| write_parser_type(t, heap, &data.parser_type));
                         self.kv(indent3).with_s_key("Definition").with_custom_val(|s| {
                             write_option(s, data.definition.as_ref().map(|v| &v.index));
                         });
                         self.kv(indent3).with_s_key("Definition").with_disp_val(&data.definition.index);
                         self.kv(indent3).with_s_key("VariantIdx").with_disp_val(&data.variant_idx);
                         for value in &data.values {
                             self.kv(indent3).with_s_key("Value");
                             self.write_expr(heap, *value, indent4);
+                        }
                 element_idx = write_element(target, heap, t, element_idx + 1);
                 target.push('>');
             },
             PTV::PolymorphicArgument(definition_id, arg_idx) => {
                 let definition = &heap[*definition_id];
                 let poly_var = &definition.poly_vars()[*arg_idx].value;
-                target.write_str(poly_var.as_str());
+                target.push_str(poly_var.as_str());
             },
             PTV::Definition(definition_id, num_embedded) => {
                 let definition = &heap[*definition_id];
                 let definition_ident = definition.identifier().value.as_str();
-                target.write_str(definition_ident);
+                target.push_str(definition_ident);
                 let num_embedded = *num_embedded;
                 if num_embedded != 0 {
                     target.push('<');
                     for embedded_idx in 0..num_embedded {
                         if embedded_idx != 0 {
         element_idx
+    }
     write_element(target, heap, t, 0);
+}
 // TODO: @Cleanup, this is littered at three places in the codebase
 fn write_concrete_type(target: &mut String, heap: &Heap, def_id: DefinitionId, t: &ConcreteType) {
     use ConcreteTypePart as CTP;
     fn write_concrete_part(target: &mut String, heap: &Heap, def_id: DefinitionId, t: &ConcreteType, mut idx: usize) -> usize {
         if idx >= t.parts.len() {
             return idx;
                 target.push_str(poly_var_ident.value.as_str());
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
             },
             CTP::Void => target.push_str("void"),
             CTP::Message => target.push_str("msg"),
             CTP::Bool => target.push_str("bool"),
             CTP::Byte => target.push_str("byte"),
             CTP::Short => target.push_str("short"),
             CTP::Int => target.push_str("int"),
             CTP::Long => target.push_str("long"),
             CTP::String => target.push_str("string"),
             CTP::UInt8 => target.push_str(KW_TYPE_UINT8_STR),
             CTP::UInt16 => target.push_str(KW_TYPE_UINT16_STR),
             CTP::UInt32 => target.push_str(KW_TYPE_UINT32_STR),
             CTP::UInt64 => target.push_str(KW_TYPE_UINT64_STR),
             CTP::SInt8 => target.push_str(KW_TYPE_SINT8_STR),
             CTP::SInt16 => target.push_str(KW_TYPE_SINT16_STR),
             CTP::SInt32 => target.push_str(KW_TYPE_SINT32_STR),
             CTP::SInt64 => target.push_str(KW_TYPE_SINT64_STR),
             CTP::Character => target.push_str(KW_TYPE_CHAR_STR),
             CTP::String => target.push_str(KW_TYPE_STRING_STR),
             CTP::Array => {
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
                 target.push_str("[]");
             },
             CTP::Slice => {
                 idx = write_concrete_part(target, heap, def_id, t, idx + 1);
     *target = match parent {
         EP::None => String::from("None"),
         EP::If(id) => format!("IfStmt({})", id.0.index),
         EP::While(id) => format!("WhileStmt({})", id.0.index),
         EP::Return(id) => format!("ReturnStmt({})", id.0.index),
         EP::Assert(id) => format!("AssertStmt({})", id.0.index),
         EP::New(id) => format!("NewStmt({})", id.0.index),
         EP::ExpressionStmt(id) => format!("ExprStmt({})", id.0.index),
         EP::Expression(id, idx) => format!("Expr({}, {})", id.index, idx)
     };
+}
@@ \ No newline at end of file @@

src/protocol/eval.rs

➞

Show inline comments

@@ @@ -21,16 +21,16 @@ const MESSAGE_MAX_LENGTH: i64 = SHORT_MAX; @@
 const ONE: Value = Value::Byte(ByteValue(1));
 // TODO: All goes one day anyway, so dirty typechecking hack
 trait ValueImpl {
     fn exact_type(&self) -> Type;
-    fn is_type_compatible(&self, h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible(&self, h: &Heap, t: &[ParserTypeElement]) -> bool {
         Self::is_type_compatible_hack(h, t)
+    }
-    fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool;
+    fn is_type_compatible_hack(h: &Heap, t: &[ParserTypeElement]) -> bool;
+}
 #[derive(Debug, Clone)]
 pub enum Value {
     Unassigned,
     Input(InputValue),
@@ @@ -90,13 +90,13 @@ impl Value { @@
+            }
             Literal::Character(_data) => unimplemented!(),
             Literal::String(_data) => unimplemented!(),
             Literal::Struct(_data) => unimplemented!(),
             Literal::Enum(_data) => unimplemented!(),
             Literal::Union(_data) => unimplemented!(),
-            Literal::Array(expressions) => unimplemented!(),
+            Literal::Array(_expressions) => unimplemented!(),
+        }
+    }
     fn set(&mut self, index: &Value, value: &Value) -> Option<Value> {
         // The index must be of integer type, and non-negative
         let the_index: usize;
         match index {
@@ @@ -848,13 +848,13 @@ impl ValueImpl for Value { @@
             Value::ByteArray(val) => val.exact_type(),
             Value::ShortArray(val) => val.exact_type(),
             Value::IntArray(val) => val.exact_type(),
             Value::LongArray(val) => val.exact_type(),
+        }
+    }
-    fn is_type_compatible(&self, h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible(&self, h: &Heap, t: &[ParserTypeElement]) -> bool {
         match self {
             Value::Unassigned => true,
             Value::Input(_) => InputValue::is_type_compatible_hack(h, t),
             Value::Output(_) => OutputValue::is_type_compatible_hack(h, t),
             Value::Message(_) => MessageValue::is_type_compatible_hack(h, t),
             Value::Boolean(_) => BooleanValue::is_type_compatible_hack(h, t),
@@ @@ -869,13 +869,13 @@ impl ValueImpl for Value { @@
             Value::ByteArray(_) => ByteArrayValue::is_type_compatible_hack(h, t),
             Value::ShortArray(_) => ShortArrayValue::is_type_compatible_hack(h, t),
             Value::IntArray(_) => InputArrayValue::is_type_compatible_hack(h, t),
             Value::LongArray(_) => LongArrayValue::is_type_compatible_hack(h, t),
+        }
+    }
-    fn is_type_compatible_hack(_h: &Heap, _t: &ParserType) -> bool { false }
+    fn is_type_compatible_hack(_h: &Heap, _t: &[ParserTypeElement]) -> bool { false }
+}
 impl Display for Value {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         let disp: &dyn Display;
         match self {
@@ @@ -911,15 +911,15 @@ impl Display for InputValue { @@
+}
 impl ValueImpl for InputValue {
     fn exact_type(&self) -> Type {
         Type::INPUT
+    }
-    fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible_hack(_h: &Heap, t: &[ParserTypeElement]) -> bool {
         use ParserTypeVariant::*;
         match &t.variant {
+        match &t[0].variant {
             Input | Inferred | Definition(_, _) => true,
             _ => false,
+        }
+    }
+}
@@ @@ -933,15 +933,15 @@ impl Display for OutputValue { @@
+}
 impl ValueImpl for OutputValue {
     fn exact_type(&self) -> Type {
         Type::OUTPUT
+    }
-    fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible_hack(_h: &Heap, t: &[ParserTypeElement]) -> bool {
         use ParserTypeVariant::*;
-        match &t.elements[0].variant {
         match &t[0].variant {
             Output | Inferred | Definition(_, _) => true,
             _ => false,
+        }
+    }
+}
@@ @@ -965,15 +965,15 @@ impl Display for MessageValue { @@
+}
 impl ValueImpl for MessageValue {
     fn exact_type(&self) -> Type {
         Type::MESSAGE
+    }
-    fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible_hack(_h: &Heap, t: &[ParserTypeElement]) -> bool {
         use ParserTypeVariant::*;
-        match &t.elements[0].variant {
         match &t[0].variant {
             Message | Inferred | Definition(_, _) => true,
             _ => false,
+        }
+    }
+}
@@ @@ -987,15 +987,15 @@ impl Display for BooleanValue { @@
+}
 impl ValueImpl for BooleanValue {
     fn exact_type(&self) -> Type {
         Type::BOOLEAN
+    }
-    fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible_hack(_h: &Heap, t: &[ParserTypeElement]) -> bool {
         use ParserTypeVariant::*;
-        match t.elements[0].variant {
+        match &t[0].variant {
             Definition(_, _) | Inferred | Bool |
             UInt8 | UInt16 | UInt32 | UInt64 |
             SInt8 | SInt16 | SInt32 | SInt64 => true,
             _ => false
+        }
+    }
@@ @@ -1011,15 +1011,15 @@ impl Display for ByteValue { @@
+}
 impl ValueImpl for ByteValue {
     fn exact_type(&self) -> Type {
         Type::BYTE
+    }
-    fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible_hack(_h: &Heap, t: &[ParserTypeElement]) -> bool {
         use ParserTypeVariant::*;
-        match t.elements[0].variant {
+        match &t[0].variant {
             Definition(_, _) | Inferred |
             UInt8 | UInt16 | UInt32 | UInt64 |
             SInt8 | SInt16 | SInt32 | SInt64 => true,
             _ => false
+        }
+    }
@@ @@ -1035,15 +1035,15 @@ impl Display for ShortValue { @@
+}
 impl ValueImpl for ShortValue {
     fn exact_type(&self) -> Type {
         Type::SHORT
+    }
-    fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible_hack(_h: &Heap, t: &[ParserTypeElement]) -> bool {
         use ParserTypeVariant::*;
-        match t.elements[0].variant {
+        match &t[0].variant {
             Definition(_, _) | Inferred |
             UInt16 | UInt32 | UInt64 |
             SInt16 | SInt32 | SInt64=> true,
             _ => false
+        }
+    }
@@ @@ -1059,15 +1059,15 @@ impl Display for IntValue { @@
+}
 impl ValueImpl for IntValue {
     fn exact_type(&self) -> Type {
         Type::INT
+    }
-    fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible_hack(_h: &Heap, t: &[ParserTypeElement]) -> bool {
         use ParserTypeVariant::*;
-        match t.elements[0].variant {
         match t[0].variant {
             Definition(_, _) | Inferred |
             UInt32 | UInt64 |
             SInt32 | SInt64 => true,
             _ => false
+        }
+    }
@@ @@ -1083,24 +1083,24 @@ impl Display for LongValue { @@
+}
 impl ValueImpl for LongValue {
     fn exact_type(&self) -> Type {
         Type::LONG
+    }
-    fn is_type_compatible_hack(_h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible_hack(_h: &Heap, t: &[ParserTypeElement]) -> bool {
         use ParserTypeVariant::*;
-        match &t.elements[0].variant {
         match &t[0].variant {
             UInt64 | SInt64 | Inferred | Definition(_, _) => true,
             _ => false,
+        }
+    }
+}
 fn get_array_inner(t: &ParserType) -> Option<ParserTypeVariant> {
     if t.elements[0].variant == ParserTypeVariant::Array {
         return Some(t.elements[1].variant.clone())
 fn get_array_inner(t: &[ParserTypeElement]) -> Option<&[ParserTypeElement]> {
     if t[0].variant == ParserTypeVariant::Array {
         return Some(&t[1..])
     } else {
         return None;
+    }
+}
 #[derive(Debug, Clone)]
@@ @@ -1122,15 +1122,15 @@ impl Display for InputArrayValue { @@
+}
 impl ValueImpl for InputArrayValue {
     fn exact_type(&self) -> Type {
         Type::INPUT_ARRAY
+    }
-    fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible_hack(h: &Heap, t: &[ParserTypeElement]) -> bool {
         get_array_inner(t)
-            .map(|v| InputValue::is_type_compatible_hack(h, &h[v]))
             .map(|v| InputValue::is_type_compatible_hack(h, v))
             .unwrap_or(false)
+    }
+}
 #[derive(Debug, Clone)]
 pub struct OutputArrayValue(Vec<OutputValue>);
@@ @@ -1151,15 +1151,15 @@ impl Display for OutputArrayValue { @@
+}
 impl ValueImpl for OutputArrayValue {
     fn exact_type(&self) -> Type {
         Type::OUTPUT_ARRAY
+    }
-    fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible_hack(h: &Heap, t: &[ParserTypeElement]) -> bool {
         get_array_inner(t)
-            .map(|v| OutputValue::is_type_compatible_hack(h, &h[v]))
             .map(|v| OutputValue::is_type_compatible_hack(h, v))
             .unwrap_or(false)
+    }
+}
 #[derive(Debug, Clone)]
 pub struct MessageArrayValue(Vec<MessageValue>);
@@ @@ -1180,15 +1180,15 @@ impl Display for MessageArrayValue { @@
+}
 impl ValueImpl for MessageArrayValue {
     fn exact_type(&self) -> Type {
         Type::MESSAGE_ARRAY
+    }
-    fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible_hack(h: &Heap, t: &[ParserTypeElement]) -> bool {
         get_array_inner(t)
-            .map(|v| MessageValue::is_type_compatible_hack(h, &h[v]))
             .map(|v| MessageValue::is_type_compatible_hack(h, v))
             .unwrap_or(false)
+    }
+}
 #[derive(Debug, Clone)]
 pub struct BooleanArrayValue(Vec<BooleanValue>);
@@ @@ -1209,15 +1209,15 @@ impl Display for BooleanArrayValue { @@
+}
 impl ValueImpl for BooleanArrayValue {
     fn exact_type(&self) -> Type {
         Type::BOOLEAN_ARRAY
+    }
-    fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible_hack(h: &Heap, t: &[ParserTypeElement]) -> bool {
         get_array_inner(t)
-            .map(|v| BooleanValue::is_type_compatible_hack(h, &h[v]))
             .map(|v| BooleanValue::is_type_compatible_hack(h, v))
             .unwrap_or(false)
+    }
+}
 #[derive(Debug, Clone)]
 pub struct ByteArrayValue(Vec<ByteValue>);
@@ @@ -1238,15 +1238,15 @@ impl Display for ByteArrayValue { @@
+}
 impl ValueImpl for ByteArrayValue {
     fn exact_type(&self) -> Type {
         Type::BYTE_ARRAY
+    }
-    fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible_hack(h: &Heap, t: &[ParserTypeElement]) -> bool {
         get_array_inner(t)
-            .map(|v| ByteValue::is_type_compatible_hack(h, &h[v]))
             .map(|v| ByteValue::is_type_compatible_hack(h, v))
             .unwrap_or(false)
+    }
+}
 #[derive(Debug, Clone)]
 pub struct ShortArrayValue(Vec<ShortValue>);
@@ @@ -1267,15 +1267,15 @@ impl Display for ShortArrayValue { @@
+}
 impl ValueImpl for ShortArrayValue {
     fn exact_type(&self) -> Type {
         Type::SHORT_ARRAY
+    }
-    fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible_hack(h: &Heap, t: &[ParserTypeElement]) -> bool {
         get_array_inner(t)
-            .map(|v| ShortValue::is_type_compatible_hack(h, &h[v]))
             .map(|v| ShortValue::is_type_compatible_hack(h, v))
             .unwrap_or(false)
+    }
+}
 #[derive(Debug, Clone)]
 pub struct IntArrayValue(Vec<IntValue>);
@@ @@ -1296,15 +1296,15 @@ impl Display for IntArrayValue { @@
+}
 impl ValueImpl for IntArrayValue {
     fn exact_type(&self) -> Type {
         Type::INT_ARRAY
+    }
-    fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible_hack(h: &Heap, t: &[ParserTypeElement]) -> bool {
         get_array_inner(t)
-            .map(|v| IntValue::is_type_compatible_hack(h, &h[v]))
             .map(|v| IntValue::is_type_compatible_hack(h, v))
             .unwrap_or(false)
+    }
+}
 #[derive(Debug, Clone)]
 pub struct LongArrayValue(Vec<LongValue>);
@@ @@ -1325,15 +1325,15 @@ impl Display for LongArrayValue { @@
+}
 impl ValueImpl for LongArrayValue {
     fn exact_type(&self) -> Type {
         Type::LONG_ARRAY
+    }
-    fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool {
+    fn is_type_compatible_hack(h: &Heap, t: &[ParserTypeElement]) -> bool {
         get_array_inner(t)
-            .map(|v| LongValue::is_type_compatible_hack(h, &h[v]))
             .map(|v| LongValue::is_type_compatible_hack(h, v))
             .unwrap_or(false)
+    }
+}
 #[derive(Debug, Clone)]
 struct Store {
@@ @@ -1346,13 +1346,13 @@ impl Store { @@
     fn initialize(&mut self, h: &Heap, var: VariableId, value: Value) {
         // Ensure value is compatible with type of variable
         let parser_type = match &h[var] {
             Variable::Local(v) => &v.parser_type,
             Variable::Parameter(v) => &v.parser_type,
         };
         assert!(value.is_type_compatible(h, parser_type));
+        assert!(value.is_type_compatible(h, &parser_type.elements));
         // Overwrite mapping
         self.map.insert(var, value.clone());
+    }
     fn update(
         &mut self,
         h: &Heap,
@@ @@ -1365,13 +1365,13 @@ impl Store { @@
                 let var = var.declaration.unwrap();
                 // Ensure value is compatible with type of variable
                 let parser_type = match &h[var] {
                     Variable::Local(v) => &v.parser_type,
                     Variable::Parameter(v) => &v.parser_type
                 };
                 assert!(value.is_type_compatible(h, parser_type));
+                assert!(value.is_type_compatible(h, &parser_type.elements));
                 // Overwrite mapping
                 self.map.insert(var, value.clone());
                 Ok(value)
+            }
             Expression::Indexing(indexing) => {
                 // Evaluate index expression, which must be some integral type
@@ @@ -1455,13 +1455,13 @@ impl Store { @@
                         self.update(h, ctx, expr.left, old.minus(&value))?;
+                    }
                     _ => unimplemented!("{:?}", expr),
+                }
                 Ok(value)
+            }
-            Expression::Binding(expr) => {
+            Expression::Binding(_expr) => {
                 unimplemented!("eval binding expression");
+            }
             Expression::Conditional(expr) => {
                 let test = self.eval(h, ctx, expr.test)?;
                 if test.as_boolean().0 {
                     self.eval(h, ctx, expr.true_expression)
@@ @@ -1558,14 +1558,28 @@ impl Store { @@
+                    }
+                }
                 Method::Create => {
                     assert_eq!(1, expr.arguments.len());
                     let length = self.eval(h, ctx, expr.arguments[0])?;
                     Ok(Value::create_message(length))
                 },
                 Method::Length => {
                     todo!("implement")
                 },
                 Method::Assert => {
                     let value = self.eval(h, ctx, expr.arguments[0])?;
                     if value.as_boolean().0 {
                         // Return bogus
                         Ok(Value::Unassigned)
                     } else {
                         // Failed assertion
                         Err(EvalContinuation::Inconsistent)
+                    }
                 Method::Symbolic(_symbol) => unimplemented!(),
                 },
                 Method::UserFunction => unimplemented!(),
                 Method::UserComponent => unreachable!(),
             },
             Expression::Variable(expr) => self.get(h, ctx, expr.this.upcast()),
+        }
+    }
+}
@@ @@ -1599,13 +1613,13 @@ impl Prompt { @@
     fn set_arguments(&mut self, h: &Heap, args: &Vec<Value>) {
         let def = &h[self.definition];
         let params = def.parameters();
         assert_eq!(params.len(), args.len());
         for (param, value) in params.iter().zip(args.iter()) {
             let hparam = &h[*param];
             assert!(value.is_type_compatible(h, &hparam.parser_type));
+            assert!(value.is_type_compatible(h, &hparam.parser_type.elements));
             self.store.initialize(h, param.upcast(), value.clone());
+        }
+    }
     pub fn step(&mut self, h: &Heap, ctx: &mut EvalContext) -> EvalResult {
         if self.position.is_none() {
             return Err(EvalContinuation::Terminal);
@@ @@ -1632,17 +1646,12 @@ impl Prompt { @@
+                    }
+                }
                 // Continue to next statement
                 self.position = stmt.next();
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Skip(stmt) => {
                 // Continue to next statement
                 self.position = stmt.next;
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Labeled(stmt) => {
                 // Continue to next statement
                 self.position = Some(stmt.body);
                 Err(EvalContinuation::Stepping)
+            }
             Statement::If(stmt) => {
@@ @@ -1697,27 +1706,16 @@ impl Prompt { @@
+            }
             Statement::Continue(stmt) => {
                 // Continue to beginning of while
                 self.position = stmt.target.map(WhileStatementId::upcast);
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Assert(stmt) => {
                 // Evaluate expression
                 let value = self.store.eval(h, ctx, stmt.expression)?;
                 if value.as_boolean().0 {
                     // Continue to next statement
                     self.position = stmt.next;
                     Err(EvalContinuation::Stepping)
                 } else {
                     // Assertion failed: inconsistent
                     Err(EvalContinuation::Inconsistent)
+                }
+            }
             Statement::Return(stmt) => {
                 // Evaluate expression
                 let value = self.store.eval(h, ctx, stmt.expression)?;
                 debug_assert_eq!(stmt.expressions.len(), 1);
                 let value = self.store.eval(h, ctx, stmt.expressions[0])?;
                 // Done with evaluation
                 Ok(value)
+            }
             Statement::Goto(stmt) => {
                 // Continue to target
                 self.position = stmt.target.map(|x| x.upcast());
@@ @@ -1729,14 +1727,14 @@ impl Prompt { @@
                 for &arg in expr.arguments.iter() {
                     let value = self.store.eval(h, ctx, arg)?;
                     args.push(value);
+                }
                 self.position = stmt.next;
                 match &expr.method {
                     Method::Symbolic(symbolic) => {
                          Err(EvalContinuation::NewComponent(symbolic.definition.unwrap(), args))
                     Method::UserComponent => {
                          Err(EvalContinuation::NewComponent(expr.definition, args))
                     },
                     _ => unreachable!("not a symbolic call expression")
+                }
+            }
             Statement::Expression(stmt) => {
                 // Evaluate expression

src/protocol/input_source.rs

➞

Show inline comments

 use std::fmt;
-use std::cell::{Ref, RefCell};
+use std::sync::{RwLock, RwLockReadGuard};
 use std::fmt::Write;
 #[derive(Debug, Clone, Copy)]
 pub struct InputPosition {
     pub line: u32,
     pub offset: u32,
@@ @@ -35,26 +35,26 @@ pub struct InputSource { @@
     // 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.
     // As the compiler is currently not multithreaded, we simply put it in a
     // RefCell to allow interior mutability.
     offset_lookup: RefCell<Vec<u32>>,
     // 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: RefCell::new(Vec::new()),
+            offset_lookup: RwLock::new(Vec::new()),
+        }
+    }
     #[cfg(test)]
     pub fn new_test(input: &str) -> Self {
         let bytes = Vec::from(input.as_bytes());
@@ @@ -126,24 +126,34 @@ impl InputSource { @@
     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) -> Ref<Vec<u32>> {
+    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.borrow();
+        {
             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.
         let mut lookup = self.offset_lookup.borrow_mut();
         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' {
@@ @@ -152,13 +162,14 @@ impl InputSource { @@
+        }
         lookup.push(self.input.len() as u32); // for lookup_line_end
         debug_assert_eq!(self.line as usize + 2, lookup.len(), "remove me: i am a testing assert and sometimes invalid");
         // Return created lookup
         let lookup = self.offset_lookup.borrow();
         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();
@@ @@ -352,13 +363,13 @@ impl fmt::Display for ParseErrorStatement { @@
                 // - 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);
+                    writeln!(f, " |  {}", &context)?;
                     last_line = cur_line;
+                }
                 // - underline beneath last line
                 annotation.push_str(" \\__");
                 extend_annotation(1, self.end_column, &last_line, &mut annotation, '_');
@@ @@ -390,16 +401,12 @@ impl fmt::Display for ParseError { @@
         Ok(())
+    }
+}
 impl ParseError {
     pub fn empty() -> Self {
         Self{ statements: Vec::new() }
+    }
     pub fn new_error_at_pos(source: &InputSource, position: InputPosition, message: String) -> Self {
         Self{ statements: vec!(ParseErrorStatement::from_source_at_pos(
             StatementKind::Error, source, position, message
         )) }
+    }

src/protocol/parser/pass_definitions.rs

➞

Show inline comments

@@ @@ -9,29 +9,29 @@ use crate::collections::*; @@
 /// Parses all the tokenized definitions into actual AST nodes.
 pub(crate) struct PassDefinitions {
     // State
     cur_definition: DefinitionId,
     // Temporary buffers of various kinds
     buffer: String,
     struct_fields: Vec<StructFieldDefinition>,
     enum_variants: Vec<EnumVariantDefinition>,
     union_variants: Vec<UnionVariantDefinition>,
     struct_fields: ScopedBuffer<StructFieldDefinition>,
     enum_variants: ScopedBuffer<EnumVariantDefinition>,
     union_variants: ScopedBuffer<UnionVariantDefinition>,
     parameters: ScopedBuffer<ParameterId>,
     expressions: ScopedBuffer<ExpressionId>,
     statements: ScopedBuffer<StatementId>,
     parser_types: Vec<ParserType>,
+}
 impl PassDefinitions {
     pub(crate) fn new() -> Self {
         Self{
             cur_definition: DefinitionId::new_invalid(),
             buffer: String::with_capacity(128),
             struct_fields: Vec::with_capacity(128),
             enum_variants: Vec::with_capacity(128),
             union_variants: Vec::with_capacity(128),
             struct_fields: ScopedBuffer::new_reserved(128),
             enum_variants: ScopedBuffer::new_reserved(128),
             union_variants: ScopedBuffer::new_reserved(128),
             parameters: ScopedBuffer::new_reserved(128),
             expressions: ScopedBuffer::new_reserved(128),
             statements: ScopedBuffer::new_reserved(128),
             parser_types: Vec::with_capacity(128),
+        }
+    }
@@ @@ -86,12 +86,13 @@ impl PassDefinitions { @@
             // Token was not None, so peek_ident returns None if not an ident
             let ident = peek_ident(&module.source, &mut iter);
             match ident {
                 Some(KW_STRUCT) => self.visit_struct_definition(module, &mut iter, ctx)?,
                 Some(KW_ENUM) => self.visit_enum_definition(module, &mut iter, ctx)?,
                 Some(KW_UNION) => self.visit_union_definition(module, &mut iter, ctx)?,
                 Some(KW_FUNCTION) => self.visit_function_definition(module, &mut iter, ctx)?,
                 Some(KW_PRIMITIVE) | Some(KW_COMPOSITE) => self.visit_component_definition(module, &mut iter, ctx)?,
                 _ => return Err(ParseError::new_error_str_at_pos(
                     &module.source, iter.last_valid_pos(),
                     "unexpected symbol, expected some kind of type or procedure definition"
                 )),
@@ @@ -106,38 +107,39 @@ impl PassDefinitions { @@
         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;
         let poly_vars = ctx.heap[definition_id].poly_vars();
         // Parse struct definition
         consume_polymorphic_vars_spilled(&module.source, iter)?;
         debug_assert!(self.struct_fields.is_empty());
         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,
             |source, iter| {
             TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
                 let poly_vars = ctx.heap[definition_id].poly_vars(); // TODO: @Cleanup, this is really ugly. But rust...
                 let start_pos = iter.last_valid_pos();
                 let parser_type = consume_parser_type(
                     source, iter, &ctx.symbols, &ctx.heap, poly_vars, module_scope,
                     definition_id, false, 0
                 )?;
                 let field = consume_ident_interned(source, iter, ctx)?;
                 Ok(StructFieldDefinition{
                     span: InputSpan::from_positions(start_pos, field.span.end),
                     field, parser_type
                 })
             },
-            &mut self.struct_fields, "a struct field", "a list of struct fields", None
+            &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.clone_from(&self.struct_fields);
         self.struct_fields.clear();
         struct_def.fields = fields_section.into_vec();
         Ok(())
+    }
     fn visit_enum_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
@@ @@ -146,37 +148,36 @@ impl PassDefinitions { @@
         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;
         let poly_vars = ctx.heap[definition_id].poly_vars();
         // Parse enum definition
         consume_polymorphic_vars_spilled(&module.source, iter)?;
         debug_assert!(self.enum_variants.is_empty());
         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,
             |source, iter| {
             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 self.enum_variants, "an enum variant", "a list of enum variants", None
+            &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.clone_from(&self.enum_variants);
         self.enum_variants.clear();
         enum_def.variants = enum_section.into_vec();
         Ok(())
+    }
     fn visit_union_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
@@ @@ -185,25 +186,27 @@ impl PassDefinitions { @@
         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;
         let poly_vars = ctx.heap[definition_id].poly_vars();
         // Parse union definition
         consume_polymorphic_vars_spilled(&module.source, iter)?;
         debug_assert!(self.union_variants.is_empty());
         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,
             |source, iter| {
             TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
                 let identifier = consume_ident_interned(source, iter, ctx)?;
                 let mut close_pos = identifier.span.end;
                 let has_embedded = maybe_consume_comma_separated(
                     TokenKind::OpenParen, TokenKind::CloseParen, source, iter,
                     |source, iter| {
                     TokenKind::OpenParen, TokenKind::CloseParen, source, iter, ctx,
                     |source, iter, ctx| {
                         let poly_vars = ctx.heap[definition_id].poly_vars(); // TODO: @Cleanup, this is really ugly. But rust...
                         consume_parser_type(
                             source, iter, &ctx.symbols, &ctx.heap, poly_vars,
                             module_scope, definition_id, false, 0
+                        )
                     },
                     &mut self.parser_types, "an embedded type", Some(&mut close_pos)
@@ @@ -218,19 +221,18 @@ impl PassDefinitions { @@
                 Ok(UnionVariantDefinition{
                     span: InputSpan::from_positions(identifier.span.begin, close_pos),
                     identifier,
                     value
                 })
             },
-            &mut self.union_variants, "a union variant", "a list of union variants", None
+            &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.clone_from(&self.union_variants);
         self.union_variants.clear();
         union_def.variants = variants_section.into_vec();
         Ok(())
+    }
     fn visit_function_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
@@ @@ -239,27 +241,27 @@ impl PassDefinitions { @@
         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;
         let poly_vars = ctx.heap[definition_id].poly_vars();
         // Parse function's argument list
         let mut parameter_section = self.parameters.start_section();
         consume_parameter_list(
-            &module.source, iter, ctx, &mut parameter_section, poly_vars, module_scope, definition_id
             &module.source, iter, ctx, &mut parameter_section, module_scope, definition_id
         )?;
         let parameters = parameter_section.into_vec();
         // Consume return types
         consume_token(&module.source, iter, TokenKind::ArrowRight)?;
         let mut open_curly_pos = iter.last_valid_pos();
         consume_comma_separated_until(
             TokenKind::OpenCurly, &module.source, iter,
             |source, iter| {
             TokenKind::OpenCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
                 let poly_vars = ctx.heap[definition_id].poly_vars(); // TODO: @Cleanup, this is really ugly. But rust...
                 consume_parser_type(source, iter, &ctx.symbols, &ctx.heap, poly_vars, module_scope, definition_id, false, 0)
             },
             &mut self.parser_types, "a return type", Some(&mut open_curly_pos)
         )?;
         let return_types = self.parser_types.clone();
@@ @@ -290,18 +292,17 @@ impl PassDefinitions { @@
         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;
         let poly_vars = ctx.heap[definition_id].poly_vars();
         // Parse component's argument list
         let mut parameter_section = self.parameters.start_section();
         consume_parameter_list(
-            &module.source, iter, ctx, &mut parameter_section, poly_vars, module_scope, definition_id
             &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)?;
@@ @@ -435,18 +436,25 @@ impl PassDefinitions { @@
         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 statements = Vec::new();
+        let mut stmt_section = self.statements.start_section();
         let mut next = iter.next();
         while next.is_some() && next != Some(TokenKind::CloseCurly) {
         while next != Some(TokenKind::CloseCurly) {
             if next.is_none() {
                 return Err(ParseError::new_error_str_at_pos(
                     &module.source, iter.last_valid_pos(), "expected a statement or '}'"
                 ));
+            }
             self.consume_statement(module, iter, ctx, &mut stmt_section)?;
             next = iter.next();
+        }
         let statements = stmt_section.into_vec();
         let mut block_span = consume_token(&module.source, iter, TokenKind::CloseCurly)?;
         block_span.begin = open_curly_pos;
         Ok(ctx.heap.alloc_block_statement(|this| BlockStatement{
             this,
             is_implicit: false,
@@ @@ -562,20 +570,22 @@ impl PassDefinitions { @@
         &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,
             |source, iter| self.consume_expression(module, iter, ctx),
             TokenKind::SemiColon, &module.source, iter, ctx,
             |_source, iter, ctx| self.consume_expression(module, iter, ctx),
             &mut scoped_section, "a return expression", None
         )?;
         let expressions = scoped_section.into_vec();
         if expressions.is_empty() {
             return Err(ParseError::new_error_str_at_span(&module.source, return_span, "expected at least one return value"));
         } else if expressions.len() > 1 {
             return Err(ParseError::new_error_str_at_span(&module.source, return_span, "multiple return values are not (yet) supported"))
+        }
         Ok(ctx.heap.alloc_return_statement(|this| ReturnStatement{
             this,
             span: return_span,
             expressions
@@ @@ -1187,14 +1197,14 @@ impl PassDefinitions { @@
             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,
                 |source, iter| self.consume_expression(module, iter, ctx),
                 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),
@@ @@ -1257,14 +1267,14 @@ impl PassDefinitions { @@
                         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,
                                     |source, iter| {
                                     TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
                                     |source, iter, ctx| {
                                         let identifier = consume_ident_interned(source, iter, ctx)?;
                                         consume_token(source, iter, TokenKind::Colon)?;
                                         let value = self.consume_expression(module, iter, ctx)?;
                                         Ok(LiteralStructField{ identifier, value, field_idx: 0 })
                                     },
                                     &mut struct_fields, "a struct field", "a list of struct field", Some(&mut last_token)
@@ @@ -1334,15 +1344,12 @@ impl PassDefinitions { @@
                                     definition: target_definition_id,
                                     parent: ExpressionParent::None,
                                     concrete_type: ConcreteType::default(),
                                 }).upcast()
                             },
                             Definition::Function(function_definition) => {
                                 // Function call: consume the arguments
                                 let arguments = self.consume_expression_list(module, iter, ctx, None)?;
                                 // Check whether it is a builtin function
                                 let method = if function_definition.builtin {
                                     match function_definition.identifier.value.as_str() {
                                         "get" => Method::Get,
                                         "put" => Method::Put,
                                         "fires" => Method::Fires,
@@ @@ -1352,12 +1359,15 @@ impl PassDefinitions { @@
                                         _ => unreachable!(),
+                                    }
                                 } else {
                                     Method::UserFunction
                                 };
                                 // Function call: consume the arguments
                                 let arguments = self.consume_expression_list(module, iter, ctx, None)?;
                                 ctx.heap.alloc_call_expression(|this| CallExpression{
                                     this,
                                     span: parser_type.elements[0].full_span, // TODO: @Span fix
                                     parser_type,
                                     method,
                                     arguments,
@@ @@ -1457,14 +1467,14 @@ impl PassDefinitions { @@
     #[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,
             |source, iter| self.consume_expression(module, iter, ctx),
             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())
+    }
+}
@@ @@ -1804,31 +1814,32 @@ fn consume_parser_type_ident( @@
     };
     Ok(ParserTypeElement{ full_span: type_span, variant })
+}
 /// Consumes polymorphic variables and throws them on the floor.
 fn consume_polymorphic_vars_spilled(source: &InputSource, iter: &mut TokenIter) -> Result<(), ParseError> {
+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,
         |source, iter| {
         TokenKind::OpenAngle, TokenKind::CloseAngle, source, iter, _ctx,
         |source, iter, _ctx| {
             consume_ident(source, iter)?;
             Ok(())
         }, "a polymorphic variable"
     )?;
     Ok(())
+}
 /// Consumes the parameter list to functions/components
 fn consume_parameter_list(
     source: &InputSource, iter: &mut TokenIter, ctx: &mut PassCtx, target: &mut ScopedSection<ParameterId>,
     poly_vars: &[Identifier], scope: SymbolScope, definition_id: DefinitionId
     source: &InputSource, iter: &mut TokenIter, ctx: &mut PassCtx,
     target: &mut ScopedSection<ParameterId>, scope: SymbolScope, definition_id: DefinitionId
 ) -> Result<(), ParseError> {
     consume_comma_separated(
         TokenKind::OpenParen, TokenKind::CloseParen, source, iter,
         |source, iter| {
         TokenKind::OpenParen, TokenKind::CloseParen, source, iter, ctx,
         |source, iter, ctx| {
             let poly_vars = ctx.heap[definition_id].poly_vars(); // TODO: @Cleanup, this is really ugly. But rust...
             let (start_pos, _) = iter.next_positions();
             let parser_type = consume_parser_type(
                 source, iter, &ctx.symbols, &ctx.heap, poly_vars, scope,
                 definition_id, false, 0
             )?;
             let identifier = consume_ident_interned(source, iter, ctx)?;

src/protocol/parser/pass_imports.rs

➞

Show inline comments

@@ @@ -52,13 +52,13 @@ impl PassImport { @@
         module.phase = ModuleCompilationPhase::ImportsResolved;
         Ok(())
+    }
     pub(crate) fn visit_import_range(
-        &mut self, modules: &mut [Module], module_idx: usize, ctx: &mut PassCtx, range_idx: usize
         &mut self, modules: &[Module], module_idx: usize, ctx: &mut PassCtx, range_idx: usize
     ) -> Result<(), ParseError> {
         let module = &modules[module_idx];
         let import_range = &module.tokens.ranges[range_idx];
         debug_assert_eq!(import_range.range_kind, TokenRangeKind::Import);
         let mut iter = module.tokens.iter_range(import_range);
@@ @@ -113,12 +113,22 @@ impl PassImport { @@
             fn consume_symbol_and_maybe_alias<'a>(
                 source: &'a InputSource, iter: &mut TokenIter, ctx: &mut PassCtx,
                 module_name: &StringRef<'static>, module_root_id: RootId,
             ) -> Result<(AliasedSymbol, SymbolDefinition), ParseError> {
                 // Consume symbol name and make sure it points to an existing definition
                 let symbol_identifier = consume_ident_interned(source, iter, ctx)?;
                 // Consume alias text if specified
                 let alias_identifier = if peek_ident(source, iter) == Some(b"as") {
                     // Consume alias
                     iter.consume();
                     Some(consume_ident_interned(source, iter, ctx)?)
                 } else {
                     None
                 };
                 let target = ctx.symbols.get_symbol_by_name_defined_in_scope(
                     SymbolScope::Module(module_root_id), symbol_identifier.value.as_bytes()
                 );
                 if target.is_none() {
                     return Err(ParseError::new_error_at_span(
@@ @@ -130,21 +140,12 @@ impl PassImport { @@
                     ));
+                }
                 let target = target.unwrap();
                 debug_assert_ne!(target.class(), SymbolClass::Module);
                 let target_definition = target.variant.as_definition();
                 // Consume alias text if specified
                 let alias_identifier = if peek_ident(source, iter) == b"as" {
                     // Consume alias
                     iter.consume();
                     Some(consume_ident_interned(source, iter, ctx)?)
                 } else {
                     None
                 };
                 Ok((
                     AliasedSymbol{
                         name: symbol_identifier,
                         alias: alias_identifier,
                         definition_id: target_definition.definition_id,
                     },
@@ @@ -157,13 +158,18 @@ impl PassImport { @@
             if Some(TokenKind::Ident) == next {
                 // Importing a single symbol
                 iter.consume();
                 let (imported_symbol, symbol_definition) = consume_symbol_and_maybe_alias(
                     &module.source, &mut iter, ctx, &module_identifier.value, target_root_id
                 )?;
                 let alias_identifier = imported_symbol.alias.unwrap_or_else(|| { imported_symbol.name.clone() });
                 let alias_identifier = match imported_symbol.alias.as_ref() {
                     Some(alias) => alias.clone(),
                     None => imported_symbol.name.clone(),
                 };
                 import_id = ctx.heap.alloc_import(|this| Import::Symbols(ImportSymbols{
                     this,
                     span: InputSpan::from_positions(import_span.begin, alias_identifier.span.end),
                     module: module_identifier,
                     module_id: target_root_id,
                     symbols: vec![imported_symbol],
@@ @@ -173,21 +179,21 @@ impl PassImport { @@
                     Symbol{
                         name: alias_identifier.value,
                         variant: SymbolVariant::Definition(symbol_definition.into_imported(import_id))
+                    }
                 ) {
                     return Err(construct_symbol_conflict_error(
                         modules, module_idx, ctx, &new_symbol, old_symbol
+                        modules, module_idx, ctx, &new_symbol, &old_symbol
                     ));
+                }
             } else if Some(TokenKind::OpenCurly) == next {
                 // Importing multiple symbols
                 let mut end_of_list = iter.last_valid_pos();
                 consume_comma_separated(
                     TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, &mut iter,
                     |source, iter| consume_symbol_and_maybe_alias(
                     TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, &mut iter, ctx,
                     |source, iter, ctx| consume_symbol_and_maybe_alias(
                         source, iter, ctx, &module_identifier.value, target_root_id
                     ),
                     &mut self.found_symbols, "a symbol", "a list of symbols to import", Some(&mut end_of_list)
                 )?;
                 // Preallocate import
@@ @@ -201,24 +207,25 @@ impl PassImport { @@
                 // Fill import symbols while inserting symbols in the
                 // appropriate scope in the symbol table.
                 let import = ctx.heap[import_id].as_symbols_mut();
                 for (imported_symbol, symbol_definition) in self.found_symbols.drain(..) {
                     let import_name = imported_symbol.alias.map_or_else(
                         || imported_symbol.name.value.clone(),
                         |v| v.value.clone()
                     );
                     let import_name = match imported_symbol.alias.as_ref() {
                         Some(import) => import.value.clone(),
                         None => imported_symbol.name.value.clone()
                     };
                     import.symbols.push(imported_symbol);
                     if let Err((new_symbol, old_symbol)) = ctx.symbols.insert_symbol(
                         SymbolScope::Module(module.root_id), Symbol{
                             name: import_name,
                             variant: SymbolVariant::Definition(symbol_definition.into_imported(import_id))
+                        }
                     ) {
                         return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, old_symbol));
+                        return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, &old_symbol));
+                    }
+                }
             } else if Some(TokenKind::Star) == next {
                 // Import all symbols from the module
                 let star_span = iter.next_span();
@@ @@ -244,25 +251,25 @@ impl PassImport { @@
                 for symbol in self.scoped_symbols.drain(..) {
                     let symbol_name = symbol.name;
                     match symbol.variant {
                         SymbolVariant::Definition(symbol_definition) => {
                             import.symbols.push(AliasedSymbol{
-                                name: Identifier{ span: star_span, value: symbol.name.clone() },
+                                name: Identifier{ span: star_span, value: symbol_name.clone() },
                                 alias: None,
                                 definition_id: symbol_definition.definition_id,
                             });
                             if let Err((new_symbol, old_symbol)) = ctx.symbols.insert_symbol(
                                 SymbolScope::Module(module.root_id),
                                 Symbol{
                                     name: symbol_name,
                                     variant: SymbolVariant::Definition(symbol_definition.into_imported(import_id))
+                                }
                             ) {
                                 return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, old_symbol));
+                                return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, &old_symbol));
+                            }
                         },
                         _ => unreachable!(),
+                    }
+                }
             } else {
@@ @@ -286,19 +293,21 @@ impl PassImport { @@
                 this,
                 span: InputSpan::from_positions(import_span.begin, module_identifier.span.end),
                 module: module_identifier,
                 alias: alias_identifier,
                 module_id: target_root_id,
             }));
             ctx.symbols.insert_symbol(SymbolScope::Module(module.root_id), Symbol{
+            if let Err((new_symbol, old_symbol)) = ctx.symbols.insert_symbol(SymbolScope::Module(module.root_id), Symbol{
                 name: alias,
                 variant: SymbolVariant::Module(SymbolModule{
                     root_id: target_root_id,
                     introduced_at: import_id
                 })
             });
             }) {
                 return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, &old_symbol));
+            }
+        }
         // By now the `import_id` is set, just need to make sure that the import
         // properly ends with a semicolon
         consume_token(&module.source, &mut iter, TokenKind::SemiColon)?;
         self.imports.push(import_id);

src/protocol/parser/pass_symbols.rs

➞

Show inline comments

@@ @@ -59,44 +59,51 @@ impl PassSymbols { @@
                 imports: Vec::new(),
                 definitions: Vec::new(),
+            }
         });
         module.root_id = root_id;
-        // Visit token ranges to detect definitions and pragmas
+        // Retrieve first range index, then make immutable borrow
         let mut range_idx = module_range.first_child_idx;
         let module = &modules[module_idx];
         // Visit token ranges to detect definitions and pragmas
         loop {
             let range_idx_usize = range_idx as usize;
             let cur_range = &module.tokens.ranges[range_idx_usize];
             let next_sibling_idx = cur_range.next_sibling_idx;
             let range_kind = cur_range.range_kind;
             // Parse if it is a definition or a pragma
-            if cur_range.range_kind == TokenRangeKind::Definition {
             if range_kind == TokenRangeKind::Definition {
                 self.visit_definition_range(modules, module_idx, ctx, range_idx_usize)?;
-            } else if cur_range.range_kind == TokenRangeKind::Pragma {
             } else if range_kind == TokenRangeKind::Pragma {
                 self.visit_pragma_range(modules, module_idx, ctx, range_idx_usize)?;
+            }
-            match cur_range.next_sibling_idx {
             match next_sibling_idx {
                 Some(idx) => { range_idx = idx; },
                 None => { break; },
+            }
+        }
         // Add the module's symbol scope and the symbols we just parsed
         let module_scope = SymbolScope::Module(root_id);
         ctx.symbols.insert_scope(None, module_scope);
         for symbol in self.symbols.drain(..) {
             if let Err((new_symbol, old_symbol)) = ctx.symbols.insert_symbol(module_scope, symbol) {
                 return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, old_symbol))
+                return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, &old_symbol))
+            }
+        }
         // Modify the preallocated root
         let root = &mut ctx.heap[root_id];
         root.pragmas.extend(self.pragmas.drain(..));
         root.definitions.extend(self.definitions.drain(..));
         let module = &mut modules[module_idx];
         module.phase = ModuleCompilationPhase::SymbolsScanned;
         Ok(())
+    }
     fn visit_pragma_range(&mut self, modules: &[Module], module_idx: usize, ctx: &mut PassCtx, range_idx: usize) -> Result<(), ParseError> {
@@ @@ -131,13 +138,13 @@ impl PassSymbols { @@
             self.pragmas.push(pragma_id);
             if let Err(other_module_root_id) = ctx.symbols.insert_module(module_name, module.root_id) {
                 // Naming conflict
                 let this_module = &modules[module_idx];
                 let other_module = seek_module(modules, other_module_root_id).unwrap();
-                let (other_module_pragma_id, _) = other_module.name.unwrap();
+                let other_module_pragma_id = other_module.name.as_ref().map(|v| (*v).0).unwrap();
                 let other_pragma = ctx.heap[other_module_pragma_id].as_module();
                 return Err(ParseError::new_error_str_at_span(
                     &this_module.source, pragma_span, "conflict in module name"
                 ).with_info_str_at_span(
                     &other_module.source, other_pragma.span, "other module is defined here"
                 ));
@@ @@ -180,14 +187,14 @@ impl PassSymbols { @@
         let (kw_text, _) = consume_any_ident(&module.source, &mut iter).unwrap();
         // Retrieve identifier of definition
         let identifier = consume_ident_interned(&module.source, &mut iter, ctx)?;
         let mut poly_vars = Vec::new();
         maybe_consume_comma_separated(
             TokenKind::OpenAngle, TokenKind::CloseAngle, &module.source, &mut iter,
             |source, iter| consume_ident_interned(source, iter, ctx),
             TokenKind::OpenAngle, TokenKind::CloseAngle, &module.source, &mut iter, ctx,
             |source, iter, ctx| consume_ident_interned(source, iter, ctx),
             &mut poly_vars, "a polymorphic variable", None
         )?;
         let ident_text = identifier.value.clone(); // because we need it later
         let ident_span = identifier.span.clone();
         // Reserve space in AST for definition and add it to the symbol table

src/protocol/parser/pass_tokenizer.rs

➞

Show inline comments

 use crate::protocol::input_source::{
     InputSource as InputSource,
     ParseError,
     InputPosition as InputPosition,
     InputSpan
 };
 use super::tokens::*;
 use super::token_parsing::*;
 /// Tokenizer is a reusable parser to tokenize multiple source files using the
@@ @@ -154,13 +153,13 @@ impl PassTokenizer { @@
                     assert_eq!(cur_range.last_child_idx, parent_idx as u32);
                 } else {
                     assert_ne!(cur_range.first_child_idx, parent_idx as u32);
                     assert_ne!(cur_range.last_child_idx, parent_idx as u32);
                     let mut child_counter = 0u32;
-                    let mut last_child_idx = cur_range.first_child_idx;
                     let last_child_idx = cur_range.first_child_idx;
                     let mut child_idx = Some(cur_range.first_child_idx);
                     while let Some(cur_child_idx) = child_idx {
                         let child_range = &target.ranges[cur_child_idx as usize];
                         assert_eq!(child_range.parent_idx, parent_idx);
                         child_idx = child_range.next_sibling_idx;
                         child_counter += 1;
@@ @@ -369,13 +368,16 @@ impl PassTokenizer { @@
                 token_kind = TokenKind::OrEquals;
             } else {
                 token_kind = TokenKind::Or;
+            }
         } else if first_char == b'}' {
             source.consume();
             token_kind = TokenKind::CloseCurly
             token_kind = TokenKind::CloseCurly;
         } else if first_char == b'~' {
             source.consume();
             token_kind = TokenKind::Tilde;
         } else {
             self.check_ascii(source)?;
             return Ok(None);
+        }
         target.tokens.push(Token::new(token_kind, pos));
@@ @@ -623,48 +625,47 @@ impl PassTokenizer { @@
         has_newline
+    }
     /// Pushes a new token range onto the stack in the buffers.
     fn push_range(&mut self, target: &mut TokenBuffer, range_kind: TokenRangeKind, first_token: u32) {
         let new_range_idx = target.ranges.len() as u32;
         let cur_range = &mut target.ranges[self.stack_idx];
         // If we have just popped a range and then push a new range, then the
         // first token is equal to the last token registered on the current
         // range. If not, then we had some intermediate tokens that did not
         // belong to a particular kind of token range: hence we insert an
         // intermediate "code" range.
         if cur_range.end != first_token {
             let code_start = cur_range.end;
             let code_range_idx = target.ranges.len() as u32;
             if cur_range.first_child_idx == self.stack_idx as u32 {
                 // The parent of the new "code" range we're going to push does
                 // not have any registered children yet.
-                cur_range.first_child_idx = code_range_idx;
+                cur_range.first_child_idx = new_range_idx;
+            }
-            cur_range.last_child_idx = code_range_idx + 1;
+            cur_range.last_child_idx = new_range_idx + 1;
             cur_range.end = first_token;
             cur_range.num_child_ranges += 1;
             target.ranges.push(TokenRange{
                 parent_idx: self.stack_idx,
                 range_kind: TokenRangeKind::Code,
                 curly_depth: self.curly_stack.len() as u32,
                 start: code_start,
                 end: first_token,
                 num_child_ranges: 0,
                 first_child_idx: code_range_idx,
                 last_child_idx: code_range_idx,
                 next_sibling_idx: Some(code_range_idx + 1), // we're going to push this thing next
                 first_child_idx: new_range_idx,
                 last_child_idx: new_range_idx,
                 next_sibling_idx: Some(new_range_idx + 1), // we're going to push this thing next
             });
         } else {
             // We're going to push the range in the code below, but while we
             // have the `cur_range` borrowed mutably, we fix up its children
             // indices.
             let new_range_idx = target.ranges.len() as u32;
             if cur_range.first_child_idx == self.stack_idx as u32 {
                 cur_range.first_child_idx = new_range_idx;
+            }
             cur_range.last_child_idx = new_range_idx;
+        }

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -57,12 +57,13 @@ macro_rules! debug_log { @@
 use std::collections::{HashMap, HashSet};
 use crate::protocol::ast::*;
 use crate::protocol::input_source::ParseError;
 use crate::protocol::parser::ModuleCompilationPhase;
 use crate::protocol::parser::type_table::*;
 use crate::protocol::parser::token_parsing::*;
 use super::visitor::{
     STMT_BUFFER_INIT_CAPACITY,
     EXPR_BUFFER_INIT_CAPACITY,
     Ctx,
     Visitor2,
     VisitorResult
@@ @@ -144,21 +145,22 @@ impl InferenceTypePart { @@
+    }
     fn is_concrete_number(&self) -> bool {
         // TODO: @float
         use InferenceTypePart as ITP;
         match self {
             ITP::Byte | ITP::Short | ITP::Int | ITP::Long => true,
             ITP::UInt8 | ITP::UInt16 | ITP::UInt32 | ITP::UInt64 |
             ITP::SInt8 | ITP::SInt16 | ITP::SInt32 | ITP::SInt64 => true,
             _ => false,
+        }
+    }
     fn is_concrete_integer(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::Byte | ITP::Short | ITP::Int | ITP::Long => true,
         match self {ITP::UInt8 | ITP::UInt16 | ITP::UInt32 | ITP::UInt64 |
         ITP::SInt8 | ITP::SInt16 | ITP::SInt32 | ITP::SInt64 => true,
             _ => false,
+        }
+    }
     fn is_concrete_msg_array_or_slice(&self) -> bool {
         use InferenceTypePart as ITP;
@@ @@ -193,14 +195,15 @@ impl InferenceTypePart { @@
     /// fashion. It is basically `number_of_subtypes - 1`
     fn depth_change(&self) -> i32 {
         use InferenceTypePart as ITP;
         match &self {
             ITP::Unknown | ITP::NumberLike | ITP::IntegerLike |
             ITP::Void | ITP::Bool |
             ITP::Byte | ITP::Short | ITP::Int | ITP::Long |
             ITP::String => {
             ITP::UInt8 | ITP::UInt16 | ITP::UInt32 | ITP::UInt64 |
             ITP::SInt8 | ITP::SInt16 | ITP::SInt32 | ITP::SInt64 |
             ITP::Character | ITP::String => {
                 -1
             },
             ITP::MarkerDefinition(_) | ITP::MarkerBody(_) |
             ITP::ArrayLike | ITP::Message | ITP::Array | ITP::Slice |
             ITP::PortLike | ITP::Input | ITP::Output => {
                 // One subtype, so do not modify depth
@@ @@ -222,16 +225,21 @@ impl From<ConcreteTypePart> for InferenceTypePart { @@
             CTP::Marker(_) => {
                 unreachable!("encountered marker while converting concrete type to inferred type");
+            }
             CTP::Void => ITP::Void,
             CTP::Message => ITP::Message,
             CTP::Bool => ITP::Bool,
             CTP::Byte => ITP::Byte,
             CTP::Short => ITP::Short,
             CTP::Int => ITP::Int,
             CTP::Long => ITP::Long,
             CTP::UInt8 => ITP::UInt8,
             CTP::UInt16 => ITP::UInt16,
             CTP::UInt32 => ITP::UInt32,
             CTP::UInt64 => ITP::UInt64,
             CTP::SInt8 => ITP::SInt8,
             CTP::SInt16 => ITP::SInt16,
             CTP::SInt32 => ITP::SInt32,
             CTP::SInt64 => ITP::SInt64,
             CTP::Character => ITP::Character,
             CTP::String => ITP::String,
             CTP::Array => ITP::Array,
             CTP::Slice => ITP::Slice,
             CTP::Input => ITP::Input,
             CTP::Output => ITP::Output,
             CTP::Instance(id, num) => ITP::Instance(id, num),
@@ @@ -632,16 +640,21 @@ impl InferenceType { @@
                 ITP::Unknown | ITP::NumberLike | ITP::IntegerLike | ITP::ArrayLike | ITP::PortLike => {
                     unreachable!("Attempted to convert inference type part {:?} into concrete type", part);
                 },
                 ITP::Void => CTP::Void,
                 ITP::Message => CTP::Message,
                 ITP::Bool => CTP::Bool,
                 ITP::Byte => CTP::Byte,
                 ITP::Short => CTP::Short,
                 ITP::Int => CTP::Int,
                 ITP::Long => CTP::Long,
                 ITP::UInt8 => CTP::UInt8,
                 ITP::UInt16 => CTP::UInt16,
                 ITP::UInt32 => CTP::UInt32,
                 ITP::UInt64 => CTP::UInt64,
                 ITP::SInt8 => CTP::SInt8,
                 ITP::SInt16 => CTP::SInt16,
                 ITP::SInt32 => CTP::SInt32,
                 ITP::SInt64 => CTP::SInt64,
                 ITP::Character => CTP::Character,
                 ITP::String => CTP::String,
                 ITP::Array => CTP::Array,
                 ITP::Slice => CTP::Slice,
                 ITP::Input => CTP::Input,
                 ITP::Output => CTP::Output,
                 ITP::Instance(id, num) => CTP::Instance(*id, *num),
@@ @@ -666,50 +679,58 @@ impl InferenceType { @@
             },
             ITP::MarkerBody(thing) => {
                 buffer.push_str(&format!("{{B:{}}}", *thing));
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
             },
             ITP::Unknown => buffer.push_str("?"),
             ITP::NumberLike => buffer.push_str("num?"),
             ITP::IntegerLike => buffer.push_str("int?"),
             ITP::NumberLike => buffer.push_str("numberlike"),
             ITP::IntegerLike => buffer.push_str("integerlike"),
             ITP::ArrayLike => {
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push_str("[?]");
             },
             ITP::PortLike => {
-                buffer.push_str("port?<");
+                buffer.push_str("portlike<");
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
+            }
             ITP::Void => buffer.push_str("void"),
             ITP::Bool => buffer.push_str("bool"),
             ITP::Byte => buffer.push_str("byte"),
             ITP::Short => buffer.push_str("short"),
             ITP::Int => buffer.push_str("int"),
             ITP::Long => buffer.push_str("long"),
             ITP::String => buffer.push_str("str"),
             ITP::Bool => buffer.push_str(KW_TYPE_BOOL_STR),
             ITP::UInt8 => buffer.push_str(KW_TYPE_UINT8_STR),
             ITP::UInt16 => buffer.push_str(KW_TYPE_UINT16_STR),
             ITP::UInt32 => buffer.push_str(KW_TYPE_UINT32_STR),
             ITP::UInt64 => buffer.push_str(KW_TYPE_UINT64_STR),
             ITP::SInt8 => buffer.push_str(KW_TYPE_SINT8_STR),
             ITP::SInt16 => buffer.push_str(KW_TYPE_SINT16_STR),
             ITP::SInt32 => buffer.push_str(KW_TYPE_SINT32_STR),
             ITP::SInt64 => buffer.push_str(KW_TYPE_SINT64_STR),
             ITP::Character => buffer.push_str(KW_TYPE_CHAR_STR),
             ITP::String => buffer.push_str(KW_TYPE_STRING_STR),
             ITP::Message => {
                 buffer.push_str("msg<");
                 buffer.push_str(KW_TYPE_MESSAGE_STR);
                 buffer.push('<');
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
             },
             ITP::Array => {
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push_str("[]");
             },
             ITP::Slice => {
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push_str("[..]");
             },
             ITP::Input => {
                 buffer.push_str("in<");
                 buffer.push_str(KW_TYPE_IN_PORT_STR);
                 buffer.push('<');
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
             },
             ITP::Output => {
                 buffer.push_str("out<");
                 buffer.push_str(KW_TYPE_OUT_PORT_STR);
                 buffer.push('<');
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
             },
             ITP::Instance(definition_id, num_sub) => {
                 let definition = &heap[*definition_id];
                 buffer.push_str(definition.identifier().value.as_str());
@@ @@ -881,13 +902,13 @@ impl VarData { @@
+    }
+}
 impl PassTyping {
     pub(crate) fn new() -> Self {
         PassTyping {
-            definition_type: DefinitionType::None,
+            definition_type: DefinitionType::Function(FunctionDefinitionId::new_invalid()),
             poly_vars: Vec::new(),
             stmt_buffer: Vec::with_capacity(STMT_BUFFER_INIT_CAPACITY),
             expr_buffer: Vec::with_capacity(EXPR_BUFFER_INIT_CAPACITY),
             var_types: HashMap::new(),
             expr_types: HashMap::new(),
             extra_data: HashMap::new(),
@@ @@ -940,13 +961,13 @@ impl PassTyping { @@
         // Keep resolving types
         self.resolve_types(ctx, queue)?;
         Ok(())
+    }
     fn reset(&mut self) {
-        self.definition_type = DefinitionType::None;
+        self.definition_type = DefinitionType::Function(FunctionDefinitionId::new_invalid());
         self.poly_vars.clear();
         self.stmt_buffer.clear();
         self.expr_buffer.clear();
         self.var_types.clear();
         self.expr_types.clear();
         self.extra_data.clear();
@@ @@ -961,18 +982,18 @@ impl Visitor2 for PassTyping { @@
         self.definition_type = DefinitionType::Component(id);
         let comp_def = &ctx.heap[id];
         debug_assert_eq!(comp_def.poly_vars.len(), self.poly_vars.len(), "component polyvars do not match imposed polyvars");
         debug_log!("{}", "-".repeat(50));
-        debug_log!("Visiting component '{}': {}", &String::from_utf8_lossy(&comp_def.identifier.value), id.0.index);
+        debug_log!("Visiting component '{}': {}", comp_def.identifier.value.as_str(), id.0.index);
         debug_log!("{}", "-".repeat(50));
         for param_id in comp_def.parameters.clone() {
             let param = &ctx.heap[param_id];
-            let var_type = self.determine_inference_type_from_parser_type(ctx, &param.parser_type, true);
+            let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);
             debug_assert!(var_type.is_done, "expected component arguments to be concrete types");
             self.var_types.insert(param_id.upcast(), VarData::new_local(var_type));
+        }
         let body_stmt_id = ctx.heap[id].body;
         self.visit_block_stmt(ctx, body_stmt_id)
@@ @@ -982,18 +1003,18 @@ impl Visitor2 for PassTyping { @@
         self.definition_type = DefinitionType::Function(id);
         let func_def = &ctx.heap[id];
         debug_assert_eq!(func_def.poly_vars.len(), self.poly_vars.len(), "function polyvars do not match imposed polyvars");
         debug_log!("{}", "-".repeat(50));
-        debug_log!("Visiting function '{}': {}", &String::from_utf8_lossy(&func_def.identifier.value), id.0.index);
+        debug_log!("Visiting function '{}': {}", func_def.identifier.value.as_str(), id.0.index);
         debug_log!("{}", "-".repeat(50));
         for param_id in func_def.parameters.clone() {
             let param = &ctx.heap[param_id];
-            let var_type = self.determine_inference_type_from_parser_type(ctx, &param.parser_type, true);
+            let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);
             debug_assert!(var_type.is_done, "expected function arguments to be concrete types");
             self.var_types.insert(param_id.upcast(), VarData::new_local(var_type));
+        }
         let body_stmt_id = ctx.heap[id].body;
         self.visit_block_stmt(ctx, body_stmt_id)
@@ @@ -1013,27 +1034,27 @@ impl Visitor2 for PassTyping { @@
+    }
     fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {
         let memory_stmt = &ctx.heap[id];
         let local = &ctx.heap[memory_stmt.variable];
-        let var_type = self.determine_inference_type_from_parser_type(ctx, &local.parser_type, true);
+        let var_type = self.determine_inference_type_from_parser_type_elements(&local.parser_type.elements, true);
         self.var_types.insert(memory_stmt.variable.upcast(), VarData::new_local(var_type));
         Ok(())
+    }
     fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {
         let channel_stmt = &ctx.heap[id];
         let from_local = &ctx.heap[channel_stmt.from];
-        let from_var_type = self.determine_inference_type_from_parser_type(ctx, &from_local.parser_type, true);
+        let from_var_type = self.determine_inference_type_from_parser_type_elements(&from_local.parser_type.elements, true);
         self.var_types.insert(from_local.this.upcast(), VarData::new_channel(from_var_type, channel_stmt.to.upcast()));
         let to_local = &ctx.heap[channel_stmt.to];
-        let to_var_type = self.determine_inference_type_from_parser_type(ctx, &to_local.parser_type, true);
+        let to_var_type = self.determine_inference_type_from_parser_type_elements(&to_local.parser_type.elements, true);
         self.var_types.insert(to_local.this.upcast(), VarData::new_channel(to_var_type, channel_stmt.from.upcast()));
         Ok(())
+    }
     fn visit_labeled_stmt(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> VisitorResult {
@@ @@ -1076,13 +1097,14 @@ impl Visitor2 for PassTyping { @@
         self.visit_block_stmt(ctx, body_id)
+    }
     fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {
         let return_stmt = &ctx.heap[id];
         let expr_id = return_stmt.expression;
         debug_assert_eq!(return_stmt.expressions.len(), 1);
         let expr_id = return_stmt.expressions[0];
         self.visit_expr(ctx, expr_id)
+    }
     fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {
         let new_stmt = &ctx.heap[id];
@@ @@ -1325,21 +1347,20 @@ impl PassTyping { @@
         // the AST and have now performed typechecking for a different
         // monomorph. In that case we just need to perform typechecking, no need
         // to annotate the AST again.
         let definition_id = match &self.definition_type {
             DefinitionType::Component(id) => id.upcast(),
             DefinitionType::Function(id) => id.upcast(),
             _ => unreachable!(),
         };
         let already_checked = ctx.types.get_base_definition(&definition_id).unwrap().has_any_monomorph();
         for (expr_id, expr_type) in self.expr_types.iter_mut() {
             if !expr_type.is_done {
                 // Auto-infer numberlike/integerlike types to a regular int
                 if expr_type.parts.len() == 1 && expr_type.parts[0] == InferenceTypePart::IntegerLike {
-                    expr_type.parts[0] = InferenceTypePart::Int;
+                    expr_type.parts[0] = InferenceTypePart::SInt32;
                 } else {
                     let expr = &ctx.heap[*expr_id];
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, expr.span(), format!(
                             "could not fully infer the type of this expression (got '{}')",
                             expr_type.display_name(&ctx.heap)
@@ @@ -1401,14 +1422,14 @@ impl PassTyping { @@
                 // Resolve to the appropriate expression and instantiate
                 // monomorphs.
                 match &ctx.heap[*expr_id] {
                     Expression::Call(call_expr) => {
                         // Add to type table if not yet typechecked
                         if let Method::Symbolic(symbolic) = &call_expr.method {
                             let definition_id = symbolic.definition.unwrap();
                         if call_expr.method == Method::UserFunction {
                             let definition_id = call_expr.definition;
                             if !ctx.types.has_monomorph(&definition_id, &monomorph_types) {
                                 let root_id = ctx.types
                                     .get_base_definition(&definition_id)
                                     .unwrap()
                                     .ast_root;
@@ @@ -1425,15 +1446,15 @@ impl PassTyping { @@
+                                }
+                            }
+                        }
                     },
                     Expression::Literal(lit_expr) => {
                         let definition_id = match &lit_expr.value {
                             Literal::Struct(literal) => literal.definition.as_ref().unwrap(),
                             Literal::Enum(literal) => literal.definition.as_ref().unwrap(),
                             Literal::Union(literal) => literal.definition.as_ref().unwrap(),
                             Literal::Struct(literal) => &literal.definition,
                             Literal::Enum(literal) => &literal.definition,
                             Literal::Union(literal) => &literal.definition,
                             _ => unreachable!("post-inference monomorph for non-struct, non-enum literal")
                         };
                         if !ctx.types.has_monomorph(definition_id, &monomorph_types) {
                             ctx.types.add_monomorph(definition_id, monomorph_types);
+                        }
                     },
@@ @@ -1448,13 +1469,13 @@ impl PassTyping { @@
     fn progress_expr(&mut self, ctx: &mut Ctx, id: ExpressionId) -> Result<(), ParseError> {
         match &ctx.heap[id] {
             Expression::Assignment(expr) => {
                 let id = expr.this;
                 self.progress_assignment_expr(ctx, id)
             },
-            Expression::Binding(expr) => {
+            Expression::Binding(_expr) => {
                 unimplemented!("progress binding expression");
             },
             Expression::Conditional(expr) => {
                 let id = expr.this;
                 self.progress_conditional_expr(ctx, id)
             },
@@ @@ -1952,18 +1973,18 @@ impl PassTyping { @@
                 self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?
             },
             Literal::True | Literal::False => {
                 self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?
             },
             Literal::Character(_) => {
                 self.apply_forced_constraint(ctx, upcast_id, &CHARACTER_TEMPLATE)?;
                 todo!("check character literal type inference");
                 self.apply_forced_constraint(ctx, upcast_id, &CHARACTER_TEMPLATE)?
             },
             Literal::String(_) => {
                 self.apply_forced_constraint(ctx, upcast_id, &STRING_TEMPLATE)?;
                 todo!("check string literal type inference");
                 self.apply_forced_constraint(ctx, upcast_id, &STRING_TEMPLATE)?
             },
             Literal::Struct(data) => {
                 let extra = self.extra_data.get_mut(&upcast_id).unwrap();
                 for poly in &extra.poly_vars {
                     debug_log!(" * Poly: {}", poly.display_name(&ctx.heap));
+                }
@@ @@ -2227,19 +2248,13 @@ impl PassTyping { @@
     //  pattern as here.
     fn progress_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> Result<(), ParseError> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let extra = self.extra_data.get_mut(&upcast_id).unwrap();
         debug_log!("Call expr '{}': {}", match &expr.method {
             Method::Create => String::from("create"),
             Method::Fires => String::from("fires"),
             Method::Get => String::from("get"),
             Method::Put => String::from("put"),
             Method::Symbolic(method) => String::from_utf8_lossy(&method.identifier.value).to_string()
         },upcast_id.index);
         debug_log!("Call expr '{}': {}", ctx.heap[expr.definition].identifier().value.as_str(), upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         debug_log!(" * During (inferring types from arguments and return type):");
         // Check if we can make progress using the arguments and/or return types
         // while keeping track of the polyvars we've extended
@@ @@ -2340,13 +2355,13 @@ impl PassTyping { @@
     fn progress_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> Result<(), ParseError> {
         let upcast_id = id.upcast();
         let var_expr = &ctx.heap[id];
         let var_id = var_expr.declaration.unwrap();
-        debug_log!("Variable expr '{}': {}", &String::from_utf8_lossy(&ctx.heap[var_id].identifier().value), upcast_id.index);
+        debug_log!("Variable expr '{}': {}", ctx.heap[var_id].identifier().value.as_str(), upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Var  type: {}", self.var_types.get(&var_id).unwrap().var_type.display_name(&ctx.heap));
         debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));
         // Retrieve shared variable type and expression type and apply inference
         let var_data = self.var_types.get_mut(&var_id).unwrap();
@@ @@ -2762,14 +2777,15 @@ impl PassTyping { @@
             EP::If(_) | EP::While(_) =>
                 // Must be a boolean
                 InferenceType::new(false, true, vec![ITP::Bool]),
             EP::Return(_) =>
                 // Must match the return type of the function
                 if let DefinitionType::Function(func_id) = self.definition_type {
                     let return_parser_type_id = ctx.heap[func_id].return_type;
                     self.determine_inference_type_from_parser_type(ctx, return_parser_type_id, true)
                     debug_assert_eq!(ctx.heap[func_id].return_types.len(), 1);
                     let returned = &ctx.heap[func_id].return_types[0];
                     self.determine_inference_type_from_parser_type_elements(&returned.elements, true)
                 } else {
                     // Cannot happen: definition always set upon body traversal
                     // and "return" calls in components are illegal.
                     unreachable!();
                 },
             EP::New(_) =>
@@ @@ -2800,167 +2816,124 @@ impl PassTyping { @@
         Ok(())
+    }
     fn insert_initial_call_polymorph_data(
         &mut self, ctx: &mut Ctx, call_id: CallExpressionId
     ) {
         use InferenceTypePart as ITP;
         // Note: the polymorph variables may be partially specified and may
         // contain references to the wrapping definition's (i.e. the proctype
         // we are currently visiting) polymorphic arguments.
         //
         // The arguments of the call may refer to polymorphic variables in the
         // definition of the function we're calling, not of the wrapping
         // definition. We insert markers in these inferred types to be able to
         // map them back and forth to the polymorphic arguments of the function
         // we are calling.
         let call = &ctx.heap[call_id];
         // Handle the polymorphic variables themselves
         let mut poly_vars = Vec::with_capacity(call.poly_args.len());
         for poly_arg_type_id in call.poly_args.clone() { // TODO: @performance
             poly_vars.push(self.determine_inference_type_from_parser_type(ctx, poly_arg_type_id, true));
         // Handle the polymorphic arguments (if there are any)
         let num_poly_args = call.parser_type.elements[0].variant.num_embedded();
         let mut poly_args = Vec::with_capacity(num_poly_args);
         for embedded_elements in call.parser_type.iter_embedded(0) {
             poly_args.push(self.determine_inference_type_from_parser_type_elements(embedded_elements, true));
+        }
         // Handle the arguments
         // TODO: @cleanup: Maybe factor this out for reuse in the validator/linker, should also
         //  make the code slightly more robust.
         let (embedded_types, return_type) = match &call.method {
             Method::Create => {
                 // Not polymorphic
+                (
                     vec![InferenceType::new(false, true, vec![ITP::Int])],
                     InferenceType::new(false, true, vec![ITP::Message, ITP::Byte])
+                )
         // Handle the arguments and return types
         let definition = &ctx.heap[call.definition];
         let (parameters, returned) = match definition {
             Definition::Component(definition) => {
                 debug_assert_eq!(poly_args.len(), definition.poly_vars.len());
                 (&definition.parameters, None)
             },
             Method::Fires => {
                 // bool fires<T>(PortLike<T> arg)
+                (
                     vec![InferenceType::new(true, false, vec![ITP::PortLike, ITP::MarkerBody(0), ITP::Unknown])],
                     InferenceType::new(false, true, vec![ITP::Bool])
+                )
             Definition::Function(definition) => {
                 debug_assert_eq!(poly_args.len(), definition.poly_vars.len());
                 (&definition.parameters, Some(&definition.return_types))
             },
             Method::Get => {
                 // T get<T>(input<T> arg)
+                (
                     vec![InferenceType::new(true, false, vec![ITP::Input, ITP::MarkerBody(0), ITP::Unknown])],
                     InferenceType::new(true, false, vec![ITP::MarkerBody(0), ITP::Unknown])
+                )
             Definition::Struct(_) | Definition::Enum(_) | Definition::Union(_) => {
                 unreachable!("insert_initial_call_polymorph data for non-procedure type");
             },
             Method::Put => {
                 // void Put<T>(output<T> port, T msg)
+                (
                     vec![
                         InferenceType::new(true, false, vec![ITP::Output, ITP::MarkerBody(0), ITP::Unknown]),
                         InferenceType::new(true, false, vec![ITP::MarkerBody(0), ITP::Unknown])
                     ],
                     InferenceType::new(false, true, vec![ITP::Void])
+                )
+            }
             Method::Symbolic(symbolic) => {
                 let definition = &ctx.heap[symbolic.definition.unwrap()];
         };
                 match definition {
                     Definition::Component(definition) => {
                         debug_assert_eq!(poly_vars.len(), definition.poly_vars.len());
                         let mut parameter_types = Vec::with_capacity(definition.parameters.len());
                         for param_id in definition.parameters.clone() {
                             let param = &ctx.heap[param_id];
                             parameter_types.push(self.determine_inference_type_from_parser_type(ctx, &param.parser_type, false));
         let mut parameter_types = Vec::with_capacity(parameters.len());
         for parameter_id in parameters.clone().into_iter() { // TODO: @Performance
             let param = &ctx.heap[parameter_id];
             parameter_types.push(self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, false));
+        }
                         (parameter_types, InferenceType::new(false, true, vec![InferenceTypePart::Void]))
         let return_type = match returned {
             None => {
                 // Component, so returns a "Void"
                 InferenceType::new(false, true, vec![InferenceTypePart::Void])
             },
                     Definition::Function(definition) => {
                         debug_assert_eq!(poly_vars.len(), definition.poly_vars.len());
                         let mut parameter_types = Vec::with_capacity(definition.parameters.len());
                         for param_id in definition.parameters.clone() {
                             let param = &ctx.heap[param_id];
                             parameter_types.push(self.determine_inference_type_from_parser_type(ctx, &param.parser_type, false));
+                        }
                         debug_assert_eq!(definition.return_types.len(), 1, "multiple return types not yet implemented");
                         let return_type = self.determine_inference_type_from_parser_type(ctx, &definition.return_types[0], false);
                         (parameter_types, return_type)
                     },
                     Definition::Struct(_) | Definition::Enum(_) | Definition::Union(_) => {
                         unreachable!("insert initial polymorph data for struct/enum/union");
+                    }
+                }
             Some(returned) => {
                 debug_assert_eq!(returned.len(), 1);
                 let returned = &returned[0];
                 self.determine_inference_type_from_parser_type_elements(&returned.elements, false)
+            }
         };
         self.extra_data.insert(call_id.upcast(), ExtraData {
             poly_vars,
             embedded: embedded_types,
             poly_vars: poly_args,
             embedded: parameter_types,
             returned: return_type
         });
+    }
     fn insert_initial_struct_polymorph_data(
         &mut self, ctx: &mut Ctx, lit_id: LiteralExpressionId,
     ) {
         use InferenceTypePart as ITP;
         let literal = ctx.heap[lit_id].value.as_struct();
         // Handle polymorphic arguments
-        let mut poly_vars = Vec::with_capacity(literal.poly_args2.len());
+        let num_embedded = literal.parser_type.elements[0].variant.num_embedded();
         let mut total_num_poly_parts = 0;
         for poly_arg_type_id in literal.poly_args2.clone() { // TODO: @performance
             let inference_type = self.determine_inference_type_from_parser_type(
                 ctx, poly_arg_type_id, true
             );
             total_num_poly_parts += inference_type.parts.len();
             poly_vars.push(inference_type);
         let mut poly_args = Vec::with_capacity(num_embedded);
         for embedded_elements in literal.parser_type.iter_embedded(0) {
             let poly_type = self.determine_inference_type_from_parser_type_elements(embedded_elements, true);
             total_num_poly_parts += poly_type.parts.len();
             poly_args.push(poly_type);
+        }
         // Handle parser types on struct definition
         let definition = &ctx.heap[literal.definition.unwrap()];
         let definition = match definition {
             Definition::Struct(definition) => {
                 debug_assert_eq!(poly_vars.len(), definition.poly_vars.len());
                 definition
             },
             _ => unreachable!("definition for struct literal does not point to struct definition")
         };
         let defined_type = ctx.types.get_base_definition(&literal.definition).unwrap();
         let struct_type = defined_type.definition.as_struct();
         debug_assert_eq!(poly_args.len(), defined_type.poly_vars.len());
         // Note: programmer is capable of specifying fields in a struct literal
         // in a different order than on the definition. We take the literal-
         // specified order to be leading.
-        let mut embedded_types = Vec::with_capacity(definition.fields.len());
+        let mut embedded_types = Vec::with_capacity(struct_type.fields.len());
         for lit_field in literal.fields.iter() {
             let def_field = &definition.fields[lit_field.field_idx];
             let inference_type = self.determine_inference_type_from_parser_type(
                 ctx, &def_field.parser_type, false
             );
             let def_field = &struct_type.fields[lit_field.field_idx];
             let inference_type = self.determine_inference_type_from_parser_type_elements(&def_field.parser_type.elements, false);
             embedded_types.push(inference_type);
+        }
         // Return type is the struct type itself, with the appropriate
         // polymorphic variables. So:
         // - 1 part for definition
         // - N_poly_arg marker parts for each polymorphic argument
         // - all the parts for the currently known polymorphic arguments
-        let parts_reserved = 1 + poly_vars.len() + total_num_poly_parts;
+        let parts_reserved = 1 + poly_args.len() + total_num_poly_parts;
         let mut parts = Vec::with_capacity(parts_reserved);
-        parts.push(ITP::Instance(definition.this.upcast(), poly_vars.len()));
+        parts.push(ITP::Instance(literal.definition, poly_args.len()));
         let mut return_type_done = true;
-        for (poly_var_idx, poly_var) in poly_vars.iter().enumerate() {
+        for (poly_var_idx, poly_var) in poly_args.iter().enumerate() {
             if !poly_var.is_done { return_type_done = false; }
             parts.push(ITP::MarkerBody(poly_var_idx));
             parts.extend(poly_var.parts.iter().cloned());
+        }
         debug_assert_eq!(parts.len(), parts_reserved);
-        let return_type = InferenceType::new(!poly_vars.is_empty(), return_type_done, parts);
+        let return_type = InferenceType::new(!poly_args.is_empty(), return_type_done, parts);
         self.extra_data.insert(lit_id.upcast(), ExtraData{
-            poly_vars,
+            poly_vars: poly_args,
             embedded: embedded_types,
             returned: return_type,
         });
+    }
     /// Inserts the extra polymorphic data struct for enum expressions. These
@@ @@ -2970,39 +2943,39 @@ impl PassTyping { @@
         &mut self, ctx: &Ctx, lit_id: LiteralExpressionId
     ) {
         use InferenceTypePart as ITP;
         let literal = ctx.heap[lit_id].value.as_enum();
         // Handle polymorphic arguments to the enum
-        let mut poly_vars = Vec::with_capacity(literal.poly_args2.len());
+        let num_poly_args = literal.parser_type.elements[0].variant.num_embedded();
         let mut total_num_poly_parts = 0;
         for poly_arg_type_id in literal.poly_args2.clone() { // TODO: @performance
             let inference_type = self.determine_inference_type_from_parser_type(
                 ctx, poly_arg_type_id, true
             );
             total_num_poly_parts += inference_type.parts.len();
             poly_vars.push(inference_type);
         let mut poly_args = Vec::with_capacity(num_poly_args);
         for embedded_elements in literal.parser_type.iter_embedded(0) {
             let poly_type = self.determine_inference_type_from_parser_type_elements(embedded_elements, true);
             total_num_poly_parts += poly_type.parts.len();
             poly_args.push(poly_type);
+        }
         // Handle enum type itself
-        let parts_reserved = 1 + poly_vars.len() + total_num_poly_parts;
+        let parts_reserved = 1 + poly_args.len() + total_num_poly_parts;
         let mut parts = Vec::with_capacity(parts_reserved);
-        parts.push(ITP::Instance(literal.definition.unwrap(), poly_vars.len()));
+        parts.push(ITP::Instance(literal.definition, poly_args.len()));
         let mut enum_type_done = true;
-        for (poly_var_idx, poly_var) in poly_vars.iter().enumerate() {
+        for (poly_var_idx, poly_var) in poly_args.iter().enumerate() {
             if !poly_var.is_done { enum_type_done = false; }
             parts.push(ITP::MarkerBody(poly_var_idx));
             parts.extend(poly_var.parts.iter().cloned());
+        }
         debug_assert_eq!(parts.len(), parts_reserved);
-        let enum_type = InferenceType::new(!poly_vars.is_empty(), enum_type_done, parts);
+        let enum_type = InferenceType::new(!poly_args.is_empty(), enum_type_done, parts);
         self.extra_data.insert(lit_id.upcast(), ExtraData{
             poly_vars,
+            poly_vars: poly_args,
             embedded: Vec::new(),
             returned: enum_type,
         });
+    }
     /// Inserts the extra polymorphic data struct for unions. The polymorphic
@@ @@ -3011,56 +2984,54 @@ impl PassTyping { @@
         &mut self, ctx: &Ctx, lit_id: LiteralExpressionId
     ) {
         use InferenceTypePart as ITP;
         let literal = ctx.heap[lit_id].value.as_union();
         // Construct the polymorphic variables
-        let mut poly_vars = Vec::with_capacity(literal.poly_args2.len());
+        let num_poly_args = literal.parser_type.elements[0].variant.num_embedded();
         let mut total_num_poly_parts = 0;
         for poly_arg_type_id in literal.poly_args2.clone() { // TODO: @performance
             let inference_type = self.determine_inference_type_from_parser_type(
                 ctx, poly_arg_type_id, true
             );
             total_num_poly_parts += inference_type.parts.len();
             poly_vars.push(inference_type);
         let mut poly_args = Vec::with_capacity(num_poly_args);
         for embedded_elements in literal.parser_type.iter_embedded(0) {
             let poly_type = self.determine_inference_type_from_parser_type_elements(embedded_elements, true);
             total_num_poly_parts += poly_type.parts.len();
             poly_args.push(poly_type);
+        }
         // Handle any of the embedded values in the variant, if specified
         let definition_id = literal.definition.unwrap();
         let union_definition = ctx.types.get_base_definition(&definition_id)
             .unwrap()
             .definition.as_union();
         let definition_id = literal.definition;
         let type_definition = ctx.types.get_base_definition(&definition_id).unwrap();
         let union_definition = type_definition.definition.as_union();
         debug_assert_eq!(poly_args.len(), type_definition.poly_vars.len());
         let variant_definition = &union_definition.variants[literal.variant_idx];
         debug_assert_eq!(variant_definition.embedded.len(), literal.values.len());
         let mut embedded = Vec::with_capacity(variant_definition.embedded.len());
         for embedded_parser_type in &variant_definition.embedded {
             let inference_type = self.determine_inference_type_from_parser_type(
                 ctx, embedded_parser_type, false
             );
             let inference_type = self.determine_inference_type_from_parser_type_elements(&embedded_parser_type.elements, false);
             embedded.push(inference_type);
+        }
         // Handle the type of the union itself
-        let parts_reserved = 1 + poly_vars.len() + total_num_poly_parts;
+        let parts_reserved = 1 + poly_args.len() + total_num_poly_parts;
         let mut parts = Vec::with_capacity(parts_reserved);
-        parts.push(ITP::Instance(definition_id, poly_vars.len()));
+        parts.push(ITP::Instance(definition_id, poly_args.len()));
         let mut union_type_done = true;
-        for (poly_var_idx, poly_var) in poly_vars.iter().enumerate() {
+        for (poly_var_idx, poly_var) in poly_args.iter().enumerate() {
             if !poly_var.is_done { union_type_done = false; }
             parts.push(ITP::MarkerBody(poly_var_idx));
             parts.extend(poly_var.parts.iter().cloned());
+        }
         debug_assert_eq!(parts_reserved, parts.len());
-        let union_type = InferenceType::new(!poly_vars.is_empty(), union_type_done, parts);
+        let union_type = InferenceType::new(!poly_args.is_empty(), union_type_done, parts);
         self.extra_data.insert(lit_id.upcast(), ExtraData{
             poly_vars,
+            poly_vars: poly_args,
             embedded,
             returned: union_type
         });
+    }
     /// Inserts the extra polymorphic data struct. Assumes that the select
@@ @@ -3076,12 +3047,13 @@ impl PassTyping { @@
         let definition_id = field.definition.unwrap();
         let definition = ctx.heap[definition_id].as_struct();
         let field_idx = field.field_idx;
         // Generate initial polyvar types and struct type
         // TODO: @Performance: we can immediately set the polyvars of the subject's struct type
         let num_poly_vars = definition.poly_vars.len();
         let mut poly_vars = Vec::with_capacity(num_poly_vars);
         let struct_parts_reserved = 1 + 2 * num_poly_vars;
         let mut struct_parts = Vec::with_capacity(struct_parts_reserved);
         struct_parts.push(ITP::Instance(definition_id, num_poly_vars));
@@ @@ -3092,16 +3064,13 @@ impl PassTyping { @@
             struct_parts.push(ITP::MarkerBody(poly_idx));
             struct_parts.push(ITP::Unknown);
+        }
         debug_assert_eq!(struct_parts.len(), struct_parts_reserved);
         // Generate initial field type
         let field_type = self.determine_inference_type_from_parser_type(
             ctx, &definition.fields[field_idx].parser_type, false
         );
         let field_type = self.determine_inference_type_from_parser_type_elements(&definition.fields[field_idx].parser_type.elements, false);
         self.extra_data.insert(select_id.upcast(), ExtraData{
             poly_vars,
             embedded: vec![InferenceType::new(num_poly_vars != 0, num_poly_vars == 0, struct_parts)],
             returned: field_type
         });
+    }
@@ @@ -3115,24 +3084,24 @@ impl PassTyping { @@
     /// 2. To resolve a ParserType on a called function's definition or on
     ///     an instantiated datatype's members. This means that the polymorphic
     ///     arguments inside those ParserTypes refer to the polymorphic
     ///     variables in the called/instantiated type's definition.
     /// In the second case we place InferenceTypePart::Marker instances such
     /// that we can perform type inference on the polymorphic variables.
     fn determine_inference_type_from_parser_type(
         &mut self, ctx: &Ctx, parser_type: &ParserType,
     fn determine_inference_type_from_parser_type_elements(
         &mut self, elements: &[ParserTypeElement],
         parser_type_in_body: bool
     ) -> InferenceType {
         use ParserTypeVariant as PTV;
         use InferenceTypePart as ITP;
-        let mut infer_type = Vec::with_capacity(parser_type.elements.len());
         let mut infer_type = Vec::with_capacity(elements.len());
         let mut has_inferred = false;
         let mut has_markers = false;
-        for element in &parser_type.elements {
         for element in elements {
             match &element.variant {
                 PTV::Message => {
                     // TODO: @types Remove the Message -> Byte hack at some point...
                     infer_type.push(ITP::Message);
                     infer_type.push(ITP::UInt8);
                 },
@@ @@ -3157,13 +3126,13 @@ impl PassTyping { @@
                 PTV::Output => { infer_type.push(ITP::Output); },
                 PTV::PolymorphicArgument(belongs_to_definition, poly_arg_idx) => {
                     let poly_arg_idx = *poly_arg_idx;
                     if parser_type_in_body {
                         // Refers to polymorphic argument on procedure we're currently processing.
                         // This argument is already known.
                         debug_assert_eq!(belongs_to_definition, self.definition_type.definition_id());
+                        debug_assert_eq!(*belongs_to_definition, self.definition_type.definition_id());
                         debug_assert!((poly_arg_idx as usize) < self.poly_vars.len());
                         infer_type.push(ITP::MarkerDefinition(poly_arg_idx as usize));
                         for concrete_part in &self.poly_vars[poly_arg_idx].parts {
                             infer_type.push(ITP::from(*concrete_part));
+                        }
@@ @@ -3200,13 +3169,13 @@ impl PassTyping { @@
         return ParseError::new_error_at_span(
             &ctx.module.source, expr.span(), format!(
                 "incompatible types: this expression expected a '{}'",
                 expr_type.display_name(&ctx.heap)
+            )
-        ).with_postfixed_info(
+        ).with_info_at_span(
             &ctx.module.source, arg_expr.span(), format!(
                 "but this expression yields a '{}'",
                 arg_type.display_name(&ctx.heap)
+            )
+        )
+    }
@@ @@ -3310,15 +3279,15 @@ impl PassTyping { @@
                             poly_var, func_name
+                        )
+                    )
                 },
                 Expression::Literal(expr) => {
                     let definition_id = match &expr.value {
                         Literal::Struct(v) => v.definition.unwrap(),
                         Literal::Enum(v) => v.definition.unwrap(),
                         Literal::Union(v) => v.definition.unwrap(),
                         Literal::Struct(v) => v.definition,
                         Literal::Enum(v) => v.definition,
                         Literal::Union(v) => v.definition,
                         _ => unreachable!(),
                     };
                     let (poly_var, type_name) = get_poly_var_and_definition_name(ctx, poly_var_idx, definition_id);
                     return ParseError::new_error_at_span(
                         &ctx.module.source, expr.span, format!(
@@ @@ -3328,13 +3297,13 @@ impl PassTyping { @@
                     );
                 },
                 Expression::Select(expr) => {
                     let field = expr.field.as_symbolic();
                     let (poly_var, struct_name) = get_poly_var_and_definition_name(ctx, poly_var_idx, field.definition.unwrap());
                     return ParseError::new_error_at_span(
-                        &ctx.module.source, expr.position(), format!(
+                        &ctx.module.source, expr.span, format!(
                             "Conflicting type for polymorphic variable '{}' while accessing field '{}' of '{}'",
                             poly_var, field.identifier.value.as_str(), struct_name
+                        )
+                    )
+                }
                 _ => unreachable!("called construct_poly_arg_error without an expected expression, got: {:?}", expr)
@@ @@ -3430,13 +3399,13 @@ impl PassTyping { @@
                     .with_info_at_span(
                         &ctx.module.source, arg.span(), format!(
                             "This argument inferred it to '{}'",
                             InferenceType::partial_display_name(&ctx.heap, section_arg)
+                        )
+                    )
-                    .with_postfixed_info(
+                    .with_info_at_span(
                         &ctx.module.source, expr.span(), format!(
                             "While the {} inferred it to '{}'",
                             expr_return_name,
                             InferenceType::partial_display_name(&ctx.heap, section_ret)
+                        )
                     );

src/protocol/parser/pass_validation_linking.rs

➞

Show inline comments

@@ @@ -260,14 +260,15 @@ impl Visitor2 for PassValidationLinking { @@
                 "return statements may only appear in function bodies"
             ));
+        }
         // If here then we are within a function
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         debug_assert_eq!(ctx.heap[id].expressions.len(), 1);
         self.expr_parent = ExpressionParent::Return(id);
-        self.visit_expr(ctx, ctx.heap[id].expression)?;
+        self.visit_expr(ctx, ctx.heap[id].expressions[0])?;
         self.expr_parent = ExpressionParent::None;
         Ok(())
+    }
     fn visit_goto_stmt(&mut self, ctx: &mut Ctx, id: GotoStatementId) -> VisitorResult {
@@ @@ -281,14 +282,14 @@ impl Visitor2 for PassValidationLinking { @@
             // not match, then we must be inside a sync scope
             debug_assert!(self.in_sync.is_some());
             let goto_stmt = &ctx.heap[id];
             let sync_stmt = &ctx.heap[self.in_sync.unwrap()];
             return Err(
                 ParseError::new_error_str_at_span(&ctx.module.source, goto_stmt.span, "goto may not escape the surrounding synchronous block")
                 .with_postfixed_info(&ctx.module.source, target.label.span, "this is the target of the goto statement")
                 .with_postfixed_info(&ctx.module.source, sync_stmt.span, "which will jump past this statement")
                 .with_info_str_at_span(&ctx.module.source, target.label.span, "this is the target of the goto statement")
                 .with_info_str_at_span(&ctx.module.source, sync_stmt.span, "which will jump past this statement")
             );
+        }
         Ok(())
+    }
@@ @@ -478,26 +479,28 @@ impl Visitor2 for PassValidationLinking { @@
                 specified.resize(struct_definition.fields.len(), false);
                 for field in &mut literal.fields {
                     // Find field in the struct definition
                     let field_idx = struct_definition.fields.iter().position(|v| v.identifier == field.identifier);
                     if field_idx.is_none() {
                         let field_span = field.identifier.span;
                         let literal = ctx.heap[id].value.as_struct();
                         let ast_definition = &ctx.heap[literal.definition];
                         return Err(ParseError::new_error_at_span(
-                            &ctx.module.source, field.identifier.span, format!(
+                            &ctx.module.source, field_span, format!(
                                 "This field does not exist on the struct '{}'",
                                 ast_definition.identifier().value.as_str()
+                            )
                         ));
+                    }
                     field.field_idx = field_idx.unwrap();
                     // Check if specified more than once
                     if specified[field.field_idx] {
                         return Err(ParseError::new_error(
                             &ctx.module.source, field.identifier.position,
                         return Err(ParseError::new_error_str_at_span(
                             &ctx.module.source, field.identifier.span,
                             "This field is specified more than once"
                         ));
+                    }
                     specified[field.field_idx] = true;
+                }
@@ @@ -548,12 +551,13 @@ impl Visitor2 for PassValidationLinking { @@
                 let variant_idx = enum_definition.variants.iter().position(|v| {
                     v.identifier == literal.variant
                 });
                 if variant_idx.is_none() {
                     let literal = ctx.heap[id].value.as_enum();
                     let ast_definition = ctx.heap[literal.definition].as_enum();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, literal.parser_type.elements[0].full_span, format!(
                             "the variant '{}' does not exist on the enum '{}'",
                             literal.variant.value.as_str(), ast_definition.identifier.value.as_str()
+                        )
@@ @@ -568,12 +572,13 @@ impl Visitor2 for PassValidationLinking { @@
                 let union_definition = type_definition.definition.as_union();
                 let variant_idx = union_definition.variants.iter().position(|v| {
                     v.identifier == literal.variant
                 });
                 if variant_idx.is_none() {
                     let literal = ctx.heap[id].value.as_union();
                     let ast_definition = ctx.heap[literal.definition].as_union();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, literal.parser_type.elements[0].full_span, format!(
                             "the variant does '{}' does not exist on the union '{}'",
                             literal.variant.value.as_str(), ast_definition.identifier.value.as_str()
+                        )
@@ @@ -583,12 +588,13 @@ impl Visitor2 for PassValidationLinking { @@
                 literal.variant_idx = variant_idx.unwrap();
                 // Make sure the number of specified values matches the expected
                 // number of embedded values in the union variant.
                 let union_variant = &union_definition.variants[literal.variant_idx];
                 if union_variant.embedded.len() != literal.values.len() {
                     let literal = ctx.heap[id].value.as_union();
                     let ast_definition = ctx.heap[literal.definition].as_union();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, literal.parser_type.elements[0].full_span, format!(
                             "The variant '{}' of union '{}' expects {} embedded values, but {} were specified",
                             literal.variant.value.as_str(), ast_definition.identifier.value.as_str(),
                             union_variant.embedded.len(), literal.values.len()
@@ @@ -615,13 +621,13 @@ impl Visitor2 for PassValidationLinking { @@
             Literal::Array(literal) => {
                 // Visit all expressions in the array
                 let upcast_id = id.upcast();
                 let expr_section = self.expression_buffer.start_section_initialized(literal);
                 for expr_idx in 0..expr_section.len() {
                     let expr_id = expr_section[expr_idx];
-                    self.expr_parent = ExpressionParent::Expression(upcast_id, expr_id as u32);
+                    self.expr_parent = ExpressionParent::Expression(upcast_id, expr_idx as u32);
                     self.visit_expr(ctx, expr_id)?;
+                }
                 expr_section.forget();
+            }
+        }
@@ @@ -700,33 +706,33 @@ impl Visitor2 for PassValidationLinking { @@
             Method::UserComponent => {
                 expected_wrapping_new_stmt = true;
             },
+        }
         if expected_wrapping_new_stmt {
-            if self.expr_parent != ExpressionParent::New {
+            if !self.expr_parent.is_new() {
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module.source, call_expr.span,
                     "cannot call a component, it can only be instantiated by using 'new'"
                 ));
+            }
         } else {
-            if self.expr_parent == ExpressionParent::New {
+            if self.expr_parent.is_new() {
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module.source, call_expr.span,
                     "only components can be instantiated"
+                    "only components can be instantiated, this is a function"
                 ));
+            }
+        }
         // Check the number of arguments
         let call_definition = ctx.types.get_base_definition(&call_expr.definition).unwrap();
         let num_expected_args = match &call_definition.definition {
             DefinedTypeVariant::Function(definition) => definition.arguments.len(),
             DefinedTypeVariant::Component(definition) => definition.arguments.len(),
-            v => unreachable!("encountered {:?} type in call expression", v),
+            v => unreachable!("encountered {} type in call expression", v.type_class()),
         };
         let num_provided_args = call_expr.arguments.len();
         if num_provided_args != num_expected_args {
             let argument_text = if num_expected_args == 1 { "argument" } else { "arguments" };
             return Err(ParseError::new_error_at_span(
@@ @@ -825,14 +831,15 @@ impl PassValidationLinking { @@
                         self.checked_local_add(ctx, relative_pos, to_id)?;
+                    }
+                }
+            }
             Statement::Labeled(stmt) => {
                 let stmt_id = stmt.this;
                 let body_id = stmt.body;
                 self.checked_label_add(ctx, relative_pos, self.in_sync, stmt_id)?;
-                self.visit_statement_for_locals_labels_and_in_sync(ctx, relative_pos, stmt.body)?;
+                self.visit_statement_for_locals_labels_and_in_sync(ctx, relative_pos, body_id)?;
             },
             Statement::While(stmt) => {
                 stmt.in_sync = self.in_sync;
             },
             _ => {},
+        }
@@ @@ -852,16 +859,16 @@ impl PassValidationLinking { @@
         // Make sure we do not conflict with any global symbols
         let cur_scope = SymbolScope::Definition(self.def_type.definition_id());
+        {
             let ident = &ctx.heap[id].identifier;
             if let Some(symbol) = ctx.symbols.get_symbol_by_name(cur_scope, &ident.value.as_bytes()) {
                 return Err(ParseError::new_error_str_at_span(
-                    &ctx.module.source, symbol.variant.span_of_introduction(&ctx.heap),
+                    &ctx.module.source, ident.span,
                     "local variable declaration conflicts with symbol"
                 ).with_postfixed_info(
                     &ctx.module.source, symbol.position, "the conflicting symbol is introduced here"
                 ).with_info_str_at_span(
                     &ctx.module.source, symbol.variant.span_of_introduction(&ctx.heap), "the conflicting symbol is introduced here"
                 ));
+            }
+        }
         let local = &mut ctx.heap[id];
         local.relative_pos_in_block = relative_pos;
@@ @@ -882,14 +889,17 @@ impl PassValidationLinking { @@
                 // in which the current variable resides.
                 if local.this != *other_local_id &&
                     local_relative_pos >= other_local.relative_pos_in_block &&
                     local.identifier == other_local.identifier {
                     // Collision within this scope
                     return Err(
                         ParseError::new_error(&ctx.module.source, local.position, "Local variable name conflicts with another variable")
                             .with_postfixed_info(&ctx.module.source, other_local.position, "Previous variable is found here")
                         ParseError::new_error_str_at_span(
                             &ctx.module.source, local.identifier.span, "Local variable name conflicts with another variable"
                         ).with_info_str_at_span(
                             &ctx.module.source, other_local.identifier.span, "Previous variable is found here"
+                        )
                     );
+                }
+            }
             // Current scope is fine, move to parent scope if any
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
@@ @@ -897,14 +907,17 @@ impl PassValidationLinking { @@
             if let Scope::Definition(definition_id) = scope {
                 // At outer scope, check parameters of function/component
                 for parameter_id in ctx.heap[*definition_id].parameters() {
                     let parameter = &ctx.heap[*parameter_id];
                     if local.identifier == parameter.identifier {
                         return Err(
                             ParseError::new_error(&ctx.module.source, local.position, "Local variable name conflicts with parameter")
                                 .with_postfixed_info(&ctx.module.source, parameter.position, "Parameter definition is found here")
                             ParseError::new_error_str_at_span(
                                 &ctx.module.source, local.identifier.span, "Local variable name conflicts with parameter"
                             ).with_info_str_at_span(
                                 &ctx.module.source, parameter.span, "Parameter definition is found here"
+                            )
                         );
+                    }
+                }
                 break;
+            }
@@ @@ -934,13 +947,13 @@ impl PassValidationLinking { @@
             debug_assert!(scope.is_block());
             let block = &ctx.heap[scope.to_block()];
             for local_id in &block.locals {
                 let local = &ctx.heap[*local_id];
-                if local.relative_pos_in_block < relative_pos && identifier.matches_identifier(&local.identifier) {
+                if local.relative_pos_in_block < relative_pos && identifier == &local.identifier {
                     return Ok(local_id.upcast());
+                }
+            }
             debug_assert!(block.parent_scope.is_some());
             scope = block.parent_scope.as_ref().unwrap();
@@ @@ -948,13 +961,13 @@ impl PassValidationLinking { @@
                 // Definition scope, need to check arguments to definition
                 match scope {
                     Scope::Definition(definition_id) => {
                         let definition = &ctx.heap[*definition_id];
                         for parameter_id in definition.parameters() {
                             let parameter = &ctx.heap[*parameter_id];
-                            if identifier.matches_identifier(&parameter.identifier) {
+                            if identifier == &parameter.identifier {
                                 return Ok(parameter_id.upcast());
+                            }
+                        }
                     },
                     _ => unreachable!(),
+                }
@@ @@ -977,25 +990,25 @@ impl PassValidationLinking { @@
         // Make sure label is not defined within the current scope or any of the
         // parent scope.
         let label = &mut ctx.heap[id];
         label.relative_pos_in_block = relative_pos;
         label.in_sync = in_sync;
-        let label = &*label;
+        let label = &ctx.heap[id];
         let mut scope = self.cur_scope.as_ref().unwrap();
         loop {
             debug_assert!(scope.is_block(), "scope is not a block");
             let block = &ctx.heap[scope.to_block()];
             for other_label_id in &block.labels {
                 let other_label = &ctx.heap[*other_label_id];
                 if other_label.label == label.label {
                     // Collision
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module.source, label.label.span, "label name is used more than once"
-                    ).with_postfixed_info(
+                    ).with_info_str_at_span(
                         &ctx.module.source, other_label.label.span, "the other label is found here"
                     ));
+                }
+            }
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
@@ @@ -1033,14 +1046,14 @@ impl PassValidationLinking { @@
                         //  is not actually being used. I might be missing
                         //  something here when laying out the bytecode...
                         let local = &ctx.heap[*local_id];
                         if local.relative_pos_in_block > relative_scope_pos && local.relative_pos_in_block < label.relative_pos_in_block {
                             return Err(
                                 ParseError::new_error_str_at_span(&ctx.module.source, identifier.span, "this target label skips over a variable declaration")
                                 .with_postfixed_info(&ctx.module.source, label.label.span, "because it jumps to this label")
                                 .with_postfixed_info(&ctx.module.source, local.identifier.span, "which skips over this variable")
                                 .with_info_str_at_span(&ctx.module.source, label.label.span, "because it jumps to this label")
                                 .with_info_str_at_span(&ctx.module.source, local.identifier.span, "which skips over this variable")
                             );
+                        }
+                    }
                     return Ok(*label_id);
+                }
+            }
@@ @@ -1062,13 +1075,13 @@ impl PassValidationLinking { @@
         debug_assert!(self.cur_scope.is_some());
         let mut scope = self.cur_scope.as_ref().unwrap();
         let while_stmt = &ctx.heap[id];
         loop {
             debug_assert!(scope.is_block());
             let block = scope.to_block();
-            if while_stmt.body == block.upcast() {
             if while_stmt.body == block {
                 return true;
+            }
             let block = &ctx.heap[block];
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();

src/protocol/parser/symbol_table.rs

➞

Show inline comments

@@ @@ -123,29 +123,15 @@ impl SymbolVariant { @@
             } else {
                 v.identifier_span
             },
+        }
+    }
     pub(crate) fn as_module(&self) -> &SymbolModule {
         match self {
             SymbolVariant::Module(v) => v,
             SymbolVariant::Definition(_) => unreachable!("called 'as_module' on {:?}", self),
+        }
+    }
     pub(crate) fn as_definition(&self) -> &SymbolDefinition {
         match self {
             SymbolVariant::Module(v) => unreachable!("called 'as_definition' on {:?}", self),
             SymbolVariant::Definition(v) => v,
+        }
+    }
     pub(crate) fn as_definition_mut(&mut self) -> &mut SymbolDefinition {
         match self {
             SymbolVariant::Module(v) => unreachable!("called 'as_definition_mut' on {:?}", self),
             SymbolVariant::Module(_) => unreachable!("called 'as_definition' on {:?}", self),
             SymbolVariant::Definition(v) => v,
+        }
+    }
+}
 /// TODO: @Cleanup - remove clone everywhere
@@ @@ -220,20 +206,21 @@ impl SymbolTable { @@
+    }
     /// Inserts a symbol into a particular scope. The symbol's name may not
     /// exist in the scope or any of its parents. If it does collide then the
     /// symbol will be returned, together with the symbol that has the same
     /// name.
     pub(crate) fn insert_symbol(&mut self, in_scope: SymbolScope, symbol: Symbol) -> Result<(), (Symbol, &Symbol)> {
     // Note: we do not return a reference because Rust doesn't like it.
     pub(crate) fn insert_symbol(&mut self, in_scope: SymbolScope, symbol: Symbol) -> Result<(), (Symbol, Symbol)> {
         debug_assert!(self.scope_lookup.contains_key(&in_scope), "inserting symbol {}, but scope {:?} does not exist", symbol.name.as_str(), in_scope);
         let mut seek_scope = in_scope;
         loop {
             let scoped_symbols = self.scope_lookup.get(&seek_scope).unwrap();
             for existing_symbol in scoped_symbols.symbols.iter() {
                 if symbol.name == existing_symbol.name {
                     return Err((symbol, existing_symbol))
+                    return Err((symbol, existing_symbol.clone()))
+                }
+            }
             match scoped_symbols.parent_scope {
                 Some(parent_scope) => { seek_scope = parent_scope; },
                 None => { break; }

src/protocol/parser/token_parsing.rs

➞

Show inline comments

-use crate::collections::{StringRef, ScopedSection};
 use crate::collections::ScopedSection;
 use crate::protocol::ast::*;
 use crate::protocol::input_source::{
     InputSource as InputSource,
     InputPosition as InputPosition,
     InputSpan,
     ParseError,
 };
 use super::tokens::*;
 use super::symbol_table::*;
-use super::{Module, ModuleCompilationPhase, PassCtx};
 use super::{Module, PassCtx};
 // Keywords
 pub(crate) const KW_LET:       &'static [u8] = b"let";
 pub(crate) const KW_AS:        &'static [u8] = b"as";
 pub(crate) const KW_STRUCT:    &'static [u8] = b"struct";
 pub(crate) const KW_ENUM:      &'static [u8] = b"enum";
 pub(crate) const KW_STMT_GOTO:     &'static [u8] = b"goto";
 pub(crate) const KW_STMT_RETURN:   &'static [u8] = b"return";
 pub(crate) const KW_STMT_SYNC:     &'static [u8] = b"synchronous";
 pub(crate) const KW_STMT_NEW:      &'static [u8] = b"new";
 // Keywords - types
 pub(crate) const KW_TYPE_IN_PORT:  &'static [u8] = b"in";
 pub(crate) const KW_TYPE_OUT_PORT: &'static [u8] = b"out";
 pub(crate) const KW_TYPE_MESSAGE:  &'static [u8] = b"msg";
 pub(crate) const KW_TYPE_BOOL:     &'static [u8] = b"bool";
 pub(crate) const KW_TYPE_UINT8:    &'static [u8] = b"u8";
 pub(crate) const KW_TYPE_UINT16:   &'static [u8] = b"u16";
 pub(crate) const KW_TYPE_UINT32:   &'static [u8] = b"u32";
 pub(crate) const KW_TYPE_UINT64:   &'static [u8] = b"u64";
 pub(crate) const KW_TYPE_SINT8:    &'static [u8] = b"s8";
 pub(crate) const KW_TYPE_SINT16:   &'static [u8] = b"s16";
 pub(crate) const KW_TYPE_SINT32:   &'static [u8] = b"s32";
 pub(crate) const KW_TYPE_SINT64:   &'static [u8] = b"s64";
 pub(crate) const KW_TYPE_CHAR:     &'static [u8] = b"char";
 pub(crate) const KW_TYPE_STRING:   &'static [u8] = b"string";
 pub(crate) const KW_TYPE_INFERRED: &'static [u8] = b"auto";
 // Since types are needed for returning diagnostic information to the user, the
 // string variants are put here as well.
 pub(crate) const KW_TYPE_IN_PORT_STR:  &'static str = "in";
 pub(crate) const KW_TYPE_OUT_PORT_STR: &'static str = "out";
 pub(crate) const KW_TYPE_MESSAGE_STR:  &'static str = "msg";
 pub(crate) const KW_TYPE_BOOL_STR:     &'static str = "bool";
 pub(crate) const KW_TYPE_UINT8_STR:    &'static str = "u8";
 pub(crate) const KW_TYPE_UINT16_STR:   &'static str = "u16";
 pub(crate) const KW_TYPE_UINT32_STR:   &'static str = "u32";
 pub(crate) const KW_TYPE_UINT64_STR:   &'static str = "u64";
 pub(crate) const KW_TYPE_SINT8_STR:    &'static str = "s8";
 pub(crate) const KW_TYPE_SINT16_STR:   &'static str = "s16";
 pub(crate) const KW_TYPE_SINT32_STR:   &'static str = "s32";
 pub(crate) const KW_TYPE_SINT64_STR:   &'static str = "s64";
 pub(crate) const KW_TYPE_CHAR_STR:     &'static str = "char";
 pub(crate) const KW_TYPE_STRING_STR:   &'static str = "string";
 pub(crate) const KW_TYPE_INFERRED_STR: &'static str = "auto";
 pub(crate) const KW_TYPE_IN_PORT:  &'static [u8] = KW_TYPE_IN_PORT_STR.as_bytes();
 pub(crate) const KW_TYPE_OUT_PORT: &'static [u8] = KW_TYPE_OUT_PORT_STR.as_bytes();
 pub(crate) const KW_TYPE_MESSAGE:  &'static [u8] = KW_TYPE_MESSAGE_STR.as_bytes();
 pub(crate) const KW_TYPE_BOOL:     &'static [u8] = KW_TYPE_BOOL_STR.as_bytes();
 pub(crate) const KW_TYPE_UINT8:    &'static [u8] = KW_TYPE_UINT8_STR.as_bytes();
 pub(crate) const KW_TYPE_UINT16:   &'static [u8] = KW_TYPE_UINT16_STR.as_bytes();
 pub(crate) const KW_TYPE_UINT32:   &'static [u8] = KW_TYPE_UINT32_STR.as_bytes();
 pub(crate) const KW_TYPE_UINT64:   &'static [u8] = KW_TYPE_UINT64_STR.as_bytes();
 pub(crate) const KW_TYPE_SINT8:    &'static [u8] = KW_TYPE_SINT8_STR.as_bytes();
 pub(crate) const KW_TYPE_SINT16:   &'static [u8] = KW_TYPE_SINT16_STR.as_bytes();
 pub(crate) const KW_TYPE_SINT32:   &'static [u8] = KW_TYPE_SINT32_STR.as_bytes();
 pub(crate) const KW_TYPE_SINT64:   &'static [u8] = KW_TYPE_SINT64_STR.as_bytes();
 pub(crate) const KW_TYPE_CHAR:     &'static [u8] = KW_TYPE_CHAR_STR.as_bytes();
 pub(crate) const KW_TYPE_STRING:   &'static [u8] = KW_TYPE_STRING_STR.as_bytes();
 pub(crate) const KW_TYPE_INFERRED: &'static [u8] = KW_TYPE_INFERRED_STR.as_bytes();
 /// A special trait for when consuming comma-separated things such that we can
 /// push them onto a `Vec` and onto a `ScopedSection`. As we monomorph for
 /// very specific comma-separated cases I don't expect polymorph bloat.
 /// Also, I really don't like this solution.
 pub(crate) trait Extendable {
@@ @@ -79,13 +97,13 @@ impl<T> Extendable for Vec<T> { @@
     #[inline]
     fn push(&mut self, v: Self::Value) {
         (self as &mut Vec<T>).push(v);
+    }
+}
-impl<T: Sized + Copy> Extendable for ScopedSection<T> {
 impl<T: Sized> Extendable for ScopedSection<T> {
     type Value = T;
     #[inline]
     fn push(&mut self, v: Self::Value) {
         (self as &mut ScopedSection<T>).push(v);
+    }
     iter.consume();
     Ok(span)
+}
 /// Consumes a comma separated list until the closing delimiter is encountered
 pub(crate) fn consume_comma_separated_until<T, F, E>(
     close_delim: TokenKind, source: &InputSource, iter: &mut TokenIter,
     consumer_fn: F, target: &mut E, item_name_and_article: &'static str,
     close_delim: TokenKind, source: &InputSource, iter: &mut TokenIter, ctx: &mut PassCtx,
     mut consumer_fn: F, target: &mut E, item_name_and_article: &'static str,
     close_pos: Option<&mut InputPosition>
 ) -> Result<(), ParseError>
-    where F: Fn(&InputSource, &mut TokenIter) -> Result<T, ParseError>,
+    where F: FnMut(&InputSource, &mut TokenIter, &mut PassCtx) -> Result<T, ParseError>,
           E: Extendable<Value=T>
+{
     let mut had_comma = true;
     let mut next;
     loop {
         next = iter.next();
@@ @@ -159,13 +177,13 @@ pub(crate) fn consume_comma_separated_until<T, F, E>( @@
             return Err(ParseError::new_error_at_pos(
                 source, iter.last_valid_pos(),
                 format!("expected a '{}', or {}", close_delim.token_chars(), item_name_and_article)
             ));
+        }
         let new_item = consumer_fn(source, iter)?;
+        let new_item = consumer_fn(source, iter, ctx)?;
         target.push(new_item);
         next = iter.next();
         had_comma = next == Some(TokenKind::Comma);
         if had_comma {
             iter.consume();
@@ @@ -180,34 +198,34 @@ pub(crate) fn consume_comma_separated_until<T, F, E>( @@
 /// Note that the potential cases may be:
 /// - No opening delimiter encountered, then we return `false`.
 /// - Both opening and closing delimiter encountered, but no items.
 /// - Opening and closing delimiter encountered, and items were processed.
 /// - Found an opening delimiter, but processing an item failed.
 pub(crate) fn maybe_consume_comma_separated<T, F, E>(
     open_delim: TokenKind, close_delim: TokenKind, source: &InputSource, iter: &mut TokenIter,
+    open_delim: TokenKind, close_delim: TokenKind, source: &InputSource, iter: &mut TokenIter, ctx: &mut PassCtx,
     consumer_fn: F, target: &mut E, item_name_and_article: &'static str,
     close_pos: Option<&mut InputPosition>
 ) -> Result<bool, ParseError>
-    where F: Fn(&InputSource, &mut TokenIter) -> Result<T, ParseError>,
+    where F: FnMut(&InputSource, &mut TokenIter, &mut PassCtx) -> Result<T, ParseError>,
           E: Extendable<Value=T>
+{
     let mut next = iter.next();
     if Some(open_delim) != next {
     if Some(open_delim) != iter.next() {
         return Ok(false);
+    }
     // Opening delimiter encountered, so must parse the comma-separated list.
     iter.consume();
     consume_comma_separated_until(close_delim, source, iter, consumer_fn, target, item_name_and_article, close_pos)?;
+    consume_comma_separated_until(close_delim, source, iter, ctx, consumer_fn, target, item_name_and_article, close_pos)?;
     Ok(true)
+}
 pub(crate) fn maybe_consume_comma_separated_spilled<F: Fn(&InputSource, &mut TokenIter) -> Result<(), ParseError>>(
     open_delim: TokenKind, close_delim: TokenKind, source: &InputSource, iter: &mut TokenIter,
     consumer_fn: F, item_name_and_article: &'static str
 pub(crate) fn maybe_consume_comma_separated_spilled<F: FnMut(&InputSource, &mut TokenIter, &mut PassCtx) -> Result<(), ParseError>>(
     open_delim: TokenKind, close_delim: TokenKind, source: &InputSource,
     iter: &mut TokenIter, ctx: &mut PassCtx,
     mut consumer_fn: F, item_name_and_article: &'static str
 ) -> Result<bool, ParseError> {
     let mut next = iter.next();
     if Some(open_delim) != next {
         return Ok(false);
+    }
             return Err(ParseError::new_error_at_pos(
                 source, iter.last_valid_pos(),
                 format!("expected a '{}', or {}", close_delim.token_chars(), item_name_and_article)
             ));
+        }
         consumer_fn(source, iter)?;
+        consumer_fn(source, iter, ctx)?;
         next = iter.next();
         had_comma = next == Some(TokenKind::Comma);
         if had_comma {
             iter.consume();
+        }
+    }
     Ok(true)
+}
 /// Consumes a comma-separated list and expected the opening and closing
 /// characters to be present. The returned array may still be empty
 pub(crate) fn consume_comma_separated<T, F, E>(
     open_delim: TokenKind, close_delim: TokenKind, source: &InputSource, iter: &mut TokenIter,
     open_delim: TokenKind, close_delim: TokenKind, source: &InputSource,
     iter: &mut TokenIter, ctx: &mut PassCtx,
     consumer_fn: F, target: &mut E, item_name_and_article: &'static str,
     list_name_and_article: &'static str, close_pos: Option<&mut InputPosition>
 ) -> Result<(), ParseError>
-    where F: Fn(&InputSource, &mut TokenIter) -> Result<T, ParseError>,
+    where F: FnMut(&InputSource, &mut TokenIter, &mut PassCtx) -> Result<T, ParseError>,
           E: Extendable<Value=T>
+{
     let first_pos = iter.last_valid_pos();
     match maybe_consume_comma_separated(
         open_delim, close_delim, source, iter, consumer_fn, target,
+        open_delim, close_delim, source, iter, ctx, consumer_fn, target,
         item_name_and_article, close_pos
     ) {
         Ok(true) => Ok(()),
         Ok(false) => {
             return Err(ParseError::new_error_at_pos(
                 source, first_pos,

src/protocol/parser/tokens.rs

➞

Show inline comments

@@ @@ -4,13 +4,13 @@ use crate::protocol::input_source::{ @@
 };
 /// Represents a particular kind of token. Some tokens represent
 /// variable-character tokens. Such a token is always followed by a
 /// `TokenKind::SpanEnd` token.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub(crate) enum TokenKind {
 pub enum TokenKind {
     // Variable-character tokens, followed by a SpanEnd token
     Ident,          // regular identifier
     Pragma,         // identifier with prefixed `#`, range includes `#`
     Integer,        // integer literal
     String,         // string literal, range includes `"`
     Character,      // character literal, range includes `'`
@@ @@ -29,14 +29,12 @@ pub(crate) enum TokenKind { @@
     CloseParen,     // )
     CloseSquare,    // ]
     Colon,          // :
     Comma,          // ,
     Dot,            // .
     SemiColon,      // ;
     Quote,          // '
     DoubleQuote,    // "
     // Operator-like (single character)
     At,             // @
     Plus,           // +
     Minus,          // -
     Star,           // *
     Slash,          // /
@@ @@ -114,14 +112,12 @@ impl TokenKind { @@
             TK::CloseParen => ")",
             TK::CloseSquare => "]",
             TK::Colon => ":",
             TK::Comma => ",",
             TK::Dot => ".",
             TK::SemiColon => ";",
             TK::Quote => "'",
             TK::DoubleQuote => "\"",
             TK::At => "@",
             TK::Plus => "+",
             TK::Minus => "-",
             TK::Star => "*",
             TK::Slash => "/",
             TK::Percent => "%",
@@ @@ -158,37 +154,37 @@ impl TokenKind { @@
             TK::LineComment | TK::BlockComment | TK::SpanEnd => unreachable!(),
+        }
+    }
+}
 /// Represents a single token at a particular position.
-pub(crate) struct Token {
 pub struct Token {
     pub kind: TokenKind,
     pub pos: InputPosition,
+}
 impl Token {
     pub(crate) fn new(kind: TokenKind, pos: InputPosition) -> Self {
         Self{ kind, pos }
+    }
+}
 /// The kind of token ranges that are specially parsed by the tokenizer.
 #[derive(Debug, PartialEq, Eq)]
 pub(crate) enum TokenRangeKind {
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum TokenRangeKind {
     Module,
     Pragma,
     Import,
     Definition,
     Code,
+}
 /// A range of tokens with a specific meaning. Such a range is part of a tree
 /// where each parent tree envelops all of its children.
 #[derive(Debug)]
-pub(crate) struct TokenRange {
 pub struct TokenRange {
     // Index of parent in `TokenBuffer.ranges`, does not have a parent if the
     // range kind is Module, in that case the parent index points to itself.
     pub parent_idx: usize,
     pub range_kind: TokenRangeKind,
     pub curly_depth: u32,
     // Offsets into `TokenBuffer.ranges`: the tokens belonging to this range.
@@ @@ -198,13 +194,13 @@ pub(crate) struct TokenRange { @@
     pub num_child_ranges: u32,  // Number of subranges
     pub first_child_idx: u32,   // First subrange (or points to self if no subranges)
     pub last_child_idx: u32,    // Last subrange (or points to self if no subranges)
     pub next_sibling_idx: Option<u32>,
+}
-pub(crate) struct TokenBuffer {
 pub struct TokenBuffer {
     pub tokens: Vec<Token>,
     pub ranges: Vec<TokenRange>,
+}
 impl TokenBuffer {
     pub(crate) fn new() -> Self {

src/protocol/parser/type_table.rs

➞

Show inline comments

@@ @@ -26,20 +26,12 @@ impl TypeClass { @@
             TypeClass::Union => "union",
             TypeClass::Struct => "struct",
             TypeClass::Function => "function",
             TypeClass::Component => "component",
+        }
+    }
     pub(crate) fn is_data_type(&self) -> bool {
         *self == TypeClass::Enum || *self == TypeClass::Union || *self == TypeClass::Struct
+    }
     pub(crate) fn is_proc_type(&self) -> bool {
         *self == TypeClass::Function || *self == TypeClass::Component
+    }
+}
 impl std::fmt::Display for TypeClass {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         write!(f, "{}", self.display_name())
+    }
@@ @@ -55,13 +47,12 @@ impl std::fmt::Display for TypeClass { @@
 pub struct DefinedType {
     pub(crate) ast_root: RootId,
     pub(crate) ast_definition: DefinitionId,
     pub(crate) definition: DefinedTypeVariant,
     pub(crate) poly_vars: Vec<PolymorphicVariable>,
     pub(crate) is_polymorph: bool,
     pub(crate) is_pointerlike: bool,
     // TODO: @optimize
     pub(crate) monomorphs: Vec<Vec<ConcreteType>>,
+}
 impl DefinedType {
     fn add_monomorph(&mut self, types: Vec<ConcreteType>) {
@@ @@ -121,13 +112,13 @@ impl DefinedTypeVariant { @@
             DefinedTypeVariant::Union(v) => v,
             _ => unreachable!("Cannot convert {} to union variant", self.type_class())
+        }
+    }
+}
 struct PolymorphicVariable {
+pub struct PolymorphicVariable {
     identifier: Identifier,
     is_in_use: bool, // a polymorphic argument may be defined, but not used by the type definition
+}
 /// `EnumType` is the classical C/C++ enum type. It has various variants with
 /// an assigned integer value. The integer values may be user-defined,
@@ @@ -408,13 +399,12 @@ impl TypeTable { @@
             definition: DefinedTypeVariant::Enum(EnumType{
                 variants,
                 representation: Self::enum_tag_type(min_enum_value, max_enum_value)
             }),
             poly_vars,
             is_polymorph: false,
             is_pointerlike: false,
             monomorphs: Vec::new()
         });
         Ok(true)
+    }
@@ @@ -487,13 +477,12 @@ impl TypeTable { @@
             definition: DefinedTypeVariant::Union(UnionType{
                 variants,
                 tag_representation: Self::enum_tag_type(-1, tag_value),
             }),
             poly_vars,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic_types
             monomorphs: Vec::new()
         });
         Ok(true)
+    }
@@ @@ -542,13 +531,12 @@ impl TypeTable { @@
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Struct(StructType{
                 fields,
             }),
             poly_vars,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic
             monomorphs: Vec::new(),
         });
         Ok(true)
+    }
@@ @@ -608,13 +596,12 @@ impl TypeTable { @@
             definition: DefinedTypeVariant::Function(FunctionType{
                 return_types: definition.return_types.clone(),
                 arguments,
             }),
             poly_vars,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic
             monomorphs: Vec::new(),
         });
         Ok(true)
+    }
@@ @@ -668,13 +655,12 @@ impl TypeTable { @@
             definition: DefinedTypeVariant::Component(ComponentType{
                 variant: component_variant,
                 arguments,
             }),
             poly_vars,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic
             monomorphs: Vec::new(),
         });
         Ok(true)
+    }

src/protocol/tests/utils.rs

➞

Show inline comments

@@ @@ -12,13 +12,13 @@ use crate::protocol::{ @@
 // Carries information about the test into utility structures for builder-like
 // assertions
 #[derive(Clone, Copy)]
 struct TestCtx<'a> {
     test_name: &'a str,
     heap: &'a Heap,
-    modules: &'a Vec<LexedModule>,
+    modules: &'a Vec<Module>,
     types: &'a TypeTable,
     symbols: &'a SymbolTable,
+}
 //------------------------------------------------------------------------------
 // Interface for parsing and compiling
@@ @@ -60,16 +60,15 @@ impl Tester { @@
         self.sources.push(source.to_string());
         self
+    }
     pub(crate) fn compile(self) -> AstTesterResult {
         let mut parser = Parser::new();
-        for (source_idx, source) in self.sources.into_iter().enumerate() {
         for source in self.sources.into_iter() {
             let source = source.into_bytes();
             let input_source = InputSource::new(String::from(""), source)
                 .expect(&format!("parsing source {}", source_idx + 1));
             let input_source = InputSource::new(String::from(""), source);
             if let Err(err) = parser.feed(input_source) {
                 return AstTesterResult::Err(AstErrTester::new(self.test_name, err))
+            }
+        }
@@ @@ -117,13 +116,13 @@ impl AstTesterResult { @@
 //------------------------------------------------------------------------------
 // Interface for successful compilation
 //------------------------------------------------------------------------------
 pub(crate) struct AstOkTester {
     test_name: String,
-    modules: Vec<LexedModule>,
+    modules: Vec<Module>,
     heap: Heap,
     symbols: SymbolTable,
     types: TypeTable,
+}
 impl AstOkTester {
@@ @@ -486,13 +485,13 @@ impl<'a> FunctionTester<'a> { @@
         // Find the assignment expression that follows it
         let assignment_id = seek_expr_in_stmt(
             self.ctx.heap, self.def.body.upcast(),
             &|expr| {
                 if let Expression::Assignment(assign_expr) = expr {
                     if let Expression::Variable(variable_expr) = &self.ctx.heap[assign_expr.left] {
-                        if variable_expr.position.offset == local.identifier.position.offset {
+                        if variable_expr.identifier.span.begin.offset == local.identifier.span.begin.offset {
                             return true;
+                        }
+                    }
+                }
                 false
@@ @@ -530,13 +529,13 @@ impl<'a> FunctionTester<'a> { @@
         let module = seek_def_in_modules(
             &self.ctx.heap, &self.ctx.modules, self.def.this.upcast()
         ).unwrap();
         // Find the first occurrence of the expression after the definition of
         // the function, we'll check that it is included in the body later.
-        let mut outer_match_idx = self.def.position.offset;
+        let mut outer_match_idx = self.def.span.begin.offset as usize;
         while outer_match_idx < module.source.input.len() {
             if module.source.input[outer_match_idx..].starts_with(outer_match.as_bytes()) {
                 break;
+            }
             outer_match_idx += 1
+        }
@@ @@ -548,13 +547,13 @@ impl<'a> FunctionTester<'a> { @@
         );
         let inner_match_idx = outer_match_idx + outer_match.find(inner_match).unwrap();
         // Use the inner match index to find the expression
         let expr_id = seek_expr_in_stmt(
             &self.ctx.heap, self.def.body.upcast(),
-            &|expr| expr.position().offset == inner_match_idx
+            &|expr| expr.span().begin.offset as usize == inner_match_idx
         );
         assert!(
             expr_id.is_some(),
             "[{}] Failed to find '{}' within the source that contains {} \
             (note: expression was found, but not within the specified function",
             self.ctx.test_name, outer_match, self.assert_postfix()
@@ @@ -745,13 +744,13 @@ impl<'a> ErrorTester<'a> { @@
         assert!(
             pos.is_some(),
             "[{}] incorrect occurs_at: '{}' could not be found in the context for {}",
             self.test_name, pattern, self.assert_postfix()
         );
         let pos = pos.unwrap();
-        let col = self.error.statements[idx].position.column;
+        let col = self.error.statements[idx].start_column as usize;
         assert_eq!(
             pos + 1, col,
             "[{}] Expected error to occur at column {}, but found it at {} for {}",
             self.test_name, pos + 1, col, self.assert_postfix()
         );
         idx
+    }
     serialize_recursive(buffer, heap, poly_vars, concrete, 0);
+}
-fn seek_def_in_modules<'a>(heap: &Heap, modules: &'a [LexedModule], def_id: DefinitionId) -> Option<&'a LexedModule> {
+fn seek_def_in_modules<'a>(heap: &Heap, modules: &'a [Module], def_id: DefinitionId) -> Option<&'a Module> {
     for module in modules {
         let root = &heap.protocol_descriptions[module.root_id];
         for definition in &root.definitions {
             if *definition == def_id {
                 return Some(module)
+            }
                 if let Some(id) = seek_expr_in_expr(heap, *arg, f) {
                     return Some(id)
+                }
+            }
             None
         },
-        Expression::Variable(expr) => {
+        Expression::Variable(_expr) => {
             None
+        }
+    }
+}
 fn seek_expr_in_stmt<F: Fn(&Expression) -> bool>(heap: &Heap, start: StatementId, f: &F) -> Option<ExpressionId> {
             .or_else(|| seek_expr_in_stmt(heap, stmt.body.upcast(), f))
         },
         Statement::Synchronous(stmt) => {
             seek_expr_in_stmt(heap, stmt.body.upcast(), f)
         },
         Statement::Return(stmt) => {
             seek_expr_in_expr(heap, stmt.expression, f)
         },
         Statement::Assert(stmt) => {
             seek_expr_in_expr(heap, stmt.expression, f)
             for expr_id in &stmt.expressions {
                 if let Some(id) = seek_expr_in_expr(heap, *expr_id, f) {
                     return Some(id);
+                }
+            }
             None
         },
         Statement::New(stmt) => {
             seek_expr_in_expr(heap, stmt.expression.upcast(), f)
         },
         Statement::Expression(stmt) => {
             seek_expr_in_expr(heap, stmt.expression, f)

0 comments (0 inline, 0 general)