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
@@ @@ -8,24 +10,20 @@ @@
 /// 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) }
+    }
@@ @@ -38,7 +36,9 @@ impl<T: Sized + Copy> ScopedBuffer<T> { @@
             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;
@@ @@ -52,14 +52,14 @@ impl<T: Sized + Copy> ScopedBuffer<T> { @@
+}
 #[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};
@@ @@ -71,7 +71,7 @@ impl<T: Sized + Copy> ScopedSection<T> { @@
     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]
@@ @@ -85,23 +85,22 @@ impl<T: Sized + Copy> ScopedSection<T> { @@
     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};

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;
@@ @@ -11,6 +13,10 @@ pub struct StringRef<'a> { @@
     _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.
@@ @@ -38,6 +44,20 @@ impl<'a> StringRef<'a> { @@
+    }
+}
 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()
@@ @@ -48,11 +68,9 @@ 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,

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -58,6 +58,7 @@ macro_rules! define_new_ast_id { @@
         #[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() }
@@ @@ -356,7 +357,7 @@ impl Display for Identifier { @@
+    }
+}
-#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq)]
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ParserTypeVariant {
     // Basic builtin
     Message,
@@ @@ -379,16 +380,23 @@ pub enum ParserTypeVariant { @@
 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?
@@ @@ -405,6 +413,61 @@ 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>()`
@@ @@ -776,19 +839,17 @@ impl Definition { @@
+        }
+    }
     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> {
@@ @@ -1209,7 +1270,7 @@ impl BlockStatement { @@
                 // 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.
@@ @@ -1428,6 +1489,15 @@ pub enum ExpressionParent { @@
     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),
@@ @@ -1762,14 +1832,14 @@ 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)]

src/protocol/ast_printer.rs

➞

Show inline comments

 #![allow(dead_code)]
 use std::fmt::{Debug, Display, Write};
 use std::io::Write as IOWrite;
@@ @@ -240,16 +242,14 @@ impl ASTWriter { @@
                 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");
@@ @@ -259,8 +259,7 @@ impl ASTWriter { @@
                     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);
+                }
+            }
+        }
@@ @@ -526,8 +525,10 @@ impl ASTWriter { @@
             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)
@@ @@ -681,7 +682,11 @@ impl ASTWriter { @@
                     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");
@@ @@ -689,9 +694,7 @@ impl ASTWriter { @@
                         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");
@@ @@ -706,9 +709,7 @@ impl ASTWriter { @@
                         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) => {
@@ @@ -717,9 +718,7 @@ impl ASTWriter { @@
                         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 {
             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 {
     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;
             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("[]");
         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)

src/protocol/eval.rs

➞

Show inline comments

@@ @@ -24,10 +24,10 @@ 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)]
@@ @@ -93,7 +93,7 @@ impl Value { @@
             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> {
@@ @@ -851,7 +851,7 @@ impl ValueImpl for Value { @@
             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),
@@ @@ -872,7 +872,7 @@ impl ValueImpl for Value { @@
             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 {
@@ @@ -914,9 +914,9 @@ 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,
+        }
@@ @@ -936,9 +936,9 @@ 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,
+        }
@@ @@ -968,9 +968,9 @@ 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,
+        }
@@ @@ -990,9 +990,9 @@ 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,
@@ @@ -1014,9 +1014,9 @@ 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,
@@ @@ -1038,9 +1038,9 @@ 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,
@@ @@ -1062,9 +1062,9 @@ 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,
@@ @@ -1086,18 +1086,18 @@ 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;
+    }
@@ @@ -1125,9 +1125,9 @@ 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)
+    }
+}
@@ @@ -1154,9 +1154,9 @@ 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)
+    }
+}
@@ @@ -1183,9 +1183,9 @@ 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)
+    }
+}
@@ @@ -1212,9 +1212,9 @@ 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)
+    }
+}
@@ @@ -1241,9 +1241,9 @@ 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)
+    }
+}
@@ @@ -1270,9 +1270,9 @@ 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)
+    }
+}
@@ @@ -1299,9 +1299,9 @@ 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)
+    }
+}
@@ @@ -1328,9 +1328,9 @@ 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)
+    }
+}
@@ @@ -1349,7 +1349,7 @@ impl Store { @@
             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());
+    }
@@ @@ -1368,7 +1368,7 @@ impl Store { @@
                     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)
@@ @@ -1458,7 +1458,7 @@ impl Store { @@
+                }
                 Ok(value)
+            }
-            Expression::Binding(expr) => {
+            Expression::Binding(_expr) => {
                 unimplemented!("eval binding expression");
+            }
             Expression::Conditional(expr) => {
@@ @@ -1561,8 +1561,22 @@ impl Store { @@
                     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()),
+        }
@@ @@ -1602,7 +1616,7 @@ impl Prompt { @@
         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());
+        }
+    }
@@ @@ -1635,11 +1649,6 @@ impl Prompt { @@
                 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);
@@ @@ -1700,21 +1709,10 @@ impl Prompt { @@
                 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)
+            }
@@ @@ -1732,8 +1730,8 @@ impl Prompt { @@
+                }
                 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")
+                }

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)]
@@ @@ -38,9 +38,9 @@ pub struct InputSource { @@
     // 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 {
@@ @@ -51,7 +51,7 @@ impl InputSource { @@
             line: 1,
             offset: 0,
             had_error: None,
-            offset_lookup: RefCell::new(Vec::new()),
+            offset_lookup: RwLock::new(Vec::new()),
+        }
+    }
@@ @@ -129,18 +129,28 @@ impl InputSource { @@
+        }
+    }
-    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
@@ @@ -155,7 +165,8 @@ impl InputSource { @@
         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;
+    }
@@ @@ -355,7 +366,7 @@ impl fmt::Display for ParseErrorStatement { @@
                 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;
+                }
@@ @@ -393,10 +404,6 @@ impl fmt::Display for ParseError { @@
+}
 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

@@ @@ -12,9 +12,9 @@ pub(crate) struct PassDefinitions { @@
     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>,
@@ @@ -26,9 +26,9 @@ impl PassDefinitions { @@
         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),
@@ @@ -89,6 +89,7 @@ impl PassDefinitions { @@
             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(
@@ @@ -109,14 +110,16 @@ impl PassDefinitions { @@
         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,
@@ @@ -128,13 +131,12 @@ impl PassDefinitions { @@
                     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(())
+    }
@@ @@ -149,14 +151,14 @@ impl PassDefinitions { @@
         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();
@@ @@ -167,13 +169,12 @@ impl PassDefinitions { @@
                 };
                 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(())
+    }
@@ @@ -188,19 +189,21 @@ impl PassDefinitions { @@
         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
@@ @@ -221,13 +224,12 @@ impl PassDefinitions { @@
                     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(())
+    }
@@ @@ -242,12 +244,11 @@ impl PassDefinitions { @@
         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();
@@ @@ -255,8 +256,9 @@ impl PassDefinitions { @@
         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)
@@ @@ -293,12 +295,11 @@ impl PassDefinitions { @@
         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();
@@ @@ -438,12 +439,19 @@ impl PassDefinitions { @@
     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;
@@ @@ -565,14 +573,16 @@ impl PassDefinitions { @@
         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{
@@ @@ -1190,8 +1200,8 @@ impl PassDefinitions { @@
             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)
             )?;
@@ @@ -1260,8 +1270,8 @@ impl PassDefinitions { @@
                                 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)?;
@@ @@ -1337,9 +1347,6 @@ impl PassDefinitions { @@
                                 }).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() {
@@ @@ -1355,6 +1362,9 @@ impl PassDefinitions { @@
                                     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
@@ @@ -1460,8 +1470,8 @@ impl PassDefinitions { @@
     ) -> 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())
@@ @@ -1807,10 +1817,10 @@ fn consume_parser_type_ident( @@
+}
 /// 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"
 /// 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,

src/protocol/parser/pass_imports.rs

➞

Show inline comments

@@ @@ -55,7 +55,7 @@ impl PassImport { @@
+    }
     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];
@@ @@ -116,6 +116,16 @@ impl PassImport { @@
             ) -> 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()
                 );
@@ @@ -133,15 +143,6 @@ impl PassImport { @@
                 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,
@@ @@ -160,7 +161,12 @@ impl PassImport { @@
                 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),
@@ @@ -176,15 +182,15 @@ impl PassImport { @@
+                    }
                 ) {
                     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)
@@ @@ -204,10 +210,11 @@ impl PassImport { @@
                 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{
@@ @@ -215,7 +222,7 @@ impl PassImport { @@
                             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 {
@@ @@ -247,7 +254,7 @@ impl PassImport { @@
                     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,
                             });
@@ @@ -259,7 +266,7 @@ impl PassImport { @@
                                     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!(),
@@ @@ -289,13 +296,15 @@ impl PassImport { @@
                 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

src/protocol/parser/pass_symbols.rs

➞

Show inline comments

@@ @@ -62,20 +62,25 @@ impl PassSymbols { @@
         });
         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; },
+            }
@@ @@ -86,7 +91,7 @@ impl PassSymbols { @@
         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))
+            }
+        }
@@ @@ -94,6 +99,8 @@ impl PassSymbols { @@
         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(())
@@ @@ -134,7 +141,7 @@ impl PassSymbols { @@
                 // 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"
@@ @@ -183,8 +190,8 @@ impl PassSymbols { @@
         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

src/protocol/parser/pass_tokenizer.rs

➞

Show inline comments

@@ @@ -2,7 +2,6 @@ use crate::protocol::input_source::{ @@
     InputSource as InputSource,
     ParseError,
     InputPosition as InputPosition,
     InputSpan
 };
 use super::tokens::*;
@@ @@ -157,7 +156,7 @@ impl PassTokenizer { @@
                     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];
@@ @@ -372,7 +371,10 @@ impl PassTokenizer { @@
+            }
         } 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);
@@ @@ -626,6 +628,7 @@ impl PassTokenizer { @@
     /// 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
@@ @@ -635,14 +638,13 @@ impl PassTokenizer { @@
         // 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;
@@ @@ -653,15 +655,14 @@ impl PassTokenizer { @@
                 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;
+            }

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -60,6 +60,7 @@ 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,
@@ @@ -147,15 +148,16 @@ impl InferenceTypePart { @@
         // 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,
+        }
+    }
@@ @@ -196,8 +198,9 @@ impl InferenceTypePart { @@
         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(_) |
@@ @@ -225,10 +228,15 @@ impl From<ConcreteTypePart> for InferenceTypePart { @@
             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,
@@ @@ -635,10 +643,15 @@ impl InferenceType { @@
                 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,
@@ @@ -669,26 +682,32 @@ impl InferenceType { @@
                 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('>');
             },
@@ @@ -701,12 +720,14 @@ impl InferenceType { @@
                 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('>');
             },
@@ @@ -884,7 +905,7 @@ 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),
@@ @@ -943,7 +964,7 @@ impl PassTyping { @@
+    }
     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();
@@ @@ -964,12 +985,12 @@ impl Visitor2 for PassTyping { @@
         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));
+        }
@@ @@ -985,12 +1006,12 @@ impl Visitor2 for PassTyping { @@
         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));
+        }
@@ @@ -1016,7 +1037,7 @@ impl Visitor2 for PassTyping { @@
         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(())
@@ @@ -1026,11 +1047,11 @@ impl Visitor2 for PassTyping { @@
         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(())
@@ @@ -1079,7 +1100,8 @@ impl Visitor2 for PassTyping { @@
     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)
+    }
@@ @@ -1328,7 +1350,6 @@ impl PassTyping { @@
         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();
@@ @@ -1336,7 +1357,7 @@ impl PassTyping { @@
             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(
@@ @@ -1404,8 +1425,8 @@ impl PassTyping { @@
                 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)
@@ @@ -1428,9 +1449,9 @@ 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) {
@@ @@ -1451,7 +1472,7 @@ impl PassTyping { @@
                 let id = expr.this;
                 self.progress_assignment_expr(ctx, id)
             },
-            Expression::Binding(expr) => {
+            Expression::Binding(_expr) => {
                 unimplemented!("progress binding expression");
             },
             Expression::Conditional(expr) => {
@@ @@ -1955,12 +1976,12 @@ impl PassTyping { @@
                 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();
@@ @@ -2230,13 +2251,7 @@ impl PassTyping { @@
         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):");
@@ @@ -2343,7 +2358,7 @@ impl PassTyping { @@
         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));
@@ @@ -2765,8 +2780,9 @@ impl PassTyping { @@
             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.
@@ @@ -2803,8 +2819,6 @@ impl PassTyping { @@
     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.
@@ @@ -2816,84 +2830,50 @@ impl PassTyping { @@
         // 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
         });
+    }
@@ @@ -2905,35 +2885,28 @@ impl PassTyping { @@
         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);
+        }
@@ @@ -2942,11 +2915,11 @@ impl PassTyping { @@
         // - 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));
@@ @@ -2954,10 +2927,10 @@ impl PassTyping { @@
+        }
         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,
         });
@@ @@ -2973,22 +2946,22 @@ impl PassTyping { @@
         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));
@@ @@ -2996,10 +2969,10 @@ impl PassTyping { @@
+        }
         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,
         });
@@ @@ -3014,50 +2987,48 @@ impl PassTyping { @@
         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
         });
@@ @@ -3079,6 +3050,7 @@ impl PassTyping { @@
         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;
@@ @@ -3095,10 +3067,7 @@ impl PassTyping { @@
         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)],
@@ @@ -3118,18 +3087,18 @@ impl PassTyping { @@
     ///     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...
@@ @@ -3160,7 +3129,7 @@ impl PassTyping { @@
                     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));
@@ @@ -3203,7 +3172,7 @@ impl PassTyping { @@
                 "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)
@@ @@ -3313,9 +3282,9 @@ impl PassTyping { @@
                 },
                 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!(),
                     };
@@ @@ -3331,7 +3300,7 @@ impl PassTyping { @@
                     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
+                        )
@@ @@ -3433,7 +3402,7 @@ impl PassTyping { @@
                             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,

src/protocol/parser/pass_validation_linking.rs

➞

Show inline comments

@@ @@ -263,8 +263,9 @@ impl Visitor2 for PassValidationLinking { @@
         // 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(())
@@ @@ -284,8 +285,8 @@ impl Visitor2 for PassValidationLinking { @@
             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")
             );
+        }
@@ @@ -481,9 +482,11 @@ impl Visitor2 for PassValidationLinking { @@
                     // 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()
+                            )
@@ @@ -493,8 +496,8 @@ impl Visitor2 for PassValidationLinking { @@
                     // 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"
                         ));
+                    }
@@ @@ -551,6 +554,7 @@ impl Visitor2 for PassValidationLinking { @@
                 });
                 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!(
@@ @@ -571,6 +575,7 @@ impl Visitor2 for PassValidationLinking { @@
                     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!(
@@ @@ -586,6 +591,7 @@ impl Visitor2 for PassValidationLinking { @@
                 // 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!(
@@ @@ -618,7 +624,7 @@ impl Visitor2 for PassValidationLinking { @@
                 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)?;
+                }
@@ @@ -703,17 +709,17 @@ impl Visitor2 for PassValidationLinking { @@
+        }
         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"
                 ));
+            }
+        }
@@ @@ -723,7 +729,7 @@ impl Visitor2 for PassValidationLinking { @@
         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();
@@ @@ -828,8 +834,9 @@ impl PassValidationLinking { @@
+            }
             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;
@@ @@ -855,10 +862,10 @@ impl PassValidationLinking { @@
             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"
                 ));
+            }
+        }
@@ @@ -885,8 +892,11 @@ impl PassValidationLinking { @@
                     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"
+                        )
                     );
+                }
+            }
@@ @@ -900,8 +910,11 @@ impl PassValidationLinking { @@
                     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"
+                            )
                         );
+                    }
+                }
@@ @@ -937,7 +950,7 @@ impl PassValidationLinking { @@
             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());
+                }
+            }
@@ @@ -951,7 +964,7 @@ impl PassValidationLinking { @@
                         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());
+                            }
+                        }
@@ @@ -980,7 +993,7 @@ impl PassValidationLinking { @@
         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 {
@@ @@ -992,7 +1005,7 @@ impl PassValidationLinking { @@
                     // 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"
                     ));
+                }
@@ @@ -1036,8 +1049,8 @@ impl PassValidationLinking { @@
                         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")
                             );
+                        }
+                    }
@@ @@ -1065,7 +1078,7 @@ impl PassValidationLinking { @@
         loop {
             debug_assert!(scope.is_block());
             let block = scope.to_block();
-            if while_stmt.body == block.upcast() {
             if while_stmt.body == block {
                 return true;
+            }

src/protocol/parser/symbol_table.rs

➞

Show inline comments

@@ @@ -126,23 +126,9 @@ impl SymbolVariant { @@
+        }
+    }
     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,
+        }
+    }
@@ @@ -223,14 +209,15 @@ impl SymbolTable { @@
     /// 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()))
+                }
+            }

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,
@@ @@ -8,7 +8,7 @@ use crate::protocol::input_source::{ @@
 };
 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_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
@@ @@ -82,7 +100,7 @@ impl<T> Extendable for Vec<T> { @@
+    }
+}
-impl<T: Sized + Copy> Extendable for ScopedSection<T> {
 impl<T: Sized> Extendable for ScopedSection<T> {
     type Value = T;
     #[inline]
 /// 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;
@@ @@ -162,7 +180,7 @@ pub(crate) fn consume_comma_separated_until<T, F, E>( @@
             ));
+        }
         let new_item = consumer_fn(source, iter)?;
+        let new_item = consumer_fn(source, iter, ctx)?;
         target.push(new_item);
         next = iter.next();
@@ @@ -183,28 +201,28 @@ pub(crate) fn consume_comma_separated_until<T, F, E>( @@
 /// - 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 {
             ));
+        }
         consumer_fn(source, iter)?;
+        consumer_fn(source, iter, ctx)?;
         next = iter.next();
         had_comma = next == Some(TokenKind::Comma);
         if had_comma {
 /// 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(()),

src/protocol/parser/tokens.rs

➞

Show inline comments

@@ @@ -7,7 +7,7 @@ use crate::protocol::input_source::{ @@
 /// 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 `#`
@@ @@ -32,8 +32,6 @@ pub(crate) enum TokenKind { @@
     Comma,          // ,
     Dot,            // .
     SemiColon,      // ;
     Quote,          // '
     DoubleQuote,    // "
     // Operator-like (single character)
     At,             // @
     Plus,           // +
@@ @@ -117,8 +115,6 @@ impl TokenKind { @@
             TK::Comma => ",",
             TK::Dot => ".",
             TK::SemiColon => ";",
             TK::Quote => "'",
             TK::DoubleQuote => "\"",
             TK::At => "@",
             TK::Plus => "+",
             TK::Minus => "-",
@@ @@ -161,7 +157,7 @@ impl TokenKind { @@
+}
 /// Represents a single token at a particular position.
-pub(crate) struct Token {
 pub struct Token {
     pub kind: TokenKind,
     pub pos: InputPosition,
+}
@@ @@ -173,8 +169,8 @@ impl Token { @@
+}
 /// 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,
@@ @@ -185,7 +181,7 @@ pub(crate) enum TokenRangeKind { @@
 /// 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,
@@ @@ -201,7 +197,7 @@ pub(crate) struct TokenRange { @@
     pub next_sibling_idx: Option<u32>,
+}
-pub(crate) struct TokenBuffer {
 pub struct TokenBuffer {
     pub tokens: Vec<Token>,
     pub ranges: Vec<TokenRange>,
+}

src/protocol/parser/type_table.rs

➞

Show inline comments

@@ @@ -29,14 +29,6 @@ impl TypeClass { @@
             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 {
@@ @@ -58,7 +50,6 @@ pub struct DefinedType { @@
     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>>,
+}
@@ @@ -124,7 +115,7 @@ impl DefinedTypeVariant { @@
+    }
+}
 struct PolymorphicVariable {
+pub struct PolymorphicVariable {
     identifier: Identifier,
     is_in_use: bool, // a polymorphic argument may be defined, but not used by the type definition
+}
@@ @@ -411,7 +402,6 @@ impl TypeTable { @@
             }),
             poly_vars,
             is_polymorph: false,
             is_pointerlike: false,
             monomorphs: Vec::new()
         });
@@ @@ -490,7 +480,6 @@ impl TypeTable { @@
             }),
             poly_vars,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic_types
             monomorphs: Vec::new()
         });
@@ @@ -545,7 +534,6 @@ impl TypeTable { @@
             }),
             poly_vars,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic
             monomorphs: Vec::new(),
         });
@@ @@ -611,7 +599,6 @@ impl TypeTable { @@
             }),
             poly_vars,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic
             monomorphs: Vec::new(),
         });
@@ @@ -671,7 +658,6 @@ impl TypeTable { @@
             }),
             poly_vars,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic
             monomorphs: Vec::new(),
         });

src/protocol/tests/utils.rs

➞

Show inline comments

@@ @@ -15,7 +15,7 @@ use crate::protocol::{ @@
 struct TestCtx<'a> {
     test_name: &'a str,
     heap: &'a Heap,
-    modules: &'a Vec<LexedModule>,
+    modules: &'a Vec<Module>,
     types: &'a TypeTable,
     symbols: &'a SymbolTable,
+}
@@ @@ -63,10 +63,9 @@ impl Tester { @@
     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))
@@ @@ -120,7 +119,7 @@ impl AstTesterResult { @@
 pub(crate) struct AstOkTester {
     test_name: String,
-    modules: Vec<LexedModule>,
+    modules: Vec<Module>,
     heap: Heap,
     symbols: SymbolTable,
     types: TypeTable,
@@ @@ -489,7 +488,7 @@ impl<'a> FunctionTester<'a> { @@
             &|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;
+                        }
+                    }
@@ @@ -533,7 +532,7 @@ impl<'a> FunctionTester<'a> { @@
         // 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;
@@ @@ -551,7 +550,7 @@ impl<'a> FunctionTester<'a> { @@
         // 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(),
@@ @@ -748,7 +747,7 @@ impl<'a> ErrorTester<'a> { @@
             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 {}",
     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 {
+            }
             None
         },
-        Expression::Variable(expr) => {
+        Expression::Variable(_expr) => {
             None
+        }
+    }
             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)

0 comments (0 inline, 0 general)