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

Changeset - 6938bcacc41e

Parent rev.

Child rev.

[Not reviewed]

0 10 0

MH - 4 years ago 2021-03-22 11:59:28
contact@maxhenger.nl

turn put stmt into call expr, make compiling great again

10 files changed with 441 insertions and 198 deletions:

src/protocol/ast.rs

src/protocol/ast_printer.rs

src/protocol/eval.rs

src/protocol/lexer.rs

src/protocol/mod.rs

src/protocol/parser/depth_visitor.rs

src/protocol/parser/type_resolver.rs

351

src/protocol/parser/type_table.rs

src/protocol/parser/visitor.rs

src/protocol/parser/visitor_linker.rs

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -17,193 +17,192 @@ macro_rules! define_aliased_ast_id { @@
     // Variant where we just defined the alias, without any indexing
     ($name:ident, $parent:ty) => {
         pub type $name = $parent;
     };
     // Variant where we define the type, and the Index and IndexMut traits
     ($name:ident, $parent:ty, $indexed_type:ty, $indexed_arena:ident) => {
         define_aliased_ast_id!($name, $parent);
         impl Index<$name> for Heap {
             type Output = $indexed_type;
             fn index(&self, index: $name) -> &Self::Output {
                 &self.$indexed_arena[index]
+            }
+        }
         impl IndexMut<$name> for Heap {
             fn index_mut(&mut self, index: $name) -> &mut Self::Output {
                 &mut self.$indexed_arena[index]
+            }
+        }
+    }
+}
 /// Helper macro that defines a wrapper type for a particular variant of an AST
 /// element ID. Only used to define single-wrapping IDs.
 macro_rules! define_new_ast_id {
     // Variant where we just defined the new type, without any indexing
     ($name:ident, $parent:ty) => {
         #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
         pub struct $name (pub(crate) $parent);
         impl $name {
             pub fn upcast(self) -> $parent {
                 self.0
+            }
+        }
     };
     // Variant where we define the type, and the Index and IndexMut traits
     ($name:ident, $parent:ty, $indexed_type:ty, $wrapper_type:path, $indexed_arena:ident) => {
         define_new_ast_id!($name, $parent);
         impl Index<$name> for Heap {
             type Output = $indexed_type;
             fn index(&self, index: $name) -> &Self::Output {
                 if let $wrapper_type(v) = &self.$indexed_arena[index.0] {
+                    v
                 } else {
                     unreachable!()
+                }
+            }
+        }
         impl IndexMut<$name> for Heap {
             fn index_mut(&mut self, index: $name) -> &mut Self::Output {
                 if let $wrapper_type(v) = &mut self.$indexed_arena[index.0] {
+                    v
                 } else {
                     unreachable!()
+                }
+            }
+        }
+    }
+}
 define_aliased_ast_id!(RootId, Id<Root>, Root, protocol_descriptions);
 define_aliased_ast_id!(PragmaId, Id<Pragma>, Pragma, pragmas);
 define_aliased_ast_id!(ImportId, Id<Import>, Import, imports);
 define_aliased_ast_id!(ParserTypeId, Id<ParserType>, ParserType, parser_types);
 define_aliased_ast_id!(VariableId, Id<Variable>, Variable, variables);
 define_new_ast_id!(ParameterId, VariableId, Parameter, Variable::Parameter, variables);
 define_new_ast_id!(LocalId, VariableId, Local, Variable::Local, variables);
 define_aliased_ast_id!(DefinitionId, Id<Definition>, Definition, definitions);
 define_new_ast_id!(StructId, DefinitionId, StructDefinition, Definition::Struct, definitions);
 define_new_ast_id!(EnumId, DefinitionId, EnumDefinition, Definition::Enum, definitions);
 define_new_ast_id!(ComponentId, DefinitionId, Component, Definition::Component, definitions);
 define_new_ast_id!(FunctionId, DefinitionId, Function, Definition::Function, definitions);
 define_aliased_ast_id!(StatementId, Id<Statement>, Statement, statements);
 define_new_ast_id!(BlockStatementId, StatementId, BlockStatement, Statement::Block, statements);
 define_new_ast_id!(LocalStatementId, StatementId, LocalStatement, Statement::Local, statements);
 define_new_ast_id!(MemoryStatementId, LocalStatementId);
 define_new_ast_id!(ChannelStatementId, LocalStatementId);
 define_new_ast_id!(SkipStatementId, StatementId, SkipStatement, Statement::Skip, statements);
 define_new_ast_id!(LabeledStatementId, StatementId, LabeledStatement, Statement::Labeled, statements);
 define_new_ast_id!(IfStatementId, StatementId, IfStatement, Statement::If, statements);
 define_new_ast_id!(EndIfStatementId, StatementId, EndIfStatement, Statement::EndIf, statements);
 define_new_ast_id!(WhileStatementId, StatementId, WhileStatement, Statement::While, statements);
 define_new_ast_id!(EndWhileStatementId, StatementId, EndWhileStatement, Statement::EndWhile, statements);
 define_new_ast_id!(BreakStatementId, StatementId, BreakStatement, Statement::Break, statements);
 define_new_ast_id!(ContinueStatementId, StatementId, ContinueStatement, Statement::Continue, statements);
 define_new_ast_id!(SynchronousStatementId, StatementId, SynchronousStatement, Statement::Synchronous, statements);
 define_new_ast_id!(EndSynchronousStatementId, StatementId, EndSynchronousStatement, Statement::EndSynchronous, statements);
 define_new_ast_id!(ReturnStatementId, StatementId, ReturnStatement, Statement::Return, statements);
 define_new_ast_id!(AssertStatementId, StatementId, AssertStatement, Statement::Assert, statements);
 define_new_ast_id!(GotoStatementId, StatementId, GotoStatement, Statement::Goto, statements);
 define_new_ast_id!(NewStatementId, StatementId, NewStatement, Statement::New, statements);
 define_new_ast_id!(PutStatementId, StatementId, PutStatement, Statement::Put, statements);
 define_new_ast_id!(ExpressionStatementId, StatementId, ExpressionStatement, Statement::Expression, statements);
 define_aliased_ast_id!(ExpressionId, Id<Expression>, Expression, expressions);
 define_new_ast_id!(AssignmentExpressionId, ExpressionId, AssignmentExpression, Expression::Assignment, expressions);
 define_new_ast_id!(ConditionalExpressionId, ExpressionId, ConditionalExpression, Expression::Conditional, expressions);
 define_new_ast_id!(BinaryExpressionId, ExpressionId, BinaryExpression, Expression::Binary, expressions);
 define_new_ast_id!(UnaryExpressionId, ExpressionId, UnaryExpression, Expression::Unary, expressions);
 define_new_ast_id!(IndexingExpressionId, ExpressionId, IndexingExpression, Expression::Indexing, expressions);
 define_new_ast_id!(SlicingExpressionId, ExpressionId, SlicingExpression, Expression::Slicing, expressions);
 define_new_ast_id!(SelectExpressionId, ExpressionId, SelectExpression, Expression::Select, expressions);
 define_new_ast_id!(ArrayExpressionId, ExpressionId, ArrayExpression, Expression::Array, expressions);
 define_new_ast_id!(ConstantExpressionId, ExpressionId, ConstantExpression, Expression::Constant, expressions);
 define_new_ast_id!(CallExpressionId, ExpressionId, CallExpression, Expression::Call, expressions);
 define_new_ast_id!(VariableExpressionId, ExpressionId, VariableExpression, Expression::Variable, expressions);
 // TODO: @cleanup - pub qualifiers can be removed once done
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 pub struct Heap {
     // Root arena, contains the entry point for different modules. Each root
     // contains lists of IDs that correspond to the other arenas.
     pub(crate) protocol_descriptions: Arena<Root>,
     // Contents of a file, these are the elements the `Root` elements refer to
     pragmas: Arena<Pragma>,
     pub(crate) imports: Arena<Import>,
     identifiers: Arena<Identifier>,
     pub(crate) parser_types: Arena<ParserType>,
     pub(crate) variables: Arena<Variable>,
     pub(crate) definitions: Arena<Definition>,
     pub(crate) statements: Arena<Statement>,
     pub(crate) expressions: Arena<Expression>,
+}
 impl Heap {
     pub fn new() -> Heap {
         Heap {
             // string_alloc: StringAllocator::new(),
             protocol_descriptions: Arena::new(),
             pragmas: Arena::new(),
             imports: Arena::new(),
             identifiers: Arena::new(),
             parser_types: Arena::new(),
             variables: Arena::new(),
             definitions: Arena::new(),
             statements: Arena::new(),
             expressions: Arena::new(),
+        }
+    }
     pub fn alloc_parser_type(
         &mut self,
         f: impl FnOnce(ParserTypeId) -> ParserType,
     ) -> ParserTypeId {
         self.parser_types.alloc_with_id(|id| f(id))
+    }
     pub fn alloc_parameter(&mut self, f: impl FnOnce(ParameterId) -> Parameter) -> ParameterId {
         ParameterId(
             self.variables.alloc_with_id(|id| Variable::Parameter(f(ParameterId(id)))),
+        )
+    }
     pub fn alloc_local(&mut self, f: impl FnOnce(LocalId) -> Local) -> LocalId {
         LocalId(
             self.variables.alloc_with_id(|id| Variable::Local(f(LocalId(id)))),
+        )
+    }
     pub fn alloc_assignment_expression(
         &mut self,
         f: impl FnOnce(AssignmentExpressionId) -> AssignmentExpression,
     ) -> AssignmentExpressionId {
         AssignmentExpressionId(
             self.expressions.alloc_with_id(|id| {
                 Expression::Assignment(f(AssignmentExpressionId(id)))
             })
+        )
+    }
     pub fn alloc_conditional_expression(
         &mut self,
         f: impl FnOnce(ConditionalExpressionId) -> ConditionalExpression,
     ) -> ConditionalExpressionId {
         ConditionalExpressionId(
             self.expressions.alloc_with_id(|id| {
                 Expression::Conditional(f(ConditionalExpressionId(id)))
             })
+        )
+    }
     pub fn alloc_binary_expression(
         &mut self,
         f: impl FnOnce(BinaryExpressionId) -> BinaryExpression,
     ) -> BinaryExpressionId {
         BinaryExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Binary(f(BinaryExpressionId(id)))),
+        )
+    }
     pub fn alloc_unary_expression(
         &mut self,
         f: impl FnOnce(UnaryExpressionId) -> UnaryExpression,
@@ @@ -328,200 +327,192 @@ impl Heap { @@
     pub fn alloc_end_if_statement(
         &mut self,
         f: impl FnOnce(EndIfStatementId) -> EndIfStatement,
     ) -> EndIfStatementId {
         EndIfStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::EndIf(f(EndIfStatementId(id)))),
+        )
+    }
     pub fn alloc_while_statement(
         &mut self,
         f: impl FnOnce(WhileStatementId) -> WhileStatement,
     ) -> WhileStatementId {
         WhileStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::While(f(WhileStatementId(id)))),
+        )
+    }
     pub fn alloc_end_while_statement(
         &mut self,
         f: impl FnOnce(EndWhileStatementId) -> EndWhileStatement,
     ) -> EndWhileStatementId {
         EndWhileStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::EndWhile(f(EndWhileStatementId(id)))),
+        )
+    }
     pub fn alloc_break_statement(
         &mut self,
         f: impl FnOnce(BreakStatementId) -> BreakStatement,
     ) -> BreakStatementId {
         BreakStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Break(f(BreakStatementId(id)))),
+        )
+    }
     pub fn alloc_continue_statement(
         &mut self,
         f: impl FnOnce(ContinueStatementId) -> ContinueStatement,
     ) -> ContinueStatementId {
         ContinueStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Continue(f(ContinueStatementId(id)))),
+        )
+    }
     pub fn alloc_synchronous_statement(
         &mut self,
         f: impl FnOnce(SynchronousStatementId) -> SynchronousStatement,
     ) -> SynchronousStatementId {
         SynchronousStatementId(self.statements.alloc_with_id(|id| {
             Statement::Synchronous(f(SynchronousStatementId(id)))
         }))
+    }
     pub fn alloc_end_synchronous_statement(
         &mut self,
         f: impl FnOnce(EndSynchronousStatementId) -> EndSynchronousStatement,
     ) -> EndSynchronousStatementId {
         EndSynchronousStatementId(self.statements.alloc_with_id(|id| {
             Statement::EndSynchronous(f(EndSynchronousStatementId(id)))
         }))
+    }
     pub fn alloc_return_statement(
         &mut self,
         f: impl FnOnce(ReturnStatementId) -> ReturnStatement,
     ) -> ReturnStatementId {
         ReturnStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Return(f(ReturnStatementId(id)))),
+        )
+    }
     pub fn alloc_assert_statement(
         &mut self,
         f: impl FnOnce(AssertStatementId) -> AssertStatement,
     ) -> AssertStatementId {
         AssertStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Assert(f(AssertStatementId(id)))),
+        )
+    }
     pub fn alloc_goto_statement(
         &mut self,
         f: impl FnOnce(GotoStatementId) -> GotoStatement,
     ) -> GotoStatementId {
         GotoStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Goto(f(GotoStatementId(id)))),
+        )
+    }
     pub fn alloc_new_statement(
         &mut self,
         f: impl FnOnce(NewStatementId) -> NewStatement,
     ) -> NewStatementId {
         NewStatementId(
             self.statements.alloc_with_id(|id| Statement::New(f(NewStatementId(id)))),
+        )
+    }
     pub fn alloc_put_statement(
         &mut self,
         f: impl FnOnce(PutStatementId) -> PutStatement,
     ) -> PutStatementId {
         PutStatementId(
             self.statements.alloc_with_id(|id| Statement::Put(f(PutStatementId(id)))),
+        )
+    }
     pub fn alloc_labeled_statement(
         &mut self,
         f: impl FnOnce(LabeledStatementId) -> LabeledStatement,
     ) -> LabeledStatementId {
         LabeledStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Labeled(f(LabeledStatementId(id)))),
+        )
+    }
     pub fn alloc_expression_statement(
         &mut self,
         f: impl FnOnce(ExpressionStatementId) -> ExpressionStatement,
     ) -> ExpressionStatementId {
         ExpressionStatementId(
             self.statements.alloc_with_id(|id| {
                 Statement::Expression(f(ExpressionStatementId(id)))
             }),
+        )
+    }
     pub fn alloc_struct_definition(&mut self, f: impl FnOnce(StructId) -> StructDefinition) -> StructId {
         StructId(self.definitions.alloc_with_id(|id| {
             Definition::Struct(f(StructId(id)))
         }))
+    }
     pub fn alloc_enum_definition(&mut self, f: impl FnOnce(EnumId) -> EnumDefinition) -> EnumId {
         EnumId(self.definitions.alloc_with_id(|id| {
             Definition::Enum(f(EnumId(id)))
         }))
+    }
     pub fn alloc_component(&mut self, f: impl FnOnce(ComponentId) -> Component) -> ComponentId {
         ComponentId(self.definitions.alloc_with_id(|id| {
             Definition::Component(f(ComponentId(id)))
         }))
+    }
     pub fn alloc_function(&mut self, f: impl FnOnce(FunctionId) -> Function) -> FunctionId {
         FunctionId(
             self.definitions
                 .alloc_with_id(|id| Definition::Function(f(FunctionId(id)))),
+        )
+    }
     pub fn alloc_pragma(&mut self, f: impl FnOnce(PragmaId) -> Pragma) -> PragmaId {
         self.pragmas.alloc_with_id(|id| f(id))
+    }
     pub fn alloc_import(&mut self, f: impl FnOnce(ImportId) -> Import) -> ImportId {
         self.imports.alloc_with_id(|id| f(id))
+    }
     pub fn alloc_protocol_description(&mut self, f: impl FnOnce(RootId) -> Root) -> RootId {
         self.protocol_descriptions.alloc_with_id(|id| f(id))
+    }
+}
 impl Index<MemoryStatementId> for Heap {
     type Output = MemoryStatement;
     fn index(&self, index: MemoryStatementId) -> &Self::Output {
         &self.statements[index.0.0].as_memory()
+    }
+}
 impl Index<ChannelStatementId> for Heap {
     type Output = ChannelStatement;
     fn index(&self, index: ChannelStatementId) -> &Self::Output {
         &self.statements[index.0.0].as_channel()
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Root {
     pub this: RootId,
     // Phase 1: parser
     pub position: InputPosition,
     pub pragmas: Vec<PragmaId>,
     pub imports: Vec<ImportId>,
     pub definitions: Vec<DefinitionId>,
+}
 impl Root {
     pub fn get_definition_ident(&self, h: &Heap, id: &[u8]) -> Option<DefinitionId> {
         for &def in self.definitions.iter() {
             if h[def].identifier().value == id {
                 return Some(def);
+            }
+        }
         None
+    }
+}
 impl SyntaxElement for Root {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Pragma {
     Version(PragmaVersion),
     Module(PragmaModule)
@@ @@ -815,192 +806,193 @@ impl PartialEq for PrimitiveSymbolic { @@
+}
 impl Eq for PrimitiveSymbolic{}
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct Type {
     pub primitive: PrimitiveType,
     pub array: bool,
+}
 #[allow(dead_code)]
 impl Type {
     pub const INPUT: Type = Type { primitive: PrimitiveType::Input, array: false };
     pub const OUTPUT: Type = Type { primitive: PrimitiveType::Output, array: false };
     pub const MESSAGE: Type = Type { primitive: PrimitiveType::Message, array: false };
     pub const BOOLEAN: Type = Type { primitive: PrimitiveType::Boolean, array: false };
     pub const BYTE: Type = Type { primitive: PrimitiveType::Byte, array: false };
     pub const SHORT: Type = Type { primitive: PrimitiveType::Short, array: false };
     pub const INT: Type = Type { primitive: PrimitiveType::Int, array: false };
     pub const LONG: Type = Type { primitive: PrimitiveType::Long, array: false };
     pub const INPUT_ARRAY: Type = Type { primitive: PrimitiveType::Input, array: true };
     pub const OUTPUT_ARRAY: Type = Type { primitive: PrimitiveType::Output, array: true };
     pub const MESSAGE_ARRAY: Type = Type { primitive: PrimitiveType::Message, array: true };
     pub const BOOLEAN_ARRAY: Type = Type { primitive: PrimitiveType::Boolean, array: true };
     pub const BYTE_ARRAY: Type = Type { primitive: PrimitiveType::Byte, array: true };
     pub const SHORT_ARRAY: Type = Type { primitive: PrimitiveType::Short, array: true };
     pub const INT_ARRAY: Type = Type { primitive: PrimitiveType::Int, array: true };
     pub const LONG_ARRAY: Type = Type { primitive: PrimitiveType::Long, array: true };
+}
 impl Display for Type {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match &self.primitive {
             PrimitiveType::Input => {
                 write!(f, "in")?;
+            }
             PrimitiveType::Output => {
                 write!(f, "out")?;
+            }
             PrimitiveType::Message => {
                 write!(f, "msg")?;
+            }
             PrimitiveType::Boolean => {
                 write!(f, "boolean")?;
+            }
             PrimitiveType::Byte => {
                 write!(f, "byte")?;
+            }
             PrimitiveType::Short => {
                 write!(f, "short")?;
+            }
             PrimitiveType::Int => {
                 write!(f, "int")?;
+            }
             PrimitiveType::Long => {
                 write!(f, "long")?;
+            }
             PrimitiveType::Symbolic(data) => {
                 // Type data is in ASCII range.
                 if let Some(id) = &data.definition {
                     write!(
                         f, "Symbolic({}, id: {})",
                         String::from_utf8_lossy(&data.identifier.value),
                         id.index
                     )?;
                 } else {
                     write!(
                         f, "Symbolic({}, id: Unresolved)",
                         String::from_utf8_lossy(&data.identifier.value)
                     )?;
+                }
+            }
+        }
         if self.array {
             write!(f, "[]")
         } else {
             Ok(())
+        }
+    }
+}
 type CharacterData = Vec<u8>;
 type IntegerData = i64;
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Constant {
     Null, // message
     True,
     False,
     Character(CharacterData),
     Integer(IntegerData),
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Method {
     Get,
     Put,
     Fires,
     Create,
     Symbolic(MethodSymbolic)
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct MethodSymbolic {
     pub(crate) identifier: NamespacedIdentifier,
     pub(crate) definition: Option<DefinitionId>
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Field {
     Length,
     Symbolic(Identifier),
+}
 impl Field {
     pub fn is_length(&self) -> bool {
         match self {
             Field::Length => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 pub enum Scope {
     Definition(DefinitionId),
     Regular(BlockStatementId),
     Synchronous((SynchronousStatementId, BlockStatementId)),
+}
 impl Scope {
     pub fn is_block(&self) -> bool {
         match &self {
             Scope::Definition(_) => false,
             Scope::Regular(_) => true,
             Scope::Synchronous(_) => true,
+        }
+    }
     pub fn to_block(&self) -> BlockStatementId {
         match &self {
             Scope::Regular(id) => *id,
             Scope::Synchronous((_, id)) => *id,
             _ => panic!("unable to get BlockStatement from Scope")
+        }
+    }
+}
 pub trait VariableScope {
     fn parent_scope(&self, h: &Heap) -> Option<Scope>;
     fn get_variable(&self, h: &Heap, id: &Identifier) -> Option<VariableId>;
+}
 impl VariableScope for Scope {
     fn parent_scope(&self, h: &Heap) -> Option<Scope> {
         match self {
             Scope::Definition(def) => h[*def].parent_scope(h),
             Scope::Regular(stmt) => h[*stmt].parent_scope(h),
             Scope::Synchronous((stmt, _)) => h[*stmt].parent_scope(h),
+        }
+    }
     fn get_variable(&self, h: &Heap, id: &Identifier) -> Option<VariableId> {
         match self {
             Scope::Definition(def) => h[*def].get_variable(h, id),
             Scope::Regular(stmt) => h[*stmt].get_variable(h, id),
             Scope::Synchronous((stmt, _)) => h[*stmt].get_variable(h, id),
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Variable {
     Parameter(Parameter),
     Local(Local),
+}
 impl Variable {
     pub fn identifier(&self) -> &Identifier {
         match self {
             Variable::Parameter(var) => &var.identifier,
             Variable::Local(var) => &var.identifier,
+        }
+    }
     pub fn is_parameter(&self) -> bool {
         match self {
             Variable::Parameter(_) => true,
             _ => false,
+        }
+    }
     pub fn as_parameter(&self) -> &Parameter {
         match self {
             Variable::Parameter(result) => result,
             _ => panic!("Unable to cast `Variable` to `Parameter`"),
+        }
+    }
@@ @@ -1178,412 +1170,403 @@ pub struct StructFieldDefinition { @@
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct StructDefinition {
     pub this: StructId,
     // Phase 1: parser
     pub position: InputPosition,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     pub fields: Vec<StructFieldDefinition>
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq)]
 pub enum EnumVariantValue {
     None,
     Integer(i64),
     Type(ParserTypeId),
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct EnumVariantDefinition {
     pub position: InputPosition,
     pub identifier: Identifier,
     pub value: EnumVariantValue,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct EnumDefinition {
     pub this: EnumId,
     // Phase 1: parser
     pub position: InputPosition,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     pub variants: Vec<EnumVariantDefinition>,
+}
 #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 pub enum ComponentVariant {
     Primitive,
     Composite,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Component {
     pub this: ComponentId,
     // Phase 1: parser
     pub position: InputPosition,
     pub variant: ComponentVariant,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     pub parameters: Vec<ParameterId>,
     pub body: StatementId,
+}
 impl SyntaxElement for Component {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Function {
     pub this: FunctionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub return_type: ParserTypeId,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     pub parameters: Vec<ParameterId>,
     pub body: StatementId,
+}
 impl SyntaxElement for Function {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Statement {
     Block(BlockStatement),
     Local(LocalStatement),
     Skip(SkipStatement),
     Labeled(LabeledStatement),
     If(IfStatement),
     EndIf(EndIfStatement),
     While(WhileStatement),
     EndWhile(EndWhileStatement),
     Break(BreakStatement),
     Continue(ContinueStatement),
     Synchronous(SynchronousStatement),
     EndSynchronous(EndSynchronousStatement),
     Return(ReturnStatement),
     Assert(AssertStatement),
     Goto(GotoStatement),
     New(NewStatement),
     Put(PutStatement),
     Expression(ExpressionStatement),
+}
 impl Statement {
     pub fn as_block(&self) -> &BlockStatement {
         match self {
             Statement::Block(result) => result,
             _ => panic!("Unable to cast `Statement` to `BlockStatement`"),
+        }
+    }
     pub fn as_block_mut(&mut self) -> &mut BlockStatement {
         match self {
             Statement::Block(result) => result,
             _ => panic!("Unable to cast `Statement` to `BlockStatement`"),
+        }
+    }
     pub fn as_local(&self) -> &LocalStatement {
         match self {
             Statement::Local(result) => result,
             _ => panic!("Unable to cast `Statement` to `LocalStatement`"),
+        }
+    }
     pub fn as_memory(&self) -> &MemoryStatement {
         self.as_local().as_memory()
+    }
     pub fn as_channel(&self) -> &ChannelStatement {
         self.as_local().as_channel()
+    }
     pub fn as_skip(&self) -> &SkipStatement {
         match self {
             Statement::Skip(result) => result,
             _ => panic!("Unable to cast `Statement` to `SkipStatement`"),
+        }
+    }
     pub fn as_labeled(&self) -> &LabeledStatement {
         match self {
             Statement::Labeled(result) => result,
             _ => panic!("Unable to cast `Statement` to `LabeledStatement`"),
+        }
+    }
     pub fn as_labeled_mut(&mut self) -> &mut LabeledStatement {
         match self {
             Statement::Labeled(result) => result,
             _ => panic!("Unable to cast `Statement` to `LabeledStatement`"),
+        }
+    }
     pub fn as_if(&self) -> &IfStatement {
         match self {
             Statement::If(result) => result,
             _ => panic!("Unable to cast `Statement` to `IfStatement`"),
+        }
+    }
     pub fn as_if_mut(&mut self) -> &mut IfStatement {
         match self {
             Statement::If(result) => result,
             _ => panic!("Unable to cast 'Statement' to 'IfStatement'"),
+        }
+    }
     pub fn as_end_if(&self) -> &EndIfStatement {
         match self {
             Statement::EndIf(result) => result,
             _ => panic!("Unable to cast `Statement` to `EndIfStatement`"),
+        }
+    }
     pub fn is_while(&self) -> bool {
         match self {
             Statement::While(_) => true,
             _ => false,
+        }
+    }
     pub fn as_while(&self) -> &WhileStatement {
         match self {
             Statement::While(result) => result,
             _ => panic!("Unable to cast `Statement` to `WhileStatement`"),
+        }
+    }
     pub fn as_while_mut(&mut self) -> &mut WhileStatement {
         match self {
             Statement::While(result) => result,
             _ => panic!("Unable to cast `Statement` to `WhileStatement`"),
+        }
+    }
     pub fn as_end_while(&self) -> &EndWhileStatement {
         match self {
             Statement::EndWhile(result) => result,
             _ => panic!("Unable to cast `Statement` to `EndWhileStatement`"),
+        }
+    }
     pub fn as_break(&self) -> &BreakStatement {
         match self {
             Statement::Break(result) => result,
             _ => panic!("Unable to cast `Statement` to `BreakStatement`"),
+        }
+    }
     pub fn as_break_mut(&mut self) -> &mut BreakStatement {
         match self {
             Statement::Break(result) => result,
             _ => panic!("Unable to cast `Statement` to `BreakStatement`"),
+        }
+    }
     pub fn as_continue(&self) -> &ContinueStatement {
         match self {
             Statement::Continue(result) => result,
             _ => panic!("Unable to cast `Statement` to `ContinueStatement`"),
+        }
+    }
     pub fn as_continue_mut(&mut self) -> &mut ContinueStatement {
         match self {
             Statement::Continue(result) => result,
             _ => panic!("Unable to cast `Statement` to `ContinueStatement`"),
+        }
+    }
     pub fn as_synchronous(&self) -> &SynchronousStatement {
         match self {
             Statement::Synchronous(result) => result,
             _ => panic!("Unable to cast `Statement` to `SynchronousStatement`"),
+        }
+    }
     pub fn as_synchronous_mut(&mut self) -> &mut SynchronousStatement {
         match self {
             Statement::Synchronous(result) => result,
             _ => panic!("Unable to cast `Statement` to `SynchronousStatement`"),
+        }
+    }
     pub fn as_end_synchronous(&self) -> &EndSynchronousStatement {
         match self {
             Statement::EndSynchronous(result) => result,
             _ => panic!("Unable to cast `Statement` to `EndSynchronousStatement`"),
+        }
+    }
     pub fn as_return(&self) -> &ReturnStatement {
         match self {
             Statement::Return(result) => result,
             _ => panic!("Unable to cast `Statement` to `ReturnStatement`"),
+        }
+    }
     pub fn as_assert(&self) -> &AssertStatement {
         match self {
             Statement::Assert(result) => result,
             _ => panic!("Unable to cast `Statement` to `AssertStatement`"),
+        }
+    }
     pub fn as_goto(&self) -> &GotoStatement {
         match self {
             Statement::Goto(result) => result,
             _ => panic!("Unable to cast `Statement` to `GotoStatement`"),
+        }
+    }
     pub fn as_goto_mut(&mut self) -> &mut GotoStatement {
         match self {
             Statement::Goto(result) => result,
             _ => panic!("Unable to cast `Statement` to `GotoStatement`"),
+        }
+    }
     pub fn as_new(&self) -> &NewStatement {
         match self {
             Statement::New(result) => result,
             _ => panic!("Unable to cast `Statement` to `NewStatement`"),
+        }
+    }
     pub fn as_put(&self) -> &PutStatement {
         match self {
             Statement::Put(result) => result,
             _ => panic!("Unable to cast `Statement` to `PutStatement`"),
+        }
+    }
     pub fn as_expression(&self) -> &ExpressionStatement {
         match self {
             Statement::Expression(result) => result,
             _ => panic!("Unable to cast `Statement` to `ExpressionStatement`"),
+        }
+    }
     pub fn link_next(&mut self, next: StatementId) {
         match self {
             Statement::Block(_) => todo!(),
             Statement::Local(stmt) => match stmt {
                 LocalStatement::Channel(stmt) => stmt.next = Some(next),
                 LocalStatement::Memory(stmt) => stmt.next = Some(next),
             },
             Statement::Skip(stmt) => stmt.next = Some(next),
             Statement::EndIf(stmt) => stmt.next = Some(next),
             Statement::EndWhile(stmt) => stmt.next = Some(next),
             Statement::EndSynchronous(stmt) => stmt.next = Some(next),
             Statement::Assert(stmt) => stmt.next = Some(next),
             Statement::New(stmt) => stmt.next = Some(next),
             Statement::Put(stmt) => stmt.next = Some(next),
             Statement::Expression(stmt) => stmt.next = Some(next),
             Statement::Return(_)
             | Statement::Break(_)
             | Statement::Continue(_)
             | Statement::Synchronous(_)
             | Statement::Goto(_)
             | Statement::While(_)
             | Statement::Labeled(_)
             | Statement::If(_) => unreachable!(),
+        }
+    }
+}
 impl SyntaxElement for Statement {
     fn position(&self) -> InputPosition {
         match self {
             Statement::Block(stmt) => stmt.position(),
             Statement::Local(stmt) => stmt.position(),
             Statement::Skip(stmt) => stmt.position(),
             Statement::Labeled(stmt) => stmt.position(),
             Statement::If(stmt) => stmt.position(),
             Statement::EndIf(stmt) => stmt.position(),
             Statement::While(stmt) => stmt.position(),
             Statement::EndWhile(stmt) => stmt.position(),
             Statement::Break(stmt) => stmt.position(),
             Statement::Continue(stmt) => stmt.position(),
             Statement::Synchronous(stmt) => stmt.position(),
             Statement::EndSynchronous(stmt) => stmt.position(),
             Statement::Return(stmt) => stmt.position(),
             Statement::Assert(stmt) => stmt.position(),
             Statement::Goto(stmt) => stmt.position(),
             Statement::New(stmt) => stmt.position(),
             Statement::Put(stmt) => stmt.position(),
             Statement::Expression(stmt) => stmt.position(),
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct BlockStatement {
     pub this: BlockStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub statements: Vec<StatementId>,
     // Phase 2: linker
     pub parent_scope: Option<Scope>,
     pub relative_pos_in_parent: u32,
     pub locals: Vec<LocalId>,
     pub labels: Vec<LabeledStatementId>,
+}
 impl BlockStatement {
     pub fn parent_block(&self, h: &Heap) -> Option<BlockStatementId> {
         let parent = self.parent_scope.unwrap();
         match parent {
             Scope::Definition(_) => {
                 // If the parent scope is a definition, then there is no
                 // parent block.
                 None
+            }
             Scope::Synchronous((parent, _)) => {
                 // It is always the case that when this function is called,
                 // the parent of a synchronous statement is a block statement:
                 // nested synchronous statements are flagged illegal,
                 // and that happens before resolving variables that
                 // creates the parent_scope references in the first place.
                 Some(h[parent].parent_scope(h).unwrap().to_block())
+            }
             Scope::Regular(parent) => {
                 // A variable scope is either a definition, sync, or block.
                 Some(parent)
+            }
+        }
+    }
     pub fn first(&self) -> StatementId {
         // It is an invariant (guaranteed by the lexer) that block statements have at least one stmt
         *self.statements.first().unwrap()
+    }
+}
 impl SyntaxElement for BlockStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 impl VariableScope for BlockStatement {
     fn parent_scope(&self, _h: &Heap) -> Option<Scope> {
         self.parent_scope.clone()
+    }
     fn get_variable(&self, h: &Heap, id: &Identifier) -> Option<VariableId> {
         for local_id in self.locals.iter() {
             let local = &h[*local_id];
             if local.identifier.value == id.value {
                 return Some(local_id.0);
+            }
+        }
         None
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum LocalStatement {
     Memory(MemoryStatement),
     Channel(ChannelStatement),
+}
 impl LocalStatement {
     pub fn this(&self) -> LocalStatementId {
         match self {
             LocalStatement::Memory(stmt) => stmt.this.upcast(),
             LocalStatement::Channel(stmt) => stmt.this.upcast(),
+        }
+    }
     pub fn as_memory(&self) -> &MemoryStatement {
         match self {
             LocalStatement::Memory(result) => result,
             _ => panic!("Unable to cast `LocalStatement` to `MemoryStatement`"),
+        }
+    }
     pub fn as_channel(&self) -> &ChannelStatement {
         match self {
             LocalStatement::Channel(result) => result,
             _ => panic!("Unable to cast `LocalStatement` to `ChannelStatement`"),
+        }
+    }
     pub fn next(&self) -> Option<StatementId> {
         match self {
             LocalStatement::Memory(stmt) => stmt.next,
@@ @@ -1790,349 +1773,338 @@ impl SyntaxElement for SynchronousStatement { @@
+    }
+}
 impl VariableScope for SynchronousStatement {
     fn parent_scope(&self, _h: &Heap) -> Option<Scope> {
         self.parent_scope.clone()
+    }
     fn get_variable(&self, _h: &Heap, _id: &Identifier) -> Option<VariableId> {
         // TODO: Another case of "where was this used for?"
         // for parameter_id in self.parameters.iter() {
         //     let parameter = &h[*parameter_id];
         //     if parameter.identifier.value == id.value {
         //         return Some(parameter_id.0);
         //     }
         // }
         None
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct EndSynchronousStatement {
     pub this: EndSynchronousStatementId,
     // Phase 2: linker
     pub position: InputPosition, // of corresponding sync statement
     pub start_sync: SynchronousStatementId,
     pub next: Option<StatementId>,
+}
 impl SyntaxElement for EndSynchronousStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ReturnStatement {
     pub this: ReturnStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub expression: ExpressionId,
+}
 impl SyntaxElement for ReturnStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct AssertStatement {
     pub this: AssertStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub expression: ExpressionId,
     // Phase 2: linker
     pub next: Option<StatementId>,
+}
 impl SyntaxElement for AssertStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct GotoStatement {
     pub this: GotoStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub label: Identifier,
     // Phase 2: linker
     pub target: Option<LabeledStatementId>,
+}
 impl SyntaxElement for GotoStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct NewStatement {
     pub this: NewStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub expression: CallExpressionId,
     // Phase 2: linker
     pub next: Option<StatementId>,
+}
 impl SyntaxElement for NewStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PutStatement {
     pub this: PutStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub port: ExpressionId,
     pub message: ExpressionId,
     // Phase 2: linker
     pub next: Option<StatementId>,
+}
 impl SyntaxElement for PutStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ExpressionStatement {
     pub this: ExpressionStatementId,
     // Phase 1: parser
     pub position: InputPosition,
     pub expression: ExpressionId,
     // Phase 2: linker
     pub next: Option<StatementId>,
+}
 impl SyntaxElement for ExpressionStatement {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, PartialEq, Eq, Clone, Copy, serde::Serialize, serde::Deserialize)]
 pub enum ExpressionParent {
     None, // only set during initial parsing
     Memory(MemoryStatementId),
     If(IfStatementId),
     While(WhileStatementId),
     Return(ReturnStatementId),
     Assert(AssertStatementId),
     New(NewStatementId),
     Put(PutStatementId, u32), // index of arg
     ExpressionStmt(ExpressionStatementId),
     Expression(ExpressionId, u32) // index within expression (e.g LHS or RHS of expression)
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Expression {
     Assignment(AssignmentExpression),
     Conditional(ConditionalExpression),
     Binary(BinaryExpression),
     Unary(UnaryExpression),
     Indexing(IndexingExpression),
     Slicing(SlicingExpression),
     Select(SelectExpression),
     Array(ArrayExpression),
     Constant(ConstantExpression),
     Call(CallExpression),
     Variable(VariableExpression),
+}
 impl Expression {
     pub fn as_assignment(&self) -> &AssignmentExpression {
         match self {
             Expression::Assignment(result) => result,
             _ => panic!("Unable to cast `Expression` to `AssignmentExpression`"),
+        }
+    }
     pub fn as_conditional(&self) -> &ConditionalExpression {
         match self {
             Expression::Conditional(result) => result,
             _ => panic!("Unable to cast `Expression` to `ConditionalExpression`"),
+        }
+    }
     pub fn as_binary(&self) -> &BinaryExpression {
         match self {
             Expression::Binary(result) => result,
             _ => panic!("Unable to cast `Expression` to `BinaryExpression`"),
+        }
+    }
     pub fn as_unary(&self) -> &UnaryExpression {
         match self {
             Expression::Unary(result) => result,
             _ => panic!("Unable to cast `Expression` to `UnaryExpression`"),
+        }
+    }
     pub fn as_indexing(&self) -> &IndexingExpression {
         match self {
             Expression::Indexing(result) => result,
             _ => panic!("Unable to cast `Expression` to `IndexingExpression`"),
+        }
+    }
     pub fn as_slicing(&self) -> &SlicingExpression {
         match self {
             Expression::Slicing(result) => result,
             _ => panic!("Unable to cast `Expression` to `SlicingExpression`"),
+        }
+    }
     pub fn as_select(&self) -> &SelectExpression {
         match self {
             Expression::Select(result) => result,
             _ => panic!("Unable to cast `Expression` to `SelectExpression`"),
+        }
+    }
     pub fn as_array(&self) -> &ArrayExpression {
         match self {
             Expression::Array(result) => result,
             _ => panic!("Unable to cast `Expression` to `ArrayExpression`"),
+        }
+    }
     pub fn as_constant(&self) -> &ConstantExpression {
         match self {
             Expression::Constant(result) => result,
             _ => panic!("Unable to cast `Expression` to `ConstantExpression`"),
+        }
+    }
     pub fn as_call(&self) -> &CallExpression {
         match self {
             Expression::Call(result) => result,
             _ => panic!("Unable to cast `Expression` to `CallExpression`"),
+        }
+    }
     pub fn as_call_mut(&mut self) -> &mut CallExpression {
         match self {
             Expression::Call(result) => result,
             _ => panic!("Unable to cast `Expression` to `CallExpression`"),
+        }
+    }
     pub fn as_variable(&self) -> &VariableExpression {
         match self {
             Expression::Variable(result) => result,
             _ => panic!("Unable to cast `Expression` to `VariableExpression`"),
+        }
+    }
     pub fn as_variable_mut(&mut self) -> &mut VariableExpression {
         match self {
             Expression::Variable(result) => result,
             _ => panic!("Unable to cast `Expression` to `VariableExpression`"),
+        }
+    }
     // TODO: @cleanup
     pub fn parent(&self) -> &ExpressionParent {
         match self {
             Expression::Assignment(expr) => &expr.parent,
             Expression::Conditional(expr) => &expr.parent,
             Expression::Binary(expr) => &expr.parent,
             Expression::Unary(expr) => &expr.parent,
             Expression::Indexing(expr) => &expr.parent,
             Expression::Slicing(expr) => &expr.parent,
             Expression::Select(expr) => &expr.parent,
             Expression::Array(expr) => &expr.parent,
             Expression::Constant(expr) => &expr.parent,
             Expression::Call(expr) => &expr.parent,
             Expression::Variable(expr) => &expr.parent,
+        }
+    }
     pub fn parent_expr_id(&self) -> Option<ExpressionId> {
         if let ExpressionParent::Expression(id, _) = self.parent() {
             Some(*id)
         } else {
             None
+        }
+    }
     pub fn set_parent(&mut self, parent: ExpressionParent) {
         match self {
             Expression::Assignment(expr) => expr.parent = parent,
             Expression::Conditional(expr) => expr.parent = parent,
             Expression::Binary(expr) => expr.parent = parent,
             Expression::Unary(expr) => expr.parent = parent,
             Expression::Indexing(expr) => expr.parent = parent,
             Expression::Slicing(expr) => expr.parent = parent,
             Expression::Select(expr) => expr.parent = parent,
             Expression::Array(expr) => expr.parent = parent,
             Expression::Constant(expr) => expr.parent = parent,
             Expression::Call(expr) => expr.parent = parent,
             Expression::Variable(expr) => expr.parent = parent,
+        }
+    }
+}
 impl SyntaxElement for Expression {
     fn position(&self) -> InputPosition {
         match self {
             Expression::Assignment(expr) => expr.position(),
             Expression::Conditional(expr) => expr.position(),
             Expression::Binary(expr) => expr.position(),
             Expression::Unary(expr) => expr.position(),
             Expression::Indexing(expr) => expr.position(),
             Expression::Slicing(expr) => expr.position(),
             Expression::Select(expr) => expr.position(),
             Expression::Array(expr) => expr.position(),
             Expression::Constant(expr) => expr.position(),
             Expression::Call(expr) => expr.position(),
             Expression::Variable(expr) => expr.position(),
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum AssignmentOperator {
     Set,
     Multiplied,
     Divided,
     Remained,
     Added,
     Subtracted,
     ShiftedLeft,
     ShiftedRight,
     BitwiseAnded,
     BitwiseXored,
     BitwiseOred,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct AssignmentExpression {
     pub this: AssignmentExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub left: ExpressionId,
     pub operation: AssignmentOperator,
     pub right: ExpressionId,
     // Phase 2: linker
     pub parent: ExpressionParent,
+}
 impl SyntaxElement for AssignmentExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ConditionalExpression {
     pub this: ConditionalExpressionId,
     // Phase 1: parser
     pub position: InputPosition,
     pub test: ExpressionId,
     pub true_expression: ExpressionId,
     pub false_expression: ExpressionId,
     // Phase 2: linker
     pub parent: ExpressionParent,
+}
 impl SyntaxElement for ConditionalExpression {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum BinaryOperator {
     Concatenate,
     LogicalOr,
     LogicalAnd,
     BitwiseOr,
     BitwiseXor,
     BitwiseAnd,
     Equality,
     Inequality,

src/protocol/ast_printer.rs

➞

Show inline comments

@@ @@ -392,365 +392,355 @@ impl ASTWriter { @@
                 self.kv(indent2).with_s_key("Condition");
                 self.write_expr(heap, stmt.test, indent3);
                 self.kv(indent2).with_s_key("TrueBody");
                 self.write_stmt(heap, stmt.true_body, indent3);
                 self.kv(indent2).with_s_key("FalseBody");
                 self.write_stmt(heap, stmt.false_body, indent3);
             },
             Statement::EndIf(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDIF_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndIf");
                 self.kv(indent2).with_s_key("StartIf").with_disp_val(&stmt.start_if.0.index);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::While(stmt) => {
                 self.kv(indent).with_id(PREFIX_WHILE_STMT_ID, stmt.this.0.index)
                     .with_s_key("While");
                 self.kv(indent2).with_s_key("EndWhile")
                     .with_opt_disp_val(stmt.end_while.as_ref().map(|v| &v.0.index));
                 self.kv(indent2).with_s_key("InSync")
                     .with_opt_disp_val(stmt.in_sync.as_ref().map(|v| &v.0.index));
                 self.kv(indent2).with_s_key("Condition");
                 self.write_expr(heap, stmt.test, indent3);
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, stmt.body, indent3);
             },
             Statement::EndWhile(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDWHILE_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndWhile");
                 self.kv(indent2).with_s_key("StartWhile").with_disp_val(&stmt.start_while.0.index);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Break(stmt) => {
                 self.kv(indent).with_id(PREFIX_BREAK_STMT_ID, stmt.this.0.index)
                     .with_s_key("Break");
                 self.kv(indent2).with_s_key("Label")
                     .with_opt_ascii_val(stmt.label.as_ref().map(|v| v.value.as_slice()));
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.index));
             },
             Statement::Continue(stmt) => {
                 self.kv(indent).with_id(PREFIX_CONTINUE_STMT_ID, stmt.this.0.index)
                     .with_s_key("Continue");
                 self.kv(indent2).with_s_key("Label")
                     .with_opt_ascii_val(stmt.label.as_ref().map(|v| v.value.as_slice()));
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.index));
             },
             Statement::Synchronous(stmt) => {
                 self.kv(indent).with_id(PREFIX_SYNC_STMT_ID, stmt.this.0.index)
                     .with_s_key("Synchronous");
                 self.kv(indent2).with_s_key("EndSync")
                     .with_opt_disp_val(stmt.end_sync.as_ref().map(|v| &v.0.index));
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, stmt.body, indent3);
             },
             Statement::EndSynchronous(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDSYNC_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndSynchronous");
                 self.kv(indent2).with_s_key("StartSync").with_disp_val(&stmt.start_sync.0.index);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Return(stmt) => {
                 self.kv(indent).with_id(PREFIX_RETURN_STMT_ID, stmt.this.0.index)
                     .with_s_key("Return");
                 self.kv(indent2).with_s_key("Expression");
                 self.write_expr(heap, stmt.expression, indent3);
             },
             Statement::Assert(stmt) => {
                 self.kv(indent).with_id(PREFIX_ASSERT_STMT_ID, stmt.this.0.index)
                     .with_s_key("Assert");
                 self.kv(indent2).with_s_key("Expression");
                 self.write_expr(heap, stmt.expression, indent3);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Goto(stmt) => {
                 self.kv(indent).with_id(PREFIX_GOTO_STMT_ID, stmt.this.0.index)
                     .with_s_key("Goto");
                 self.kv(indent2).with_s_key("Label").with_ascii_val(&stmt.label.value);
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.index));
             },
             Statement::New(stmt) => {
                 self.kv(indent).with_id(PREFIX_NEW_STMT_ID, stmt.this.0.index)
                     .with_s_key("New");
                 self.kv(indent2).with_s_key("Expression");
                 self.write_expr(heap, stmt.expression.upcast(), indent3);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Put(stmt) => {
                 self.kv(indent).with_id(PREFIX_PUT_STMT_ID, stmt.this.0.index)
                     .with_s_key("Put");
                 self.kv(indent2).with_s_key("Port");
                 self.write_expr(heap, stmt.port, indent3);
                 self.kv(indent2).with_s_key("Message");
                 self.write_expr(heap, stmt.message, indent3);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Expression(stmt) => {
                 self.kv(indent).with_id(PREFIX_EXPR_STMT_ID, stmt.this.0.index)
                     .with_s_key("ExpressionStatement");
                 self.write_expr(heap, stmt.expression, indent2);
                 self.kv(indent2).with_s_key("Next")
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
+            }
+        }
+    }
     fn write_expr(&mut self, heap: &Heap, expr_id: ExpressionId, indent: usize) {
         let expr = &heap[expr_id];
         let indent2 = indent + 1;
         let indent3 = indent2 + 1;
         match expr {
             Expression::Assignment(expr) => {
                 self.kv(indent).with_id(PREFIX_ASSIGNMENT_EXPR_ID, expr.this.0.index)
                     .with_s_key("AssignmentExpr");
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Left");
                 self.write_expr(heap, expr.left, indent3);
                 self.kv(indent2).with_s_key("Right");
                 self.write_expr(heap, expr.right, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Conditional(expr) => {
                 self.kv(indent).with_id(PREFIX_CONDITIONAL_EXPR_ID, expr.this.0.index)
                     .with_s_key("ConditionalExpr");
                 self.kv(indent2).with_s_key("Condition");
                 self.write_expr(heap, expr.test, indent3);
                 self.kv(indent2).with_s_key("TrueExpression");
                 self.write_expr(heap, expr.true_expression, indent3);
                 self.kv(indent2).with_s_key("FalseExpression");
                 self.write_expr(heap, expr.false_expression, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Binary(expr) => {
                 self.kv(indent).with_id(PREFIX_BINARY_EXPR_ID, expr.this.0.index)
                     .with_s_key("BinaryExpr");
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Left");
                 self.write_expr(heap, expr.left, indent3);
                 self.kv(indent2).with_s_key("Right");
                 self.write_expr(heap, expr.right, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Unary(expr) => {
                 self.kv(indent).with_id(PREFIX_UNARY_EXPR_ID, expr.this.0.index)
                     .with_s_key("UnaryExpr");
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Argument");
                 self.write_expr(heap, expr.expression, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Indexing(expr) => {
                 self.kv(indent).with_id(PREFIX_INDEXING_EXPR_ID, expr.this.0.index)
                     .with_s_key("IndexingExpr");
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("Index");
                 self.write_expr(heap, expr.index, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Slicing(expr) => {
                 self.kv(indent).with_id(PREFIX_SLICING_EXPR_ID, expr.this.0.index)
                     .with_s_key("SlicingExpr");
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("FromIndex");
                 self.write_expr(heap, expr.from_index, indent3);
                 self.kv(indent2).with_s_key("ToIndex");
                 self.write_expr(heap, expr.to_index, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Select(expr) => {
                 self.kv(indent).with_id(PREFIX_SELECT_EXPR_ID, expr.this.0.index)
                     .with_s_key("SelectExpr");
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 match &expr.field {
                     Field::Length => {
                         self.kv(indent2).with_s_key("Field").with_s_val("length");
                     },
                     Field::Symbolic(field) => {
                         self.kv(indent2).with_s_key("Field").with_ascii_val(&field.value);
+                    }
+                }
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Array(expr) => {
                 self.kv(indent).with_id(PREFIX_ARRAY_EXPR_ID, expr.this.0.index)
                     .with_s_key("ArrayExpr");
                 self.kv(indent2).with_s_key("Elements");
                 for expr_id in &expr.elements {
                     self.write_expr(heap, *expr_id, indent3);
+                }
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Constant(expr) => {
                 self.kv(indent).with_id(PREFIX_CONST_EXPR_ID, expr.this.0.index)
                     .with_s_key("ConstantExpr");
                 let val = self.kv(indent2).with_s_key("Value");
                 match &expr.value {
                     Constant::Null => { val.with_s_val("null"); },
                     Constant::True => { val.with_s_val("true"); },
                     Constant::False => { val.with_s_val("false"); },
                     Constant::Character(char) => { val.with_ascii_val(char); },
                     Constant::Integer(int) => { val.with_disp_val(int); },
+                }
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Call(expr) => {
                 self.kv(indent).with_id(PREFIX_CALL_EXPR_ID, expr.this.0.index)
                     .with_s_key("CallExpr");
                 // Method
                 let method = self.kv(indent2).with_s_key("Method");
                 match &expr.method {
                     Method::Get => { method.with_s_val("get"); },
                     Method::Put => { method.with_s_val("put"); },
                     Method::Fires => { method.with_s_val("fires"); },
                     Method::Create => { method.with_s_val("create"); },
                     Method::Symbolic(symbolic) => {
                         method.with_s_val("symbolic");
                         self.kv(indent3).with_s_key("Name").with_ascii_val(&symbolic.identifier.value);
                         self.kv(indent3).with_s_key("Definition")
                             .with_opt_disp_val(symbolic.definition.as_ref().map(|v| &v.index));
+                    }
+                }
                 // Arguments
                 self.kv(indent2).with_s_key("Arguments");
                 for arg_id in &expr.arguments {
                     self.write_expr(heap, *arg_id, indent3);
+                }
                 // Parent
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Variable(expr) => {
                 self.kv(indent).with_id(PREFIX_VARIABLE_EXPR_ID, expr.this.0.index)
                     .with_s_key("VariableExpr");
                 self.kv(indent2).with_s_key("Name").with_ascii_val(&expr.identifier.value);
                 self.kv(indent2).with_s_key("Definition")
                     .with_opt_disp_val(expr.declaration.as_ref().map(|v| &v.index));
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
+            }
+        }
+    }
     fn write_local(&mut self, heap: &Heap, local_id: LocalId, indent: usize) {
         let local = &heap[local_id];
         let indent2 = indent + 1;
         self.kv(indent).with_id(PREFIX_LOCAL_ID, local_id.0.index)
             .with_s_key("Local");
         self.kv(indent2).with_s_key("Name").with_ascii_val(&local.identifier.value);
         self.kv(indent2).with_s_key("Type")
             .with_custom_val(|w| write_type(w, heap, &heap[local.parser_type]));
+    }
     //--------------------------------------------------------------------------
     // Printing Utilities
     //--------------------------------------------------------------------------
     fn kv(&mut self, indent: usize) -> KV {
         KV::new(&mut self.buffer, &mut self.temp1, &mut self.temp2, indent)
+    }
     fn flush<W: IOWrite>(&mut self, w: &mut W) {
         w.write(self.buffer.as_bytes()).unwrap();
         self.buffer.clear()
+    }
+}
 fn write_option<V: Display>(target: &mut String, value: Option<V>) {
     target.clear();
     match &value {
         Some(v) => write!(target, "Some({})", v),
         None => target.write_str("None")
     };
+}
 fn write_type(target: &mut String, heap: &Heap, t: &ParserType) {
     use ParserTypeVariant as PTV;
     let mut embedded = Vec::new();
     match &t.variant {
         PTV::Input(id) => { target.write_str("in"); embedded.push(*id); }
         PTV::Output(id) => { target.write_str("out"); embedded.push(*id) }
         PTV::Array(id) => { target.write_str("array"); embedded.push(*id) }
         PTV::Message => { target.write_str("msg"); }
         PTV::Bool => { target.write_str("bool"); }
         PTV::Byte => { target.write_str("byte"); }
         PTV::Short => { target.write_str("short"); }
         PTV::Int => { target.write_str("int"); }
         PTV::Long => { target.write_str("long"); }
         PTV::String => { target.write_str("str"); }
         PTV::IntegerLiteral => { target.write_str("int_lit"); }
         PTV::Inferred => { target.write_str("auto"); }
         PTV::Symbolic(symbolic) => {
             target.write_str(&String::from_utf8_lossy(&symbolic.identifier.value));
             match symbolic.variant {
                 Some(SymbolicParserTypeVariant::PolyArg(def_id, idx)) => {
                     target.write_str(&format!("{{def: {}, idx: {}}}", def_id.index, idx));
                 },
                 Some(SymbolicParserTypeVariant::Definition(def_id)) => {
                     target.write_str(&format!("{{def: {}}}", def_id.index));
                 },
                 None => {
                     target.write_str("{None}");
+                }
+            }
             embedded.extend(&symbolic.poly_args);
+        }
     };
     if !embedded.is_empty() {
         target.write_str("<");
         for (idx, embedded_id) in embedded.into_iter().enumerate() {
             if idx != 0 { target.write_str(", "); }
             write_type(target, heap, &heap[embedded_id]);
+        }
         target.write_str(">");
+    }
+}
 fn write_expression_parent(target: &mut String, parent: &ExpressionParent) {
     use ExpressionParent as EP;
     *target = match parent {
         EP::None => String::from("None"),
         EP::Memory(id) => format!("MemoryStmt({})", id.0.0.index),
         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::Put(id, idx) => format!("PutStmt({}, {})", id.0.index, idx),
         EP::ExpressionStmt(id) => format!("ExprStmt({})", id.0.index),
         EP::Expression(id, idx) => format!("Expr({}, {})", id.index, idx)
     };
+}
@@ \ No newline at end of file @@

src/protocol/eval.rs

➞

Show inline comments

@@ @@ -1406,371 +1406,373 @@ impl Store { @@
     fn eval(&mut self, h: &Heap, ctx: &mut EvalContext, expr: ExpressionId) -> EvalResult {
         match &h[expr] {
             Expression::Assignment(expr) => {
                 let value = self.eval(h, ctx, expr.right)?;
                 match expr.operation {
                     AssignmentOperator::Set => {
                         self.update(h, ctx, expr.left, value.clone())?;
+                    }
                     AssignmentOperator::Added => {
                         let old = self.get(h, ctx, expr.left)?;
                         self.update(h, ctx, expr.left, old.plus(&value))?;
+                    }
                     AssignmentOperator::Subtracted => {
                         let old = self.get(h, ctx, expr.left)?;
                         self.update(h, ctx, expr.left, old.minus(&value))?;
+                    }
                     _ => unimplemented!("{:?}", expr),
+                }
                 Ok(value)
+            }
             Expression::Conditional(expr) => {
                 let test = self.eval(h, ctx, expr.test)?;
                 if test.as_boolean().0 {
                     self.eval(h, ctx, expr.true_expression)
                 } else {
                     self.eval(h, ctx, expr.false_expression)
+                }
+            }
             Expression::Binary(expr) => {
                 let left = self.eval(h, ctx, expr.left)?;
                 let right;
                 match expr.operation {
                     BinaryOperator::LogicalAnd => {
                         if left.as_boolean().0 == false {
                             return Ok(left);
+                        }
                         right = self.eval(h, ctx, expr.right)?;
                         right.as_boolean(); // panics if not a boolean
                         return Ok(right);
+                    }
                     BinaryOperator::LogicalOr => {
                         if left.as_boolean().0 == true {
                             return Ok(left);
+                        }
                         right = self.eval(h, ctx, expr.right)?;
                         right.as_boolean(); // panics if not a boolean
                         return Ok(right);
+                    }
                     _ => {}
+                }
                 right = self.eval(h, ctx, expr.right)?;
                 match expr.operation {
                     BinaryOperator::Equality => Ok(left.eq(&right)),
                     BinaryOperator::Inequality => Ok(left.neq(&right)),
                     BinaryOperator::LessThan => Ok(left.lt(&right)),
                     BinaryOperator::LessThanEqual => Ok(left.lte(&right)),
                     BinaryOperator::GreaterThan => Ok(left.gt(&right)),
                     BinaryOperator::GreaterThanEqual => Ok(left.gte(&right)),
                     BinaryOperator::Remainder => Ok(left.modulus(&right)),
                     BinaryOperator::Add => Ok(left.plus(&right)),
                     _ => unimplemented!("{:?}", expr.operation),
+                }
+            }
             Expression::Unary(expr) => {
                 let mut value = self.eval(h, ctx, expr.expression)?;
                 match expr.operation {
                     UnaryOperation::PostIncrement => {
                         self.update(h, ctx, expr.expression, value.plus(&ONE))?;
+                    }
                     UnaryOperation::PreIncrement => {
                         value = value.plus(&ONE);
                         self.update(h, ctx, expr.expression, value.clone())?;
+                    }
                     UnaryOperation::PostDecrement => {
                         self.update(h, ctx, expr.expression, value.minus(&ONE))?;
+                    }
                     UnaryOperation::PreDecrement => {
                         value = value.minus(&ONE);
                         self.update(h, ctx, expr.expression, value.clone())?;
+                    }
                     _ => unimplemented!(),
+                }
                 Ok(value)
+            }
             Expression::Indexing(expr) => self.get(h, ctx, expr.this.upcast()),
             Expression::Slicing(_expr) => unimplemented!(),
             Expression::Select(expr) => self.get(h, ctx, expr.this.upcast()),
             Expression::Array(expr) => {
                 let mut elements = Vec::new();
                 for &elem in expr.elements.iter() {
                     elements.push(self.eval(h, ctx, elem)?);
+                }
                 todo!()
+            }
             Expression::Constant(expr) => Ok(Value::from_constant(&expr.value)),
             Expression::Call(expr) => match &expr.method {
-                Method::Create => {
+                Method::Get => {
                     assert_eq!(1, expr.arguments.len());
                     let length = self.eval(h, ctx, expr.arguments[0])?;
                     Ok(Value::create_message(length))
                     let value = self.eval(h, ctx, expr.arguments[0])?;
                     match ctx.get(value.clone()) {
                         None => Err(EvalContinuation::BlockGet(value)),
                         Some(result) => Ok(result),
+                    }
+                }
                 Method::Put => {
                     assert_eq!(2, expr.arguments.len());
                     let port_value = self.eval(h, ctx, expr.arguments[0])?;
                     let msg_value = self.eval(h, ctx, expr.arguments[1])?;
                     if ctx.did_put(port_value.clone()) {
                         // Return bogus, replacing this at some point anyway
                         Ok(Value::Message(MessageValue(None)))
                     } else {
                         Err(EvalContinuation::Put(port_value, msg_value))
+                    }
+                }
                 Method::Fires => {
                     assert_eq!(1, expr.arguments.len());
                     let value = self.eval(h, ctx, expr.arguments[0])?;
                     match ctx.fires(value.clone()) {
                         None => Err(EvalContinuation::BlockFires(value)),
                         Some(result) => Ok(result),
+                    }
+                }
-                Method::Get => {
+                Method::Create => {
                     assert_eq!(1, expr.arguments.len());
                     let value = self.eval(h, ctx, expr.arguments[0])?;
                     match ctx.get(value.clone()) {
                         None => Err(EvalContinuation::BlockGet(value)),
                         Some(result) => Ok(result),
+                    }
                     let length = self.eval(h, ctx, expr.arguments[0])?;
                     Ok(Value::create_message(length))
+                }
                 Method::Symbolic(_symbol) => unimplemented!(),
             },
             Expression::Variable(expr) => self.get(h, ctx, expr.this.upcast()),
+        }
+    }
+}
 type EvalResult = Result<Value, EvalContinuation>;
 pub enum EvalContinuation {
     Stepping,
     Inconsistent,
     Terminal,
     SyncBlockStart,
     SyncBlockEnd,
     NewComponent(DefinitionId, Vec<Value>),
     BlockFires(Value),
     BlockGet(Value),
     Put(Value, Value),
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub(crate) struct Prompt {
     definition: DefinitionId,
     store: Store,
     position: Option<StatementId>,
+}
 impl Prompt {
     pub fn new(h: &Heap, def: DefinitionId, args: &Vec<Value>) -> Self {
         let mut prompt =
             Prompt { definition: def, store: Store::new(), position: Some((&h[def]).body()) };
         prompt.set_arguments(h, args);
         prompt
+    }
     fn set_arguments(&mut self, h: &Heap, args: &Vec<Value>) {
         let def = &h[self.definition];
         let params = def.parameters();
         assert_eq!(params.len(), args.len());
         for (param, value) in params.iter().zip(args.iter()) {
             let hparam = &h[*param];
             let parser_type = &h[hparam.parser_type];
             assert!(value.is_type_compatible(h, parser_type));
             self.store.initialize(h, param.upcast(), value.clone());
+        }
+    }
     pub fn step(&mut self, h: &Heap, ctx: &mut EvalContext) -> EvalResult {
         if self.position.is_none() {
             return Err(EvalContinuation::Terminal);
+        }
         let stmt = &h[self.position.unwrap()];
         match stmt {
             Statement::Block(stmt) => {
                 // Continue to first statement
                 self.position = Some(stmt.first());
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Memory(stmt) => {
                         // Evaluate initial expression
                         let value = self.store.eval(h, ctx, stmt.initial)?;
                         // Update store
                         self.store.initialize(h, stmt.variable.upcast(), value);
+                    }
                     LocalStatement::Channel(stmt) => {
                         let [from, to] = ctx.new_channel();
                         // Store the values in the declared variables
                         self.store.initialize(h, stmt.from.upcast(), from);
                         self.store.initialize(h, stmt.to.upcast(), to);
+                    }
+                }
                 // Continue to next statement
                 self.position = stmt.next();
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Skip(stmt) => {
                 // Continue to next statement
                 self.position = stmt.next;
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Labeled(stmt) => {
                 // Continue to next statement
                 self.position = Some(stmt.body);
                 Err(EvalContinuation::Stepping)
+            }
             Statement::If(stmt) => {
                 // Evaluate test
                 let value = self.store.eval(h, ctx, stmt.test)?;
                 // Continue with either branch
                 if value.as_boolean().0 {
                     self.position = Some(stmt.true_body);
                 } else {
                     self.position = Some(stmt.false_body);
+                }
                 Err(EvalContinuation::Stepping)
+            }
             Statement::EndIf(stmt) => {
                 // Continue to next statement
                 self.position = stmt.next;
                 Err(EvalContinuation::Stepping)
+            }
             Statement::While(stmt) => {
                 // Evaluate test
                 let value = self.store.eval(h, ctx, stmt.test)?;
                 // Either continue with body, or go to next
                 if value.as_boolean().0 {
                     self.position = Some(stmt.body);
                 } else {
                     self.position = stmt.end_while.map(|x| x.upcast());
+                }
                 Err(EvalContinuation::Stepping)
+            }
             Statement::EndWhile(stmt) => {
                 // Continue to next statement
                 self.position = stmt.next;
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Synchronous(stmt) => {
                 // Continue to next statement, and signal upward
                 self.position = Some(stmt.body);
                 Err(EvalContinuation::SyncBlockStart)
+            }
             Statement::EndSynchronous(stmt) => {
                 // Continue to next statement, and signal upward
                 self.position = stmt.next;
                 Err(EvalContinuation::SyncBlockEnd)
+            }
             Statement::Break(stmt) => {
                 // Continue to end of while
                 self.position = stmt.target.map(EndWhileStatementId::upcast);
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Continue(stmt) => {
                 // Continue to beginning of while
                 self.position = stmt.target.map(WhileStatementId::upcast);
                 Err(EvalContinuation::Stepping)
+            }
             Statement::Assert(stmt) => {
                 // Evaluate expression
                 let value = self.store.eval(h, ctx, stmt.expression)?;
                 if value.as_boolean().0 {
                     // Continue to next statement
                     self.position = stmt.next;
                     Err(EvalContinuation::Stepping)
                 } else {
                     // Assertion failed: inconsistent
                     Err(EvalContinuation::Inconsistent)
+                }
+            }
             Statement::Return(stmt) => {
                 // Evaluate expression
                 let value = self.store.eval(h, ctx, stmt.expression)?;
                 // Done with evaluation
                 Ok(value)
+            }
             Statement::Goto(stmt) => {
                 // Continue to target
                 self.position = stmt.target.map(|x| x.upcast());
                 Err(EvalContinuation::Stepping)
+            }
             Statement::New(stmt) => {
                 let expr = &h[stmt.expression];
                 let mut args = Vec::new();
                 for &arg in expr.arguments.iter() {
                     let value = self.store.eval(h, ctx, arg)?;
                     args.push(value);
+                }
                 self.position = stmt.next;
                 match &expr.method {
                     Method::Symbolic(symbolic) => {
                          Err(EvalContinuation::NewComponent(symbolic.definition.unwrap(), args))
                     },
                     _ => unreachable!("not a symbolic call expression")
+                }
+            }
             Statement::Put(stmt) => {
                 // Evaluate port and message
                 let port = self.store.eval(h, ctx, stmt.port)?;
                 let message = self.store.eval(h, ctx, stmt.message)?;
                 // Continue to next statement
                 self.position = stmt.next;
                 // Signal the put upwards
                 Err(EvalContinuation::Put(port, message))
+            }
             Statement::Expression(stmt) => {
                 // Evaluate expression
                 let _value = self.store.eval(h, ctx, stmt.expression)?;
                 // Continue to next statement
                 self.position = stmt.next;
                 Err(EvalContinuation::Stepping)
+            }
+        }
+    }
     // fn compute_function(_h: &Heap, _fun: FunctionId, _args: &Vec<Value>) -> Option<Value> {
     // let mut prompt = Self::new(h, fun.upcast(), args);
     // let mut context = EvalContext::None;
     // loop {
     //     let result = prompt.step(h, &mut context);
     //     match result {
     //         Ok(val) => return Some(val),
     //         Err(cont) => match cont {
     //             EvalContinuation::Stepping => continue,
     //             EvalContinuation::Inconsistent => return None,
     //             // Functions never terminate without returning
     //             EvalContinuation::Terminal => unreachable!(),
     //             // Functions never encounter any blocking behavior
     //             EvalContinuation::SyncBlockStart => unreachable!(),
     //             EvalContinuation::SyncBlockEnd => unreachable!(),
     //             EvalContinuation::NewComponent(_, _) => unreachable!(),
     //             EvalContinuation::BlockFires(val) => unreachable!(),
     //             EvalContinuation::BlockGet(val) => unreachable!(),
     //             EvalContinuation::Put(port, msg) => unreachable!(),
     //         },
     //     }
     // }
     // }
+}
 // #[cfg(test)]
 // mod tests {
 //     extern crate test_generator;
 //     use std::fs::File;
 //     use std::io::Read;
 //     use std::path::Path;
 //     use test_generator::test_resources;
 //     use super::*;
 //     #[test_resources("testdata/eval/positive/*.pdl")]
 //     fn batch1(resource: &str) {
 //         let path = Path::new(resource);
 //         let expect = path.with_extension("txt");
 //         let mut heap = Heap::new();
 //         let mut source = InputSource::from_file(&path).unwrap();
 //         let mut parser = Parser::new(&mut source);
 //         let pd = parser.parse(&mut heap).unwrap();
 //         let def = heap[pd].get_definition_ident(&heap, b"test").unwrap();
 //         let fun = heap[def].as_function().this;
 //         let args = Vec::new();
 //         let result = Prompt::compute_function(&heap, fun, &args).unwrap();
 //         let valstr: String = format!("{}", result);
 //         println!("{}", valstr);
 //         let mut cev: Vec<u8> = Vec::new();
 //         let mut f = File::open(expect).unwrap();
 //         f.read_to_end(&mut cev).unwrap();
 //         let lavstr = String::from_utf8_lossy(&cev);
 //         println!("{}", lavstr);
 //         assert_eq!(valstr, lavstr);
 //     }
 // }

src/protocol/lexer.rs

➞

Show inline comments

@@ @@ -1321,333 +1321,334 @@ impl Lexer<'_> { @@
             return Ok(self.consume_array_expression(h)?.upcast());
+        }
         if self.has_constant()
             || self.has_keyword(b"null")
             || self.has_keyword(b"true")
             || self.has_keyword(b"false")
+        {
             return Ok(self.consume_constant_expression(h)?.upcast());
+        }
         if self.has_call_expression() {
             return Ok(self.consume_call_expression(h)?.upcast());
+        }
         Ok(self.consume_variable_expression(h)?.upcast())
+    }
     fn consume_array_expression(&mut self, h: &mut Heap) -> Result<ArrayExpressionId, ParseError2> {
         let position = self.source.pos();
         let mut elements = Vec::new();
         self.consume_string(b"{")?;
         self.consume_whitespace(false)?;
         if !self.has_string(b"}") {
             while self.source.next().is_some() {
                 elements.push(self.consume_expression(h)?);
                 self.consume_whitespace(false)?;
                 if self.has_string(b"}") {
                     break;
+                }
                 self.consume_string(b",")?;
                 self.consume_whitespace(false)?;
+            }
+        }
         self.consume_string(b"}")?;
         Ok(h.alloc_array_expression(|this| ArrayExpression {
             this,
             position,
             elements,
             parent: ExpressionParent::None,
         }))
+    }
     fn has_constant(&self) -> bool {
         is_constant(self.source.next())
+    }
     fn consume_constant_expression(
         &mut self,
         h: &mut Heap,
     ) -> Result<ConstantExpressionId, ParseError2> {
         let position = self.source.pos();
         let value;
         if self.has_keyword(b"null") {
             self.consume_keyword(b"null")?;
             value = Constant::Null;
         } else if self.has_keyword(b"true") {
             self.consume_keyword(b"true")?;
             value = Constant::True;
         } else if self.has_keyword(b"false") {
             self.consume_keyword(b"false")?;
             value = Constant::False;
         } else if self.source.next() == Some(b'\'') {
             self.source.consume();
             let mut data = Vec::new();
             let mut next = self.source.next();
             while next != Some(b'\'') && (is_vchar(next) || next == Some(b' ')) {
                 data.push(next.unwrap());
                 self.source.consume();
                 next = self.source.next();
+            }
             if next != Some(b'\'') || data.is_empty() {
                 return Err(self.error_at_pos("Expected character constant"));
+            }
             self.source.consume();
             value = Constant::Character(data);
         } else {
             if !self.has_integer() {
                 return Err(self.error_at_pos("Expected integer constant"));
+            }
             value = Constant::Integer(self.consume_integer()?);
+        }
         Ok(h.alloc_constant_expression(|this| ConstantExpression {
             this,
             position,
             value,
             parent: ExpressionParent::None,
         }))
+    }
     fn has_call_expression(&mut self) -> bool {
         // We need to prevent ambiguity with various operators (because we may
         // be specifying polymorphic variables) and variables.
         if self.has_builtin_keyword() {
             return true;
+        }
         let backup_pos = self.source.pos();
         let mut result = false;
         if self.consume_namespaced_identifier_spilled().is_ok() &&
             self.consume_whitespace(false).is_ok() &&
-            self.maybe_consume_poly_args_spilled_without_pos_recovery().is_ok() &&
             self.maybe_consume_poly_args_spilled_without_pos_recovery() &&
             self.consume_whitespace(false).is_ok() &&
             self.source.next() == Some(b'(') {
             // Seems like we have a function call or an enum literal
             result = true;
+        }
         self.source.seek(backup_pos);
         return result;
+    }
     fn consume_call_expression(&mut self, h: &mut Heap) -> Result<CallExpressionId, ParseError2> {
         let position = self.source.pos();
         // Consume method identifier
         let method;
         if self.has_keyword(b"get") {
             self.consume_keyword(b"get")?;
             method = Method::Get;
         } else if self.has_keyword(b"put") {
             self.consume_keyword(b"put")?;
             method = Method::Put;
         } else if self.has_keyword(b"fires") {
             self.consume_keyword(b"fires")?;
             method = Method::Fires;
         } else if self.has_keyword(b"create") {
             self.consume_keyword(b"create")?;
             method = Method::Create;
         } else {
             let identifier = self.consume_namespaced_identifier()?;
             method = Method::Symbolic(MethodSymbolic{
                 identifier,
                 definition: None
             })
+        }
         // Consume polymorphic arguments
         self.consume_whitespace(false)?;
         let poly_args = self.consume_polymorphic_args(h, true)?;
         // Consume arguments to call
         self.consume_whitespace(false)?;
         let mut arguments = Vec::new();
         self.consume_string(b"(")?;
         self.consume_whitespace(false)?;
         if !self.has_string(b")") {
             // TODO: allow trailing comma
             while self.source.next().is_some() {
                 arguments.push(self.consume_expression(h)?);
                 self.consume_whitespace(false)?;
                 if self.has_string(b")") {
                     break;
+                }
                 self.consume_string(b",")?;
                 self.consume_whitespace(false)?
+            }
+        }
         self.consume_string(b")")?;
         Ok(h.alloc_call_expression(|this| CallExpression {
             this,
             position,
             method,
             arguments,
             poly_args,
             parent: ExpressionParent::None,
         }))
+    }
     fn consume_variable_expression(
         &mut self,
         h: &mut Heap,
     ) -> Result<VariableExpressionId, ParseError2> {
         let position = self.source.pos();
         let identifier = self.consume_namespaced_identifier()?;
         Ok(h.alloc_variable_expression(|this| VariableExpression {
             this,
             position,
             identifier,
             declaration: None,
             parent: ExpressionParent::None,
         }))
+    }
     // ====================
     // Statements
     // ====================
     /// Consumes any kind of statement from the source and will error if it
     /// did not encounter a statement. Will also return an error if the
     /// statement is nested too deeply.
     ///
     /// `wrap_in_block` may be set to true to ensure that the parsed statement
     /// will be wrapped in a block statement if it is not already a block
     /// statement. This is used to ensure that all `if`, `while` and `sync`
     /// statements have a block statement as body.
     fn consume_statement(&mut self, h: &mut Heap, wrap_in_block: bool) -> Result<StatementId, ParseError2> {
         if self.level >= MAX_LEVEL {
             return Err(self.error_at_pos("Too deeply nested statement"));
+        }
         self.level += 1;
         let result = self.consume_statement_impl(h, wrap_in_block);
         self.level -= 1;
         result
+    }
     fn has_label(&mut self) -> bool {
         // To prevent ambiguity with expression statements consisting only of an
         // identifier or a namespaced identifier, we look ahead and match on the
         // *single* colon that signals a labeled statement.
         let backup_pos = self.source.pos();
         let mut result = false;
         if self.consume_identifier_spilled().is_ok() {
             // next character is ':', second character is NOT ':'
             result = Some(b':') == self.source.next() && Some(b':') != self.source.lookahead(1)
+        }
         self.source.seek(backup_pos);
         return result;
+    }
     fn consume_statement_impl(&mut self, h: &mut Heap, wrap_in_block: bool) -> Result<StatementId, ParseError2> {
         // Parse and allocate statement
         let mut must_wrap = true;
         let mut stmt_id = if self.has_string(b"{") {
             must_wrap = false;
             self.consume_block_statement(h)?
         } else if self.has_keyword(b"skip") {
             must_wrap = false;
             self.consume_skip_statement(h)?.upcast()
         } else if self.has_keyword(b"if") {
             self.consume_if_statement(h)?.upcast()
         } else if self.has_keyword(b"while") {
             self.consume_while_statement(h)?.upcast()
         } else if self.has_keyword(b"break") {
             self.consume_break_statement(h)?.upcast()
         } else if self.has_keyword(b"continue") {
             self.consume_continue_statement(h)?.upcast()
         } else if self.has_keyword(b"synchronous") {
             self.consume_synchronous_statement(h)?.upcast()
         } else if self.has_keyword(b"return") {
             self.consume_return_statement(h)?.upcast()
         } else if self.has_keyword(b"assert") {
             self.consume_assert_statement(h)?.upcast()
         } else if self.has_keyword(b"goto") {
             self.consume_goto_statement(h)?.upcast()
         } else if self.has_keyword(b"new") {
             self.consume_new_statement(h)?.upcast()
         } else if self.has_keyword(b"put") {
             self.consume_put_statement(h)?.upcast()
         } else if self.has_label() {
             self.consume_labeled_statement(h)?.upcast()
         } else {
             self.consume_expression_statement(h)?.upcast()
         };
         // Wrap if desired and if needed
         if must_wrap && wrap_in_block {
             let position = h[stmt_id].position();
             let block_wrapper = h.alloc_block_statement(|this| BlockStatement{
                 this,
                 position,
                 statements: vec![stmt_id],
                 parent_scope: None,
                 relative_pos_in_parent: 0,
                 locals: Vec::new(),
                 labels: Vec::new()
             });
             stmt_id = block_wrapper.upcast();
+        }
         Ok(stmt_id)
+    }
     fn has_local_statement(&mut self) -> bool {
         /* To avoid ambiguity, we look ahead to find either the
         channel keyword that signals a variable declaration, or
         a type annotation followed by another identifier.
         Example:
           my_type[] x = {5}; // memory statement
           my_var[5] = x; // assignment expression, expression statement
         Note how both the local and the assignment
         start with arbitrary identifier followed by [. */
         if self.has_keyword(b"channel") {
             return true;
+        }
         if self.has_statement_keyword() {
             return false;
+        }
         let backup_pos = self.source.pos();
         let mut result = false;
         if self.maybe_consume_type_spilled_without_pos_recovery() {
             // We seem to have a valid type, do we now have an identifier?
             if self.consume_whitespace(true).is_ok() {
                 result = self.has_identifier();
+            }
+        }
         self.source.seek(backup_pos);
         return result;
+    }
     fn consume_block_statement(&mut self, h: &mut Heap) -> Result<StatementId, ParseError2> {
         let position = self.source.pos();
         let mut statements = Vec::new();
         self.consume_string(b"{")?;
         self.consume_whitespace(false)?;
         while self.has_local_statement() {
             statements.push(self.consume_local_statement(h)?.upcast());
             self.consume_whitespace(false)?;
+        }
         while !self.has_string(b"}") {
             statements.push(self.consume_statement(h, false)?);
             self.consume_whitespace(false)?;
+        }
         self.consume_string(b"}")?;
         if statements.is_empty() {
             Ok(h.alloc_skip_statement(|this| SkipStatement { this, position, next: None }).upcast())
         } else {
             Ok(h.alloc_block_statement(|this| BlockStatement {
                 this,
                 position,
                 statements,
                 parent_scope: None,
                 relative_pos_in_parent: 0,
                 locals: Vec::new(),
                 labels: Vec::new(),
             })
             .upcast())
+        }
+    }
     fn consume_local_statement(&mut self, h: &mut Heap) -> Result<LocalStatementId, ParseError2> {
         if self.has_keyword(b"channel") {
             Ok(self.consume_channel_statement(h)?.upcast())
         } else {
             Ok(self.consume_memory_statement(h)?.upcast())
+        }
+    }
     fn consume_channel_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<ChannelStatementId, ParseError2> {
         // Consume channel statement and polymorphic argument if specified
         let position = self.source.pos();
         self.consume_keyword(b"channel")?;
         let poly_args = self.consume_polymorphic_args(h, true)?;
@@ @@ -1806,208 +1807,192 @@ impl Lexer<'_> { @@
+    }
     fn consume_continue_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<ContinueStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"continue")?;
         self.consume_whitespace(false)?;
         let label;
         if self.has_identifier() {
             label = Some(self.consume_identifier()?);
             self.consume_whitespace(false)?;
         } else {
             label = None;
+        }
         self.consume_string(b";")?;
         Ok(h.alloc_continue_statement(|this| ContinueStatement {
             this,
             position,
             label,
             target: None,
         }))
+    }
     fn consume_synchronous_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<SynchronousStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"synchronous")?;
         self.consume_whitespace(false)?;
         // TODO: What was the purpose of this? Seems superfluous and confusing?
         // let mut parameters = Vec::new();
         // if self.has_string(b"(") {
         //     self.consume_parameters(h, &mut parameters)?;
         //     self.consume_whitespace(false)?;
         // } else if !self.has_keyword(b"skip") && !self.has_string(b"{") {
         //     return Err(self.error_at_pos("Expected block statement"));
         // }
         let body = self.consume_statement(h, true)?;
         Ok(h.alloc_synchronous_statement(|this| SynchronousStatement {
             this,
             position,
             body,
             end_sync: None,
             parent_scope: None,
         }))
+    }
     fn consume_return_statement(&mut self, h: &mut Heap) -> Result<ReturnStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"return")?;
         self.consume_whitespace(false)?;
         let expression = if self.has_string(b"(") {
             self.consume_paren_expression(h)
         } else {
             self.consume_expression(h)
         }?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_return_statement(|this| ReturnStatement { this, position, expression }))
+    }
     fn consume_assert_statement(&mut self, h: &mut Heap) -> Result<AssertStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"assert")?;
         self.consume_whitespace(false)?;
         let expression = if self.has_string(b"(") {
             self.consume_paren_expression(h)
         } else {
             self.consume_expression(h)
         }?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_assert_statement(|this| AssertStatement {
             this,
             position,
             expression,
             next: None,
         }))
+    }
     fn consume_goto_statement(&mut self, h: &mut Heap) -> Result<GotoStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"goto")?;
         self.consume_whitespace(false)?;
         let label = self.consume_identifier()?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_goto_statement(|this| GotoStatement { this, position, label, target: None }))
+    }
     fn consume_new_statement(&mut self, h: &mut Heap) -> Result<NewStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"new")?;
         self.consume_whitespace(false)?;
         let expression = self.consume_call_expression(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_new_statement(|this| NewStatement { this, position, expression, next: None }))
+    }
     fn consume_put_statement(&mut self, h: &mut Heap) -> Result<PutStatementId, ParseError2> {
         let position = self.source.pos();
         self.consume_keyword(b"put")?;
         self.consume_whitespace(false)?;
         self.consume_string(b"(")?;
         let port = self.consume_expression(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b",")?;
         self.consume_whitespace(false)?;
         let message = self.consume_expression(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b")")?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_put_statement(|this| PutStatement { this, position, port, message, next: None }))
+    }
     fn consume_expression_statement(
         &mut self,
         h: &mut Heap,
     ) -> Result<ExpressionStatementId, ParseError2> {
         let position = self.source.pos();
         let expression = self.consume_expression(h)?;
         self.consume_whitespace(false)?;
         self.consume_string(b";")?;
         Ok(h.alloc_expression_statement(|this| ExpressionStatement {
             this,
             position,
             expression,
             next: None,
         }))
+    }
     // ====================
     // Symbol definitions
     // ====================
     fn has_symbol_definition(&self) -> bool {
         self.has_keyword(b"composite")
             || self.has_keyword(b"primitive")
             || self.has_type_keyword()
             || self.has_identifier()
+    }
     fn consume_symbol_definition(&mut self, h: &mut Heap) -> Result<DefinitionId, ParseError2> {
         if self.has_keyword(b"struct") {
             Ok(self.consume_struct_definition(h)?.upcast())
         } else if self.has_keyword(b"enum") {
             Ok(self.consume_enum_definition(h)?.upcast())
         } else if self.has_keyword(b"composite") || self.has_keyword(b"primitive") {
             Ok(self.consume_component_definition(h)?.upcast())
         } else {
             Ok(self.consume_function_definition(h)?.upcast())
+        }
+    }
     fn consume_struct_definition(&mut self, h: &mut Heap) -> Result<StructId, ParseError2> {
         // Parse "struct" keyword, optional polyvars and its identifier
         let struct_pos = self.source.pos();
         self.consume_keyword(b"struct")?;
         self.consume_whitespace(true)?;
         let struct_ident = self.consume_identifier()?;
         let poly_vars = self.consume_polymorphic_vars()?;
         self.consume_whitespace(false)?;
         // Parse struct fields
         self.consume_string(b"{")?;
         let mut next = self.source.next();
         let mut fields = Vec::new();
         while next.is_some() {
             let char = next.unwrap();
             if char == b'}' {
                 break;
+            }
             // Consume field definition
             self.consume_whitespace(false)?;
             let field_position = self.source.pos();
             let field_parser_type = self.consume_type2(h, false)?;
             self.consume_whitespace(true)?;
             let field_ident = self.consume_identifier()?;
             self.consume_whitespace(false)?;
             fields.push(StructFieldDefinition{
                 position: field_position,
                 field: field_ident,
                 parser_type: field_parser_type,
             });
             // If we have a comma, then we may or may not have another field
             // definition. Otherwise we expect the struct to be fully defined
             // and expect a closing brace
             next = self.source.next();
             if let Some(b',') = next {
                 self.source.consume();
                 self.consume_whitespace(false)?;
                 next = self.source.next();
             } else {
                 break;
+            }
+        }
         // End of struct definition, so we expect a closing brace
         self.consume_string(b"}")?;
         // Valid struct definition
         Ok(h.alloc_struct_definition(|this| StructDefinition{
             this,
             position: struct_pos,
             identifier: struct_ident,
             poly_vars,
             fields,
         }))
+    }
     fn consume_enum_definition(&mut self, h: &mut Heap) -> Result<EnumId, ParseError2> {

src/protocol/mod.rs

➞

Show inline comments

@@ @@ -201,97 +201,109 @@ impl ComponentState { @@
                         let value;
                         match port {
                             Value::Output(OutputValue(port_value)) => {
                                 value = port_value;
+                            }
                             Value::Input(InputValue(port_value)) => {
                                 value = port_value;
+                            }
                             _ => unreachable!(),
+                        }
                         let payload;
                         match message {
                             Value::Message(MessageValue(None)) => {
                                 // Putting a null message is inconsistent
                                 return SyncBlocker::Inconsistent;
+                            }
                             Value::Message(MessageValue(Some(buffer))) => {
                                 // Create a copy of the payload
                                 payload = buffer;
+                            }
                             _ => unreachable!(),
+                        }
                         return SyncBlocker::PutMsg(value, payload);
+                    }
                 },
+            }
+        }
+    }
+}
 impl EvalContext<'_> {
     // fn random(&mut self) -> LongValue {
     //     match self {
     //         // EvalContext::None => unreachable!(),
     //         EvalContext::Nonsync(_context) => todo!(),
     //         EvalContext::Sync(_) => unreachable!(),
     //     }
     // }
     fn new_component(&mut self, args: &[Value], init_state: ComponentState) -> () {
         match self {
             // EvalContext::None => unreachable!(),
             EvalContext::Nonsync(context) => {
                 let mut moved_ports = HashSet::new();
                 for arg in args.iter() {
                     match arg {
                         Value::Output(OutputValue(port)) => {
                             moved_ports.insert(*port);
+                        }
                         Value::Input(InputValue(port)) => {
                             moved_ports.insert(*port);
+                        }
                         _ => {}
+                    }
+                }
                 context.new_component(moved_ports, init_state)
+            }
             EvalContext::Sync(_) => unreachable!(),
+        }
+    }
     fn new_channel(&mut self) -> [Value; 2] {
         match self {
             // EvalContext::None => unreachable!(),
             EvalContext::Nonsync(context) => {
                 let [from, to] = context.new_port_pair();
                 let from = Value::Output(OutputValue(from));
                 let to = Value::Input(InputValue(to));
                 return [from, to];
+            }
             EvalContext::Sync(_) => unreachable!(),
+        }
+    }
     fn fires(&mut self, port: Value) -> Option<Value> {
         match self {
             // EvalContext::None => unreachable!(),
             EvalContext::Nonsync(_) => unreachable!(),
             EvalContext::Sync(context) => match port {
                 Value::Output(OutputValue(port)) => context.is_firing(port).map(Value::from),
                 Value::Input(InputValue(port)) => context.is_firing(port).map(Value::from),
                 _ => unreachable!(),
             },
+        }
+    }
     fn get(&mut self, port: Value) -> Option<Value> {
         match self {
             // EvalContext::None => unreachable!(),
             EvalContext::Nonsync(_) => unreachable!(),
             EvalContext::Sync(context) => match port {
                 Value::Output(OutputValue(port)) => {
                     context.read_msg(port).map(Value::receive_message)
+                }
                 Value::Input(InputValue(port)) => {
                     context.read_msg(port).map(Value::receive_message)
+                }
                 _ => unreachable!(),
             },
+        }
+    }
     fn did_put(&mut self, port: Value) -> bool {
         match self {
             EvalContext::Nonsync(_) => unreachable!("did_put in nonsync context"),
             EvalContext::Sync(context) => match port {
                 Value::Output(OutputValue(port)) => {
                     context.is_firing(port).unwrap_or(false)
                 },
                 Value::Input(_) => unreachable!("did_put on input port"),
                 _ => unreachable!("did_put on non-port value")
+            }
+        }
+    }
+}

src/protocol/parser/depth_visitor.rs

➞

Show inline comments

@@ @@ -25,195 +25,192 @@ pub(crate) trait Visitor: Sized { @@
+    }
     fn visit_enum_definition(&mut self, _h: &mut Heap, _def: EnumId) -> VisitorResult {
         Ok(())
+    }
     fn visit_component_definition(&mut self, h: &mut Heap, def: ComponentId) -> VisitorResult {
         recursive_component_definition(self, h, def)
+    }
     fn visit_composite_definition(&mut self, h: &mut Heap, def: ComponentId) -> VisitorResult {
         recursive_composite_definition(self, h, def)
+    }
     fn visit_primitive_definition(&mut self, h: &mut Heap, def: ComponentId) -> VisitorResult {
         recursive_primitive_definition(self, h, def)
+    }
     fn visit_function_definition(&mut self, h: &mut Heap, def: FunctionId) -> VisitorResult {
         recursive_function_definition(self, h, def)
+    }
     fn visit_variable_declaration(&mut self, h: &mut Heap, decl: VariableId) -> VisitorResult {
         recursive_variable_declaration(self, h, decl)
+    }
     fn visit_parameter_declaration(&mut self, _h: &mut Heap, _decl: ParameterId) -> VisitorResult {
         Ok(())
+    }
     fn visit_local_declaration(&mut self, _h: &mut Heap, _decl: LocalId) -> VisitorResult {
         Ok(())
+    }
     fn visit_statement(&mut self, h: &mut Heap, stmt: StatementId) -> VisitorResult {
         recursive_statement(self, h, stmt)
+    }
     fn visit_local_statement(&mut self, h: &mut Heap, stmt: LocalStatementId) -> VisitorResult {
         recursive_local_statement(self, h, stmt)
+    }
     fn visit_memory_statement(&mut self, h: &mut Heap, stmt: MemoryStatementId) -> VisitorResult {
         recursive_memory_statement(self, h, stmt)
+    }
     fn visit_channel_statement(
         &mut self,
         _h: &mut Heap,
         _stmt: ChannelStatementId,
     ) -> VisitorResult {
         Ok(())
+    }
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         recursive_block_statement(self, h, stmt)
+    }
     fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {
         recursive_labeled_statement(self, h, stmt)
+    }
     fn visit_skip_statement(&mut self, _h: &mut Heap, _stmt: SkipStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_if_statement(&mut self, h: &mut Heap, stmt: IfStatementId) -> VisitorResult {
         recursive_if_statement(self, h, stmt)
+    }
     fn visit_end_if_statement(&mut self, _h: &mut Heap, _stmt: EndIfStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {
         recursive_while_statement(self, h, stmt)
+    }
     fn visit_end_while_statement(&mut self, _h: &mut Heap, _stmt: EndWhileStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_break_statement(&mut self, _h: &mut Heap, _stmt: BreakStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_continue_statement(
         &mut self,
         _h: &mut Heap,
         _stmt: ContinueStatementId,
     ) -> VisitorResult {
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         recursive_synchronous_statement(self, h, stmt)
+    }
     fn visit_end_synchronous_statement(&mut self, _h: &mut Heap, _stmt: EndSynchronousStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_return_statement(&mut self, h: &mut Heap, stmt: ReturnStatementId) -> VisitorResult {
         recursive_return_statement(self, h, stmt)
+    }
     fn visit_assert_statement(&mut self, h: &mut Heap, stmt: AssertStatementId) -> VisitorResult {
         recursive_assert_statement(self, h, stmt)
+    }
     fn visit_goto_statement(&mut self, _h: &mut Heap, _stmt: GotoStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_new_statement(&mut self, h: &mut Heap, stmt: NewStatementId) -> VisitorResult {
         recursive_new_statement(self, h, stmt)
+    }
     fn visit_put_statement(&mut self, h: &mut Heap, stmt: PutStatementId) -> VisitorResult {
         recursive_put_statement(self, h, stmt)
+    }
     fn visit_expression_statement(
         &mut self,
         h: &mut Heap,
         stmt: ExpressionStatementId,
     ) -> VisitorResult {
         recursive_expression_statement(self, h, stmt)
+    }
     fn visit_expression(&mut self, h: &mut Heap, expr: ExpressionId) -> VisitorResult {
         recursive_expression(self, h, expr)
+    }
     fn visit_assignment_expression(
         &mut self,
         h: &mut Heap,
         expr: AssignmentExpressionId,
     ) -> VisitorResult {
         recursive_assignment_expression(self, h, expr)
+    }
     fn visit_conditional_expression(
         &mut self,
         h: &mut Heap,
         expr: ConditionalExpressionId,
     ) -> VisitorResult {
         recursive_conditional_expression(self, h, expr)
+    }
     fn visit_binary_expression(&mut self, h: &mut Heap, expr: BinaryExpressionId) -> VisitorResult {
         recursive_binary_expression(self, h, expr)
+    }
     fn visit_unary_expression(&mut self, h: &mut Heap, expr: UnaryExpressionId) -> VisitorResult {
         recursive_unary_expression(self, h, expr)
+    }
     fn visit_indexing_expression(
         &mut self,
         h: &mut Heap,
         expr: IndexingExpressionId,
     ) -> VisitorResult {
         recursive_indexing_expression(self, h, expr)
+    }
     fn visit_slicing_expression(
         &mut self,
         h: &mut Heap,
         expr: SlicingExpressionId,
     ) -> VisitorResult {
         recursive_slicing_expression(self, h, expr)
+    }
     fn visit_select_expression(&mut self, h: &mut Heap, expr: SelectExpressionId) -> VisitorResult {
         recursive_select_expression(self, h, expr)
+    }
     fn visit_array_expression(&mut self, h: &mut Heap, expr: ArrayExpressionId) -> VisitorResult {
         recursive_array_expression(self, h, expr)
+    }
     fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {
         recursive_call_expression(self, h, expr)
+    }
     fn visit_constant_expression(
         &mut self,
         _h: &mut Heap,
         _expr: ConstantExpressionId,
     ) -> VisitorResult {
         Ok(())
+    }
     fn visit_variable_expression(
         &mut self,
         _h: &mut Heap,
         _expr: VariableExpressionId,
     ) -> VisitorResult {
         Ok(())
+    }
+}
 // Bubble-up helpers
 fn recursive_parameter_as_variable<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     param: ParameterId,
 ) -> VisitorResult {
     this.visit_variable_declaration(h, param.upcast())
+}
 fn recursive_local_as_variable<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     local: LocalId,
 ) -> VisitorResult {
     this.visit_variable_declaration(h, local.upcast())
+}
 fn recursive_call_expression_as_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     call: CallExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, call.upcast())
+}
 // Recursive procedures
@@ @@ -227,305 +224,295 @@ fn recursive_protocol_description<T: Visitor>( @@
+    }
     for &import in h[pd].imports.clone().iter() {
         this.visit_import(h, import)?;
+    }
     for &def in h[pd].definitions.clone().iter() {
         this.visit_symbol_definition(h, def)?;
+    }
     Ok(())
+}
 fn recursive_symbol_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: DefinitionId,
 ) -> VisitorResult {
     // We clone the definition in case it is modified
     // TODO: Fix me
     match h[def].clone() {
         Definition::Struct(def) => this.visit_struct_definition(h, def.this),
         Definition::Enum(def) => this.visit_enum_definition(h, def.this),
         Definition::Component(cdef) => this.visit_component_definition(h, cdef.this),
         Definition::Function(fdef) => this.visit_function_definition(h, fdef.this),
+    }
+}
 fn recursive_component_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: ComponentId,
 ) -> VisitorResult {
     let component_variant = h[def].variant;
     match component_variant {
         ComponentVariant::Primitive => this.visit_primitive_definition(h, def),
         ComponentVariant::Composite => this.visit_composite_definition(h, def),
+    }
+}
 fn recursive_composite_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: ComponentId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
         recursive_parameter_as_variable(this, h, param)?;
+    }
     this.visit_statement(h, h[def].body)
+}
 fn recursive_primitive_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: ComponentId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
         recursive_parameter_as_variable(this, h, param)?;
+    }
     this.visit_statement(h, h[def].body)
+}
 fn recursive_function_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: FunctionId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
         recursive_parameter_as_variable(this, h, param)?;
+    }
     this.visit_statement(h, h[def].body)
+}
 fn recursive_variable_declaration<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     decl: VariableId,
 ) -> VisitorResult {
     match h[decl].clone() {
         Variable::Parameter(decl) => this.visit_parameter_declaration(h, decl.this),
         Variable::Local(decl) => this.visit_local_declaration(h, decl.this),
+    }
+}
 fn recursive_statement<T: Visitor>(this: &mut T, h: &mut Heap, stmt: StatementId) -> VisitorResult {
     match h[stmt].clone() {
         Statement::Block(stmt) => this.visit_block_statement(h, stmt.this),
         Statement::Local(stmt) => this.visit_local_statement(h, stmt.this()),
         Statement::Skip(stmt) => this.visit_skip_statement(h, stmt.this),
         Statement::Labeled(stmt) => this.visit_labeled_statement(h, stmt.this),
         Statement::If(stmt) => this.visit_if_statement(h, stmt.this),
         Statement::While(stmt) => this.visit_while_statement(h, stmt.this),
         Statement::Break(stmt) => this.visit_break_statement(h, stmt.this),
         Statement::Continue(stmt) => this.visit_continue_statement(h, stmt.this),
         Statement::Synchronous(stmt) => this.visit_synchronous_statement(h, stmt.this),
         Statement::Return(stmt) => this.visit_return_statement(h, stmt.this),
         Statement::Assert(stmt) => this.visit_assert_statement(h, stmt.this),
         Statement::Goto(stmt) => this.visit_goto_statement(h, stmt.this),
         Statement::New(stmt) => this.visit_new_statement(h, stmt.this),
         Statement::Put(stmt) => this.visit_put_statement(h, stmt.this),
         Statement::Expression(stmt) => this.visit_expression_statement(h, stmt.this),
         Statement::EndSynchronous(stmt) => this.visit_end_synchronous_statement(h, stmt.this),
         Statement::EndWhile(stmt) => this.visit_end_while_statement(h, stmt.this),
         Statement::EndIf(stmt) => this.visit_end_if_statement(h, stmt.this),
+    }
+}
 fn recursive_block_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     block: BlockStatementId,
 ) -> VisitorResult {
     for &local in h[block].locals.clone().iter() {
         recursive_local_as_variable(this, h, local)?;
+    }
     for &stmt in h[block].statements.clone().iter() {
         this.visit_statement(h, stmt)?;
+    }
     Ok(())
+}
 fn recursive_local_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: LocalStatementId,
 ) -> VisitorResult {
     match h[stmt].clone() {
         LocalStatement::Channel(stmt) => this.visit_channel_statement(h, stmt.this),
         LocalStatement::Memory(stmt) => this.visit_memory_statement(h, stmt.this),
+    }
+}
 fn recursive_memory_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: MemoryStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].initial)
+}
 fn recursive_labeled_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: LabeledStatementId,
 ) -> VisitorResult {
     this.visit_statement(h, h[stmt].body)
+}
 fn recursive_if_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: IfStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].test)?;
     this.visit_statement(h, h[stmt].true_body)?;
     this.visit_statement(h, h[stmt].false_body)
+}
 fn recursive_while_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: WhileStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].test)?;
     this.visit_statement(h, h[stmt].body)
+}
 fn recursive_synchronous_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: SynchronousStatementId,
 ) -> VisitorResult {
     // TODO: Check where this was used for
     // for &param in h[stmt].parameters.clone().iter() {
     //     recursive_parameter_as_variable(this, h, param)?;
     // }
     this.visit_statement(h, h[stmt].body)
+}
 fn recursive_return_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: ReturnStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].expression)
+}
 fn recursive_assert_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: AssertStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].expression)
+}
 fn recursive_new_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: NewStatementId,
 ) -> VisitorResult {
     recursive_call_expression_as_expression(this, h, h[stmt].expression)
+}
 fn recursive_put_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: PutStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].port)?;
     this.visit_expression(h, h[stmt].message)
+}
 fn recursive_expression_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: ExpressionStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].expression)
+}
 fn recursive_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: ExpressionId,
 ) -> VisitorResult {
     match h[expr].clone() {
         Expression::Assignment(expr) => this.visit_assignment_expression(h, expr.this),
         Expression::Conditional(expr) => this.visit_conditional_expression(h, expr.this),
         Expression::Binary(expr) => this.visit_binary_expression(h, expr.this),
         Expression::Unary(expr) => this.visit_unary_expression(h, expr.this),
         Expression::Indexing(expr) => this.visit_indexing_expression(h, expr.this),
         Expression::Slicing(expr) => this.visit_slicing_expression(h, expr.this),
         Expression::Select(expr) => this.visit_select_expression(h, expr.this),
         Expression::Array(expr) => this.visit_array_expression(h, expr.this),
         Expression::Constant(expr) => this.visit_constant_expression(h, expr.this),
         Expression::Call(expr) => this.visit_call_expression(h, expr.this),
         Expression::Variable(expr) => this.visit_variable_expression(h, expr.this),
+    }
+}
 fn recursive_assignment_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: AssignmentExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].left)?;
     this.visit_expression(h, h[expr].right)
+}
 fn recursive_conditional_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: ConditionalExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].test)?;
     this.visit_expression(h, h[expr].true_expression)?;
     this.visit_expression(h, h[expr].false_expression)
+}
 fn recursive_binary_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: BinaryExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].left)?;
     this.visit_expression(h, h[expr].right)
+}
 fn recursive_unary_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: UnaryExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].expression)
+}
 fn recursive_indexing_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: IndexingExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].subject)?;
     this.visit_expression(h, h[expr].index)
+}
 fn recursive_slicing_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: SlicingExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].subject)?;
     this.visit_expression(h, h[expr].from_index)?;
     this.visit_expression(h, h[expr].to_index)
+}
 fn recursive_select_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: SelectExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].subject)
+}
 fn recursive_array_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: ArrayExpressionId,
 ) -> VisitorResult {
@@ @@ -876,196 +863,192 @@ impl Visitor for LinkStatements { @@
         assert!(self.prev.is_none());
         self.visit_statement(h, h[stmt].true_body)?;
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(end_if_id.upcast());
+        }
         assert!(self.prev.is_none());
         self.visit_statement(h, h[stmt].false_body)?;
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(end_if_id.upcast());
+        }
         // Use the pseudo-statement as the statement where to update the next pointer
         // self.prev = Some(UniqueStatementId(end_if_id.upcast()));
         Ok(())
+    }
     fn visit_end_if_statement(&mut self, _h: &mut Heap, stmt: EndIfStatementId) -> VisitorResult {
         assert!(self.prev.is_none());
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {
         // We allocate a pseudo-statement, to which the break statement finds its target
         // Update the while's next statement to point to the pseudo-statement
         let end_while_id = h[stmt].end_while;
         assert!(end_while_id.is_some());
         // let end_while_id = end_while_id.unwrap();
         assert!(self.prev.is_none());
         self.visit_statement(h, h[stmt].body)?;
         // The body's next statement loops back to the while statement itself
         // Note: continue statements also loop back to the while statement itself
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(stmt.upcast());
+        }
         // Use the while statement as the statement where the next pointer is updated
         // self.prev = Some(UniqueStatementId(end_while_id.upcast()));
         Ok(())
+    }
     fn visit_end_while_statement(&mut self, _h: &mut Heap, stmt: EndWhileStatementId) -> VisitorResult {
         assert!(self.prev.is_none());
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_break_statement(&mut self, _h: &mut Heap, _stmt: BreakStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_continue_statement(
         &mut self,
         _h: &mut Heap,
         _stmt: ContinueStatementId,
     ) -> VisitorResult {
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         // Allocate a pseudo-statement, that is added for helping the evaluator to issue a command
         // that marks the end of the synchronous block. Every evaluation has to pause at this
         // point, only to resume later when the thread is selected as unique thread to continue.
         let end_sync_id = h[stmt].end_sync;
         assert!(end_sync_id.is_some());
         let end_sync_id = end_sync_id.unwrap();
         assert!(self.prev.is_none());
         self.visit_statement(h, h[stmt].body)?;
         // The body's next statement points to the pseudo element
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(end_sync_id.upcast());
+        }
         // Use the pseudo-statement as the statement where the next pointer is updated
         // self.prev = Some(UniqueStatementId(end_sync_id.upcast()));
         Ok(())
+    }
     fn visit_end_synchronous_statement(&mut self, _h: &mut Heap, stmt: EndSynchronousStatementId) -> VisitorResult {
         assert!(self.prev.is_none());
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_return_statement(&mut self, _h: &mut Heap, _stmt: ReturnStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_assert_statement(&mut self, _h: &mut Heap, stmt: AssertStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_goto_statement(&mut self, _h: &mut Heap, _stmt: GotoStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_new_statement(&mut self, _h: &mut Heap, stmt: NewStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_put_statement(&mut self, _h: &mut Heap, stmt: PutStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_expression_statement(
         &mut self,
         _h: &mut Heap,
         stmt: ExpressionStatementId,
     ) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_expression(&mut self, _h: &mut Heap, _expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 pub(crate) struct BuildLabels {
     block: Option<BlockStatementId>,
     sync_enclosure: Option<SynchronousStatementId>,
+}
 impl BuildLabels {
     pub(crate) fn new() -> Self {
         BuildLabels { block: None, sync_enclosure: None }
+    }
+}
 impl Visitor for BuildLabels {
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         assert_eq!(self.block, h[stmt].parent_block(h));
         let old = self.block;
         self.block = Some(stmt);
         recursive_block_statement(self, h, stmt)?;
         self.block = old;
         Ok(())
+    }
     fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {
         assert!(!self.block.is_none());
         // Store label in current block (on the fly)
         h[self.block.unwrap()].labels.push(stmt);
         // Update synchronous scope of label
         h[stmt].in_sync = self.sync_enclosure;
         recursive_labeled_statement(self, h, stmt)
+    }
     fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {
         h[stmt].in_sync = self.sync_enclosure;
         recursive_while_statement(self, h, stmt)
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         assert!(self.sync_enclosure.is_none());
         self.sync_enclosure = Some(stmt);
         recursive_synchronous_statement(self, h, stmt)?;
         self.sync_enclosure = None;
         Ok(())
+    }
     fn visit_expression(&mut self, _h: &mut Heap, _expr: ExpressionId) -> VisitorResult {
         Ok(())
+    }
+}
 pub(crate) struct ResolveLabels {
     block: Option<BlockStatementId>,
     while_enclosure: Option<WhileStatementId>,
     sync_enclosure: Option<SynchronousStatementId>,
+}
 impl ResolveLabels {
     pub(crate) fn new() -> Self {
         ResolveLabels { block: None, while_enclosure: None, sync_enclosure: None }
+    }
     fn check_duplicate_impl(
         h: &Heap,
         block: Option<BlockStatementId>,
         stmt: LabeledStatementId,
     ) -> VisitorResult {
         if let Some(block) = block {
             // Checking the parent first is important. Otherwise, labels
             // overshadow previously defined labels: and this is illegal!
             ResolveLabels::check_duplicate_impl(h, h[block].parent_block(h), stmt)?;
             // For the current block, check for a duplicate.
             for &other_stmt in h[block].labels.iter() {
                 if other_stmt == stmt {
                     continue;
                 } else {
                     if h[other_stmt].label.value == h[stmt].label.value {
                         return Err((h[stmt].position, "Duplicate label".to_string()));
+                    }
+                }
+            }
+        }
         Ok(())
+    }
     fn check_duplicate(&self, h: &Heap, stmt: LabeledStatementId) -> VisitorResult {
         ResolveLabels::check_duplicate_impl(h, self.block, stmt)
+    }

src/protocol/parser/type_resolver.rs

➞

Show inline comments

 /// type_resolver.rs
 ///
 /// Performs type inference and type checking
 ///
 /// TODO: Needs an optimization pass
 /// TODO: Needs a cleanup pass
 use std::collections::{HashMap, HashSet, VecDeque};
 use crate::protocol::ast::*;
 use crate::protocol::inputsource::*;
 use super::type_table::*;
 use super::symbol_table::*;
 use super::visitor::{
     STMT_BUFFER_INIT_CAPACITY,
     EXPR_BUFFER_INIT_CAPACITY,
     Ctx,
     Visitor2,
     VisitorResult
 };
 use std::collections::hash_map::Entry;
 use crate::protocol::parser::type_resolver::InferenceTypePart::IntegerLike;
 const MESSAGE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Message ];
 const BOOL_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Bool ];
 const NUMBERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::NumberLike ];
 const INTEGERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::IntegerLike ];
 const ARRAY_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Array, InferenceTypePart::Unknown ];
 const ARRAYLIKE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::ArrayLike, InferenceTypePart::Unknown ];
 const PORTLIKE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::PortLike, InferenceTypePart::Unknown ];
 /// TODO: @performance Turn into PartialOrd+Ord to simplify checks
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub(crate) enum InferenceTypePart {
     // A marker with an identifier which we can use to seek subsections of the
     // inferred type
     Marker(usize),
     // Completely unknown type, needs to be inferred
     Unknown,
     // Partially known type, may be inferred to to be the appropriate related
     // type.
     // IndexLike,      // index into array/slice
     NumberLike,     // any kind of integer/float
     IntegerLike,    // any kind of integer
     ArrayLike,      // array or slice. Note that this must have a subtype
     PortLike,       // input or output port
     // Special types that cannot be instantiated by the user
     Void, // For builtin functions that do not return anything
     // Concrete types without subtypes
     Message,
     Bool,
     Byte,
     Short,
     Int,
     Long,
     String,
     // One subtype
     Array,
     Slice,
     Input,
     Output,
     // A user-defined type with any number of subtypes
     Instance(DefinitionId, usize)
+}
 impl InferenceTypePart {
     fn is_marker(&self) -> bool {
         if let InferenceTypePart::Marker(_) = self { true } else { false }
+    }
     /// Checks if the type is concrete, markers are interpreted as concrete
     /// types.
     fn is_concrete(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::Unknown | ITP::NumberLike | ITP::IntegerLike |
             ITP::ArrayLike | ITP::PortLike => false,
             _ => true
+        }
+    }
     fn is_concrete_number(&self) -> bool {
         // TODO: @float
         use InferenceTypePart as ITP;
         match self {
             ITP::Byte | ITP::Short | ITP::Int | ITP::Long => true,
             _ => false,
+        }
+    }
     fn is_concrete_integer(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::Byte | ITP::Short | ITP::Int | ITP::Long => true,
             _ => false,
+        }
+    }
     fn is_concrete_array_or_slice(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::Array | ITP::Slice => true,
             _ => false,
+        }
+    }
     fn is_concrete_port(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::Input | ITP::Output => true,
             _ => false,
+        }
+    }
     /// Checks if a part is less specific than the argument. Only checks for
     /// single-part inference (i.e. not the replacement of an `Unknown` variant
     /// with the argument)
     fn may_be_inferred_from(&self, arg: &InferenceTypePart) -> bool {
         use InferenceTypePart as ITP;
         (*self == ITP::IntegerLike && arg.is_concrete_integer()) ||
         (*self == ITP::NumberLike && (arg.is_concrete_number() || *arg == ITP::IntegerLike)) ||
         (*self == ITP::ArrayLike && arg.is_concrete_array_or_slice()) ||
         (*self == ITP::PortLike && arg.is_concrete_port())
+    }
     /// Returns the change in "iteration depth" when traversing this particular
     /// part. The iteration depth is used to traverse the tree in a linear
     /// fashion. It is basically `number_of_subtypes - 1`
     fn depth_change(&self) -> i32 {
         use InferenceTypePart as ITP;
         match &self {
             ITP::Unknown | ITP::NumberLike | ITP::IntegerLike |
             ITP::Void | ITP::Message | ITP::Bool |
             ITP::Byte | ITP::Short | ITP::Int | ITP::Long |
             ITP::String => {
                 -1
             },
             ITP::Marker(_) | ITP::ArrayLike | ITP::Array | ITP::Slice |
             ITP::PortLike | ITP::Input | ITP::Output => {
                 // One subtype, so do not modify depth
             },
             ITP::Instance(_, num_args) => {
                 (*num_args as i32) - 1
+            }
+        }
+    }
+}
 impl From<ConcreteTypeVariant> for InferenceTypePart {
     fn from(v: ConcreteTypeVariant) -> InferenceTypePart {
         use ConcreteTypeVariant as CTV;
         use InferenceTypePart as ITP;
         match v {
             CTV::Message => ITP::Message,
             CTV::Bool => ITP::Bool,
             CTV::Byte => ITP::Byte,
             CTV::Short => ITP::Short,
             CTV::Int => ITP::Int,
             CTV::Long => ITP::Long,
             CTV::String => ITP::String,
             CTV::Array => ITP::Array,
             CTV::Slice => ITP::Slice,
             CTV::Input => ITP::Input,
             CTV::Output => ITP::Output,
             CTV::Instance(id, num) => ITP::Instance(id, num),
+        }
+    }
+}
 struct InferenceType {
     has_marker: bool,
     is_done: bool,
     parts: Vec<InferenceTypePart>,
+}
 impl InferenceType {
     fn new(has_marker: bool, is_done: bool, parts: Vec<InferenceTypePart>) -> Self {
         if cfg!(debug_assertions) {
             debug_assert!(!parts.is_empty());
             if !has_marker {
                 debug_assert!(parts.iter().all(|v| !v.is_marker()));
+            }
             if is_done {
                 debug_assert!(parts.iter().all(|v| v.is_concrete()));
+            }
+        }
         Self{ has_marker, is_done, parts }
+    }
     fn replace_subtree(&mut self, start_idx: usize, with: &[InferenceTypePart]) {
          let end_idx = Self::find_subtree_end_idx(&self.parts, start_idx);
         debug_assert_eq!(with.len(), Self::find_subtree_end_idx(with, 0));
         self.parts.splice(start_idx..end_idx, with.iter().cloned());
         self.recompute_is_done();
+    }
     // TODO: @performance, might all be done inline in the type inference methods
     fn recompute_is_done(&mut self) {
         self.is_done = self.parts.iter().all(|v| v.is_concrete());
+    }
     /// Checks if type is, or may be inferred as, a number
     // TODO: @float
     fn might_be_number(&self) -> bool {
         use InferenceTypePart as ITP;
         // TODO: @marker?
         if self.parts.len() != 1 { return false; }
         match self.parts[0] {
             ITP::Unknown | ITP::NumberLike | ITP::IntegerLike |
             ITP::Byte | ITP::Short | ITP::Int | ITP::Long =>
                 true,
             _ =>
                 false,
+        }
+    }
     /// Checks if type is, or may be inferred as, an integer
     fn might_be_integer(&self) -> bool {
         use InferenceTypePart as ITP;
         // TODO: @marker?
         if self.parts.len() != 1 { return false; }
         match self.parts[0] {
             ITP::Unknown | ITP::IntegerLike |
             ITP::Byte | ITP::Short | ITP::Int | ITP::Long =>
                 true,
             _ =>
                 false,
+        }
+    }
     /// Checks if type is, or may be inferred as, a boolean
     fn might_be_boolean(&self) -> bool {
         use InferenceTypePart as ITP;
         // TODO: @marker?
         if self.parts.len() != 1 { return false; }
         match self.parts[0] {
             ITP::Unknown | ITP::Bool => true,
             _ => false
+        }
+    }
     /// Returns an iterator over all markers and the partial type tree that
     /// follows those markers.
     fn marker_iter(&self) -> InferenceTypeMarkerIter {
         InferenceTypeMarkerIter::new(&self.parts)
+    }
     /// Attempts to find a marker with a specific value appearing at or after
     /// the specified index. If found then the partial type tree's bounding
     /// indices that follow that marker are returned.
     fn find_subtree_idx_for_marker(&self, marker: usize, mut idx: usize) -> Option<(usize, usize)> {
         // Seek ahead to find a marker
         let marker = InferenceTypePart::Marker(marker);
         while idx < self.parts.len() {
             if marker == self.parts[idx] {
                 // Found the marker
                 let start_idx = idx + 1;
                 let end_idx = Self::find_subtree_end_idx(&self.parts, start_idx);
                 return Some((start_idx, end_idx))
+            }
             idx += 1;
+        }
         None
+    }
     /// Given that the `parts` are a depth-first serialized tree of types, this
     /// function finds the subtree anchored at a specific node. The returned
     /// index is exclusive.
     fn find_subtree_end_idx(parts: &[InferenceTypePart], start_idx: usize) -> usize {
         let mut depth = 1;
         let mut idx = start_idx;
         while idx < parts.len() {
             depth += parts[idx].depth_change();
             if depth == 0 {
                 return idx + 1;
+            }
             idx += 1;
+        }
         // If here, then the inference type is malformed
         unreachable!();
+    }
     /// Call that attempts to infer the part at `to_infer.parts[to_infer_idx]`
     /// using the subtree at `template.parts[template_idx]`. Will return
     /// `Some(depth_change_due_to_traversal)` if type inference has been
     /// applied. In this case the indices will also be modified to point to the
     /// next part in both templates. If type inference has not (or: could not)
     /// be applied then `None` will be returned. Note that this might mean that
     /// the types are incompatible.
     ///
     /// As this is a helper functions, some assumptions: the parts are not
     /// exactly equal, and neither of them contains a marker. Also: only the
     /// `to_infer` parts are checked for inference. It might be that this
     /// function returns `None`, but that that `template` is still compatible
     /// with `to_infer`, e.g. when `template` has an `Unknown` part.
     fn infer_part_for_single_type(
         to_infer: &mut InferenceType, to_infer_idx: &mut usize,
         template_parts: &[InferenceTypePart], template_idx: &mut usize,
     ) -> Option<i32> {
         use InferenceTypePart as ITP;
         let to_infer_part = &to_infer.parts[*to_infer_idx];
         let template_part = &template_parts[*template_idx];
         // Check for programmer mistakes
         debug_assert_ne!(to_infer_part, template_part);
         debug_assert!(!to_infer_part.is_marker(), "marker encountered in 'infer part'");
         debug_assert!(!template_part.is_marker(), "marker encountered in 'template part'");
         // Inference of a somewhat-specified type
         if to_infer_part.may_be_inferred_from(template_part) {
             let depth_change = to_infer_part.depth_change();
             debug_assert_eq!(depth_change, template_part.depth_change());
             to_infer.parts[*to_infer_idx] = template_part.clone();
             *to_infer_idx += 1;
             *template_idx += 1;
             return Some(depth_change);
+        }
         // Inference of a completely unknown type
         if *to_infer_part == ITP::Unknown {
             // template part is different, so cannot be unknown, hence copy the
             // entire subtree
             let template_end_idx = Self::find_subtree_end_idx(template_parts, *template_idx);
             to_infer.parts[*to_infer_idx] = template_part.clone();
             *to_infer_idx += 1;
             for insert_idx in (*template_idx + 1)..template_end_idx {
                 to_infer.parts.insert(*to_infer_idx, template_parts[insert_idx].clone());
                 *to_infer_idx += 1;
+            }
             *template_idx = template_end_idx;
             // Note: by definition the LHS was Unknown and the RHS traversed a
             // full subtree.
             return Some(-1);
+        }
         None
+    }
     /// Call that checks if the `to_check` part is compatible with the `infer`
     /// part. This essentially implements `infer_part_for_single_type` but skips
@@ @@ -607,462 +628,530 @@ struct InferenceTypeMarkerIter<'a> { @@
+}
 impl<'a> InferenceTypeMarkerIter<'a> {
     fn new(parts: &'a [InferenceTypePart]) -> Self {
         Self{ parts, idx: 0 }
+    }
+}
 impl<'a> Iterator for InferenceTypeMarkerIter<'a> {
     type Item = (usize, &'a [InferenceTypePart]);
     fn next(&mut self) -> Option<Self::Item> {
         // Iterate until we find a marker
         while self.idx < self.parts.len() {
             if let InferenceTypePart::Marker(marker) = self.parts[self.idx] {
                 // Found a marker, find the subtree end
                 let start_idx = self.idx + 1;
                 let end_idx = InferenceType::find_subtree_end_idx(self.parts, start_idx);
                 // Modify internal index, then return items
                 self.idx = end_idx;
                 return Some((marker, &self.parts[start_idx..end_idx]))
+            }
             self.idx += 1;
+        }
         None
+    }
+}
 #[derive(PartialEq, Eq)]
 enum DualInferenceResult {
     Neither,        // neither argument is clarified
     First,          // first argument is clarified using the second one
     Second,         // second argument is clarified using the first one
     Both,           // both arguments are clarified
     Incompatible,   // types are incompatible: programmer error
+}
 impl DualInferenceResult {
     fn modified_any(&self) -> bool {
         match self {
             DualInferenceResult::First | DualInferenceResult::Second | DualInferenceResult::Both => true,
             _ => false
+        }
+    }
     fn modified_lhs(&self) -> bool {
         match self {
             DualInferenceResult::First | DualInferenceResult::Both => true,
             _ => false
+        }
+    }
     fn modified_rhs(&self) -> bool {
         match self {
             DualInferenceResult::Second | DualInferenceResult::Both => true,
             _ => false
+        }
+    }
+}
 #[derive(PartialEq, Eq)]
 enum SingleInferenceResult {
     Unmodified,
     Modified,
     Incompatible
+}
 enum DefinitionType{
     None,
     Component(ComponentId),
     Function(FunctionId),
+}
 /// This particular visitor will recurse depth-first into the AST and ensures
 /// that all expressions have the appropriate types. At the moment this implies:
 ///
 ///     - Type checking arguments to unary and binary operators.
 ///     - Type checking assignment, indexing, slicing and select expressions.
 ///     - Checking arguments to functions and component instantiations.
 ///
 /// This will be achieved by slowly descending into the AST. At any given
 /// expression we may depend on
 pub(crate) struct TypeResolvingVisitor {
     definition_type: DefinitionType,
     // Buffers for iteration over substatements and subexpressions
     stmt_buffer: Vec<StatementId>,
     expr_buffer: Vec<ExpressionId>,
     // If instantiating a monomorph of a polymorphic proctype, then we store the
     // values of the polymorphic values here. There should be as many, and in
     // the same order as, in the definition's polyargs.
     polyvars: Vec<ConcreteType>,
     // Mapping from parser type to inferred type. We attempt to continue to
     // specify these types until we're stuck or we've fully determined the type.
     infer_types: HashMap<VariableId, InferenceType>,
     expr_types: HashMap<ExpressionId, InferenceType>,
     extra_data: HashMap<ExpressionId, ExtraData>,
     var_types: HashMap<VariableId, VarData>,      // types of variables
     expr_types: HashMap<ExpressionId, InferenceType>,   // types of expressions
     extra_data: HashMap<ExpressionId, ExtraData>,       // data for function call inference
     // Keeping track of which expressions need to be reinferred because the
     // expressions they're linked to made progression on an associated type
     expr_queued: HashSet<ExpressionId>,
+}
 // TODO: @rename used for calls and struct literals, maybe union literals?
 struct ExtraData {
     /// Progression of polymorphic variables (if any)
     poly_vars: Vec<InferenceType>,
     /// Progression of types of call arguments or struct members
     embedded: Vec<InferenceType>,
     returned: InferenceType,
+}
 struct VarData {
     var_type: InferenceType,
     used_at: Vec<ExpressionId>,
+}
 impl TypeResolvingVisitor {
     pub(crate) fn new() -> Self {
         TypeResolvingVisitor{
             definition_type: DefinitionType::None,
             stmt_buffer: Vec::with_capacity(STMT_BUFFER_INIT_CAPACITY),
             expr_buffer: Vec::with_capacity(EXPR_BUFFER_INIT_CAPACITY),
             polyvars: Vec::new(),
-            infer_types: HashMap::new(),
+            var_types: HashMap::new(),
             expr_types: HashMap::new(),
             extra_data: HashMap::new(),
             expr_queued: HashSet::new(),
+        }
+    }
     fn reset(&mut self) {
         self.definition_type = DefinitionType::None;
         self.stmt_buffer.clear();
         self.expr_buffer.clear();
         self.polyvars.clear();
-        self.infer_types.clear();
+        self.var_types.clear();
         self.expr_types.clear();
+    }
+}
 impl Visitor2 for TypeResolvingVisitor {
     // Definitions
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentId) -> VisitorResult {
         self.reset();
         self.definition_type = DefinitionType::Component(id);
         let comp_def = &ctx.heap[id];
         debug_assert_eq!(comp_def.poly_vars.len(), self.polyvars.len(), "component polyvars do not match imposed polyvars");
         for param_id in comp_def.parameters.clone() {
             let param = &ctx.heap[param_id];
             let infer_type = self.determine_inference_type_from_parser_type(ctx, param.parser_type, true);
             debug_assert!(infer_type.is_done, "expected component arguments to be concrete types");
             self.infer_types.insert(param_id.upcast(), infer_type);
             let var_type = self.determine_inference_type_from_parser_type(ctx, param.parser_type, true);
             debug_assert!(var_type.is_done, "expected component arguments to be concrete types");
             self.var_types.insert(param_id.upcast(), VarData{ var_type, used_at: Vec::new() });
+        }
         let body_stmt_id = ctx.heap[id].body;
         self.visit_stmt(ctx, body_stmt_id)
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionId) -> VisitorResult {
         self.reset();
         self.definition_type = DefinitionType::Function(id);
         let func_def = &ctx.heap[id];
         debug_assert_eq!(func_def.poly_vars.len(), self.polyvars.len(), "function polyvars do not match imposed polyvars");
         for param_id in func_def.parameters.clone() {
             let param = &ctx.heap[param_id];
             let infer_type = self.determine_inference_type_from_parser_type(ctx, param.parser_type, true);
             debug_assert!(infer_type.is_done, "expected function arguments to be concrete types");
             self.infer_types.insert(param_id.upcast(), infer_type);
             let var_type = self.determine_inference_type_from_parser_type(ctx, param.parser_type, true);
             debug_assert!(var_type.is_done, "expected function arguments to be concrete types");
             self.var_types.insert(param_id.upcast(), VarData{ var_type, used_at: Vec::new() });
+        }
         let body_stmt_id = ctx.heap[id].body;
         self.visit_stmt(ctx, body_stmt_id)
+    }
     // Statements
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         // Transfer statements for traversal
         let block = &ctx.heap[id];
         for stmt_id in block.statements.clone() {
             self.visit_stmt(ctx, stmt_id);
+        }
         Ok(())
+    }
     fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {
         let memory_stmt = &ctx.heap[id];
         let local = &ctx.heap[memory_stmt.variable];
         let infer_type = self.determine_inference_type_from_parser_type(ctx, local.parser_type, true);
         self.infer_types.insert(memory_stmt.variable.upcast(), infer_type);
         let var_type = self.determine_inference_type_from_parser_type(ctx, local.parser_type, true);
         self.var_types.insert(memory_stmt.variable.upcast(), VarData{ var_type, used_at: Vec::new() });
         let expr_id = memory_stmt.initial;
         self.visit_expr(ctx, expr_id)?;
         Ok(())
+    }
     fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {
         let channel_stmt = &ctx.heap[id];
         let from_local = &ctx.heap[channel_stmt.from];
         let from_infer_type = self.determine_inference_type_from_parser_type(ctx, from_local.parser_type, true);
         self.infer_types.insert(from_local.this.upcast(), from_infer_type);
         let from_var_type = self.determine_inference_type_from_parser_type(ctx, from_local.parser_type, true);
         self.var_types.insert(from_local.this.upcast(), VarData{ var_type: from_var_type, used_at: Vec::new() });
         let to_local = &ctx.heap[channel_stmt.to];
         let to_infer_type = self.determine_inference_type_from_parser_type(ctx, to_local.parser_type, true);
         self.infer_types.insert(to_local.this.upcast(), to_infer_type);
         let to_var_type = self.determine_inference_type_from_parser_type(ctx, to_local.parser_type, true);
         self.var_types.insert(to_local.this.upcast(), VarData{ var_type: to_var_type, used_at: Vec::new() });
         Ok(())
+    }
     fn visit_labeled_stmt(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> VisitorResult {
         let labeled_stmt = &ctx.heap[id];
         let substmt_id = labeled_stmt.body;
         self.visit_stmt(ctx, substmt_id)
+    }
     fn visit_if_stmt(&mut self, ctx: &mut Ctx, id: IfStatementId) -> VisitorResult {
         let if_stmt = &ctx.heap[id];
         let true_body_id = if_stmt.true_body;
         let false_body_id = if_stmt.false_body;
         let test_expr_id = if_stmt.test;
         self.visit_expr(ctx, test_expr_id)?;
         self.visit_stmt(ctx, true_body_id)?;
         self.visit_stmt(ctx, false_body_id)?;
         Ok(())
+    }
     fn visit_while_stmt(&mut self, ctx: &mut Ctx, id: WhileStatementId) -> VisitorResult {
         let while_stmt = &ctx.heap[id];
         let body_id = while_stmt.body;
         let test_expr_id = while_stmt.test;
         self.visit_expr(ctx, test_expr_id)?;
         self.visit_stmt(ctx, body_id)?;
         Ok(())
+    }
     fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {
         let sync_stmt = &ctx.heap[id];
         let body_id = sync_stmt.body;
         self.visit_stmt(ctx, body_id)
+    }
     fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {
         let return_stmt = &ctx.heap[id];
         let expr_id = return_stmt.expression;
         self.visit_expr(ctx, expr_id)
+    }
     fn visit_assert_stmt(&mut self, ctx: &mut Ctx, id: AssertStatementId) -> VisitorResult {
         let assert_stmt = &ctx.heap[id];
         let test_expr_id = assert_stmt.expression;
         self.visit_expr(ctx, test_expr_id)
+    }
     fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {
         let new_stmt = &ctx.heap[id];
         let call_expr_id = new_stmt.expression;
         self.visit_call_expr(ctx, call_expr_id)
+    }
     fn visit_put_stmt(&mut self, ctx: &mut Ctx, id: PutStatementId) -> VisitorResult {
         let put_stmt = &ctx.heap[id];
         let port_expr_id = put_stmt.port;
         let msg_expr_id = put_stmt.message;
         // TODO: What what?
         self.visit_expr(ctx, port_expr_id)?;
         self.visit_expr(ctx, msg_expr_id)?;
         Ok(())
+    }
     fn visit_expr_stmt(&mut self, ctx: &mut Ctx, id: ExpressionStatementId) -> VisitorResult {
         let expr_stmt = &ctx.heap[id];
         let subexpr_id = expr_stmt.expression;
         self.visit_expr(ctx, subexpr_id)
+    }
     // Expressions
     fn visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let assign_expr = &ctx.heap[id];
         let left_expr_id = assign_expr.left;
         let right_expr_id = assign_expr.right;
         self.visit_expr(ctx, left_expr_id)?;
         self.visit_expr(ctx, right_expr_id)?;
         self.progress_assignment_expr(ctx, id)
+    }
     fn visit_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let conditional_expr = &ctx.heap[id];
         let test_expr_id = conditional_expr.test;
         let true_expr_id = conditional_expr.true_expression;
         let false_expr_id = conditional_expr.false_expression;
         self.expr_types.insert(test_expr_id, InferenceType::new(false, true, vec![InferenceTypePart::Bool]));
         self.visit_expr(ctx, test_expr_id)?;
         self.visit_expr(ctx, true_expr_id)?;
         self.visit_expr(ctx, false_expr_id)?;
         self.progress_conditional_expr(ctx, id)
+    }
     fn visit_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let binary_expr = &ctx.heap[id];
         let lhs_expr_id = binary_expr.left;
         let rhs_expr_id = binary_expr.right;
         self.visit_expr(ctx, lhs_expr_id)?;
         self.visit_expr(ctx, rhs_expr_id)?;
         self.progress_binary_expr(ctx, id)
+    }
     fn visit_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let unary_expr = &ctx.heap[id];
         let arg_expr_id = unary_expr.expression;
         self.visit_expr(ctx, arg_expr_id);
+        self.visit_expr(ctx, arg_expr_id)?;
         self.progress_unary_expr(ctx, id)
+    }
     fn visit_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let indexing_expr = &ctx.heap[id];
         let subject_expr_id = indexing_expr.subject;
         let index_expr_id = indexing_expr.index;
         self.visit_expr(ctx, subject_expr_id)?;
         self.visit_expr(ctx, index_expr_id)?;
         self.progress_indexing_expr(ctx, id)
+    }
     fn visit_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let slicing_expr = &ctx.heap[id];
         let subject_expr_id = slicing_expr.subject;
         let from_expr_id = slicing_expr.from_index;
         let to_expr_id = slicing_expr.to_index;
         self.visit_expr(ctx, subject_expr_id)?;
         self.visit_expr(ctx, from_expr_id)?;
         self.visit_expr(ctx, to_expr_id)?;
         self.progress_slicing_expr(ctx, id)
+    }
     fn visit_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let select_expr = &ctx.heap[id];
         let subject_expr_id = select_expr.subject;
         self.visit_expr(ctx, subject_expr_id)?;
         self.progress_select_expr(ctx, id)
+    }
     fn visit_array_expr(&mut self, ctx: &mut Ctx, id: ArrayExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let array_expr = &ctx.heap[id];
         // TODO: @performance
         for element_id in array_expr.elements.clone().into_iter() {
             self.visit_expr(ctx, element_id)?;
+        }
         self.progress_array_expr(ctx, id)
+    }
     fn visit_constant_expr(&mut self, ctx: &mut Ctx, id: ConstantExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         self.progress_constant_expr(ctx, id)
+    }
     fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         self.insert_initial_call_polymorph_data(ctx, id);
         // TODO: @performance
         let call_expr = &ctx.heap[id];
         for arg_expr_id in call_expr.arguments.clone() {
             self.visit_expr(ctx, arg_expr_id)?;
+        }
         self.progress_call_expr(ctx, id)
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let var_expr = &ctx.heap[id];
         debug_assert!(var_expr.declaration.is_some());
         let var_data = self.var_types.get_mut(var_expr.declaration.as_ref().unwrap()).unwrap();
         var_data.used_at.push(upcast_id);
         self.progress_variable_expr(ctx, id)
+    }
+}
 macro_rules! debug_assert_expr_ids_unique_and_known {
     // Base case for a single expression ID
     ($resolver:ident, $id:ident) => {
         if cfg!(debug_assertions) {
             $resolver.expr_types.contains_key(&$id);
+        }
     };
     // Base case for two expression IDs
     ($resolver:ident, $id1:ident, $id2:ident) => {
         debug_assert_ne!($id1, $id2);
         debug_assert_expr_ids_unique_and_known!($resolver, $id1);
         debug_assert_expr_ids_unique_and_known!($resolver, $id2);
     };
     // Generic case
     ($resolver:ident, $id1:ident, $id2:ident, $($tail:ident),+) => {
         debug_assert_ne!($id1, $id2);
         debug_assert_expr_ids_unique_and_known!($resolver, $id1);
         debug_assert_expr_ids_unique_and_known!($resolver, $id2, $($tail),+);
     };
+}
 macro_rules! debug_assert_ptrs_distinct {
     // Base case
     ($ptr1:ident, $ptr2:ident) => {
         debug_assert!(!std::ptr::eq($ptr1, $ptr2));
     };
     // Generic case
     ($ptr1:ident, $ptr2:ident, $($tail:ident),+) => {
         debug_assert_ptrs_distinct!($ptr1, $ptr2);
         debug_assert_ptrs_distinct!($ptr2, $($tail),+);
     };
+}
 enum TypeConstraintResult {
     Progress, // Success: Made progress in applying constraints
     NoProgess, // Success: But did not make any progress in applying constraints
     ErrExprType, // Error: Expression type did not match the argument(s) of the expression type
     ErrArgType, // Error: Expression argument types did not match
+}
 impl TypeResolvingVisitor {
     fn progress_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> Result<(), ParseError2> {
         use AssignmentOperator as AO;
         // TODO: Assignable check
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_expr_id = expr.left;
         let arg2_expr_id = expr.right;
         let progress_base = match expr.operation {
             AO::Set =>
                 false,
             AO::Multiplied | AO::Divided | AO::Added | AO::Subtracted =>
                 self.apply_forced_constraint(ctx, upcast_id, &NUMBERLIKE_TEMPLATE)?,
             AO::Remained | AO::ShiftedLeft | AO::ShiftedRight |
             AO::BitwiseAnded | AO::BitwiseXored | AO::BitwiseOred =>
                 self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?,
         };
         let (progress_expr, progress_arg1, progress_arg2) = self.apply_equal3_constraint(
             ctx, upcast_id, arg1_expr_id, arg2_expr_id, 0
         )?;
         if progress_base || progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg1 { self.queue_expr(arg1_expr_id); }
         if progress_arg2 { self.queue_expr(arg2_expr_id); }
         Ok(())
+    }
     fn progress_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> Result<(), ParseError2> {
         // Note: test expression type is already enforced
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_expr_id = expr.true_expression;
         let arg2_expr_id = expr.false_expression;
         let (progress_expr, progress_arg1, progress_arg2) = self.apply_equal3_constraint(
             ctx, upcast_id, arg1_expr_id, arg2_expr_id, 0
         )?;
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg1 { self.queue_expr(arg1_expr_id); }
         if progress_arg2 { self.queue_expr(arg2_expr_id); }
         Ok(())
+    }
     fn progress_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> Result<(), ParseError2> {
         // Note: our expression type might be fixed by our parent, but we still
         // need to make sure it matches the type associated with our operation.
         use BinaryOperator as BO;
@@ @@ -1116,806 +1205,1015 @@ impl TypeResolvingVisitor { @@
                     self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg1, progress_base || progress_arg2)
             },
         };
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg1 { self.queue_expr(arg1_id); }
         if progress_arg2 { self.queue_expr(arg2_id); }
         Ok(())
+    }
     fn progress_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> Result<(), ParseError2> {
         use UnaryOperation as UO;
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg_id = expr.expression;
         let (progress_expr, progress_arg) = match expr.operation {
             UO::Positive | UO::Negative => {
                 // Equal types of numeric class
                 let progress_base = self.apply_forced_constraint(ctx, upcast_id, &NUMBERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg) =
                     self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, arg_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg)
             },
             UO::BitwiseNot | UO::PreIncrement | UO::PreDecrement | UO::PostIncrement | UO::PostDecrement => {
                 // Equal types of integer class
                 let progress_base = self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg) =
                     self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, arg_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg)
             },
             UO::LogicalNot => {
                 // Both booleans
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 (progress_expr, progress_arg)
+            }
         };
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg { self.queue_expr(arg_id); }
         Ok(())
+    }
     fn progress_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let subject_id = expr.subject;
         let index_id = expr.index;
         // Make sure subject is arraylike and index is integerlike
         let progress_subject_base = self.apply_forced_constraint(ctx, subject_id, &ARRAYLIKE_TEMPLATE)?;
         let progress_index = self.apply_forced_constraint(ctx, index_id, &INTEGERLIKE_TEMPLATE)?;
         // Make sure if output is of T then subject is Array<T>
         let (progress_expr, progress_subject) =
             self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, subject_id, 1)?;
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_subject_base || progress_subject { self.queue_expr(subject_id); }
         if progress_index { self.queue_expr(index_id); }
         Ok(())
+    }
     fn progress_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let subject_id = expr.subject;
         let from_id = expr.from_index;
         let to_id = expr.to_index;
         // Make sure subject is arraylike and indices are of equal integerlike
         let progress_subject_base = self.apply_forced_constraint(ctx, subject_id, &ARRAYLIKE_TEMPLATE)?;
         let progress_idx_base = self.apply_forced_constraint(ctx, from_id, &INTEGERLIKE_TEMPLATE)?;
         let (progress_from, progress_to) = self.apply_equal2_constraint(ctx, upcast_id, from_id, 0, to_id, 0)?;
         // Make sure if output is of T then subject is Array<T>
         let (progress_expr, progress_subject) =
             self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, subject_id, 1)?;
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_subject_base || progress_subject { self.queue_expr(subject_id); }
         if progress_idx_base || progress_from { self.queue_expr(from_id); }
         if progress_idx_base || progress_to { self.queue_expr(to_id); }
         Ok(())
+    }
     fn progress_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let subject_id = expr.subject;
         let (progress_subject, progress_expr) = match &expr.field {
             Field::Length => {
                 let progress_subject = self.apply_forced_constraint(ctx, subject_id, &ARRAYLIKE_TEMPLATE)?;
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?;
                 (progress_subject, progress_expr)
             },
             Field::Symbolic(_field) => {
                 todo!("implement select expr for symbolic fields");
+            }
         };
         if progress_subject { self.queue_expr(subject_id); }
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         Ok(())
+    }
     fn progress_array_expr(&mut self, ctx: &mut Ctx, id: ArrayExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let expr_elements = expr.elements.clone(); // TODO: @performance
         // All elements should have an equal type
         let progress = self.apply_equal_n_constraint(ctx, upcast_id, &expr_elements)?;
         let mut any_progress = false;
         for (progress_arg, arg_id) in progress.iter().zip(expr_elements.iter()) {
             if *progress_arg {
                 any_progress = true;
                 self.queue_expr(*arg_id);
+            }
+        }
         // And the output should be an array of the element types
         let mut expr_progress = self.apply_forced_constraint(ctx, upcast_id, &ARRAY_TEMPLATE)?;
         if !expr_elements.is_empty() {
             let first_arg_id = expr_elements[0];
             let (inner_expr_progress, arg_progress) = self.apply_equal2_constraint(
                 ctx, upcast_id, upcast_id, 1, first_arg_id, 0
             )?;
             expr_progress = expr_progress || inner_expr_progress;
             // Note that if the array type progressed the type of the arguments,
             // then we should enqueue this progression function again
             if arg_progress { self.queue_expr(upcast_id); }
+        }
         if expr_progress { self.queue_expr_parent(ctx, upcast_id); }
         Ok(())
+    }
     fn progress_constant_expr(&mut self, ctx: &mut Ctx, id: ConstantExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let template = match &expr.value {
             Constant::Null => &MESSAGE_TEMPLATE,
             Constant::Integer(_) => &INTEGERLIKE_TEMPLATE,
             Constant::True | Constant::False => &BOOL_TEMPLATE,
             Constant::Character(_) => todo!("character literals")
         };
         let progress = self.apply_forced_constraint(ctx, upcast_id, template)?;
         if progress { self.queue_expr_parent(ctx, upcast_id); }
         Ok(())
+    }
     // TODO: @cleanup, see how this can be cleaned up once I implement
     //  polymorphic struct/enum/union literals. These likely follow the same
     //  pattern as here.
     fn progress_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let extra = self.extra_data.get_mut(&upcast_id).unwrap();
         // Check if we can make progress using the arguments and/or return types
         // while keeping track of the polyvars we've extended
         let mut poly_progress = HashSet::new();
         debug_assert_eq!(extra.embedded.len(), expr.arguments.len());
         let mut poly_infer_error = false;
         for (arg_idx, arg_id) in expr.arguments.clone().into_iter().enumerate() {
             let signature_type = &mut extra.embedded[arg_idx];
             let argument_type: *mut _ = self.expr_types.get_mut(&arg_id).unwrap();
             let (progress_sig, progress_arg) = Self::apply_equal2_constraint_types(
                 ctx, upcast_id, signature_type, 0, argument_type, 0
             )?;
             if progress_sig {
                 // Progressed signature, so also apply inference to the
                 // polymorph types using the markers
                 debug_assert!(signature_type.has_marker, "progress on signature argument type without markers");
                 for (poly_idx, poly_section) in signature_type.marker_iter() {
                     let polymorph_type = &mut extra.poly_vars[poly_idx];
                     match Self::apply_forced_constraint_types(
                         polymorph_type, 0, poly_section, 0
                     ) {
                         Ok(true) => { poly_progress.insert(poly_idx); },
                         Ok(false) => {},
                         Err(()) => { poly_infer_error = true; }
+                    }
+                }
+            }
             if progress_arg {
                 // Progressed argument expression
-                self.queue_expr(arg_id);
+                self.expr_queued.insert(arg_id);
+            }
+        }
         // Do the same for the return type
         let signature_type = &mut extra.returned;
         let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();
         let (progress_sig, progress_expr) = Self::apply_equal2_constraint_types(
             ctx, upcast_id, signature_type, 0, expr_type, 0
         )?;
         if progress_sig {
             // As above: apply inference to polyargs as well
             debug_assert!(signature_type.has_marker, "progress on signature return type without markers");
             for (poly_idx, poly_section) in signature_type.marker_iter() {
                 let polymorph_type = &mut extra.poly_vars[poly_idx];
                 match Self::apply_forced_constraint_types(
                     polymorph_type, 0, poly_section, 0
                 ) {
                     Ok(true) => { poly_progress.insert(poly_idx); },
                     Ok(false) => {},
                     Err(()) => { poly_infer_error = true; }
+                }
+            }
+        }
         if progress_expr {
             self.queue_expr_parent(ctx, upcast_id);
             if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {
                 self.expr_queued.insert(parent_id);
+            }
+        }
         // If we had an error in the polymorphic variable's inference, then we
         // need to provide a human readable error: find a pair of inference
         // types in the arguments/return type that do not agree on the
         // polymorphic variable's type
         if poly_infer_error { return Err(self.construct_poly_arg_error(ctx, id)) }
         // If we did not have an error in the polymorph inference above, then
         // reapplying the polymorph type to each argument type and the return
         // type should always succeed.
         // TODO: @performance If the algorithm is changed to be more "on demand
         //  argument re-evaluation", instead of "all-argument re-evaluation",
         //  then this is no longer true
         for poly_idx in poly_progress.into_iter() {
             // For each polymorphic argument: first extend the signature type,
             // then reapply the equal2 constraint to the expressions
             let poly_type = &extra.poly_vars[poly_idx];
-            for (arg_idx, arg_type) in extra.embedded.iter_mut().enumerate() {
+            for (arg_idx, sig_type) in extra.embedded.iter_mut().enumerate() {
                 let mut seek_idx = 0;
                 let mut modified_sig = false;
-                while let Some((start_idx, end_idx)) = arg_type.find_subtree_idx_for_marker(poly_idx, seek_idx) {
+                while let Some((start_idx, end_idx)) = sig_type.find_subtree_idx_for_marker(poly_idx, seek_idx) {
                     let modified_at_marker = Self::apply_forced_constraint_types(
-                        arg_type, start_idx, &poly_type.parts, 0
+                        sig_type, start_idx, &poly_type.parts, 0
                     ).unwrap();
                     modified_sig = modified_sig || modified_at_marker;
                     seek_idx = end_idx;
+                }
                 if !modified_sig { continue; }
                 // Part of signature was modified, so update expression used as
                 // argument as well
                 let arg_expr_id = expr.arguments[arg_idx];
                 let arg_type = self.expr_types.get_mut(arg_expr_id).unwrap();
                 Self::apply_equal2_constraint_types(ctx, arg_expr_id, )
                 let arg_type: *mut _ = self.expr_types.get_mut(&arg_expr_id).unwrap();
                 let (progress_arg, _) = Self::apply_equal2_constraint_types(
                     ctx, arg_expr_id, arg_type, 0, sig_type, 0
                 ).expect("no inference error at argument type");
                 if progress_arg { self.expr_queued.insert(arg_expr_id); }
+            }
             // Again: do the same for the return type
             let sig_type = &mut extra.returned;
             let mut seek_idx = 0;
             let mut modified_sig = false;
             while let Some((start_idx, end_idx)) = sig_type.find_subtree_idx_for_marker(poly_idx, seek_idx) {
                 let modified_at_marker = Self::apply_forced_constraint_types(
                     sig_type, start_idx, &poly_type.parts, 0
                 ).unwrap();
                 modified_sig = modified_sig || modified_at_marker;
                 seek_idx = end_idx;
+            }
             if modified_sig {
                 let ret_type = self.expr_types.get_mut(&upcast_id).unwrap();
                 let (progress_ret, _) = Self::apply_equal2_constraint_types(
                     ctx, upcast_id, ret_type, 0, sig_type, 0
                 ).expect("no inference error at return type");
                 if progress_ret {
                     if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {
                         self.expr_queued.insert(parent_id);
+                    }
+                }
+            }
+        }
         Ok(())
+    }
     fn progress_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> Result<(), ParseError2> {
         let upcast_id = id.upcast();
         let var_expr = &ctx.heap[id];
         let var_id = var_expr.declaration.unwrap();
         // Retrieve shared variable type and expression type and apply inference
         let var_data = self.var_types.get_mut(&var_id).unwrap();
         let expr_type = self.expr_types.get_mut(&upcast_id).unwrap();
         let infer_res = unsafe{ InferenceType::infer_subtrees_for_both_types(
             &mut var_data.var_type as *mut _, 0, expr_type, 0
         ) };
         if infer_res == DualInferenceResult::Incompatible {
             let var_decl = &ctx.heap[var_id];
             return Err(ParseError2::new_error(
                 &ctx.module.source, var_decl.position(),
                 &format!(
                     "Conflicting types for this variable, previously assigned the type '{}'",
                     var_data.var_type.display_name(&ctx.heap)
+                )
             ).with_postfixed_info(
                 &ctx.module.source, var_expr.position,
                 &format!(
                     "But inferred to have incompatible type '{}' here",
                     expr_type.display_name(&ctx.heap)
+                )
             ))
+        }
         let progress_var = infer_res.modified_lhs();
         let progress_expr = infer_res.modified_rhs();
         if progress_var {
             for other_expr in var_data.used_at.iter() {
                 if *other_expr != upcast_id {
                     self.expr_queued.insert(*other_expr);
+                }
+            }
+        }
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         Ok(())
+    }
     fn queue_expr_parent(&mut self, ctx: &Ctx, expr_id: ExpressionId) {
         if let ExpressionParent::Expression(parent_expr_id, _) = &ctx.heap[expr_id].parent() {
             self.expr_queued.insert(*parent_expr_id);
+        }
+    }
     fn queue_expr(&mut self, expr_id: ExpressionId) {
         self.expr_queued.insert(expr_id);
+    }
     /// Applies a forced type constraint: the type associated with the supplied
     /// expression will be molded into the provided "template". The template may
     /// be fully specified (e.g. a bool) or contain "inference" variables (e.g.
     /// an array of T)
     fn apply_forced_constraint(
         &mut self, ctx: &mut Ctx, expr_id: ExpressionId, template: &[InferenceTypePart]
     ) -> Result<bool, ParseError2> {
         debug_assert_expr_ids_unique_and_known!(self, expr_id);
         let expr_type = self.expr_types.get_mut(&expr_id).unwrap();
         match InferenceType::infer_subtree_for_single_type(expr_type, 0, template, 0) {
             SingleInferenceResult::Modified => Ok(true),
             SingleInferenceResult::Unmodified => Ok(false),
             SingleInferenceResult::Incompatible => Err(
                 self.construct_template_type_error(ctx, expr_id, template)
+            )
+        }
+    }
     fn apply_forced_constraint_types(
         to_infer: *mut InferenceType, to_infer_start_idx: usize,
         template: &[InferenceTypePart], template_start_idx: usize
     ) -> Result<bool, ()> {
         match InferenceType::infer_subtree_for_single_type(
             unsafe{ &mut *to_infer }, to_infer_start_idx,
             template, template_start_idx
         ) {
             SingleInferenceResult::Modified => Ok(true),
             SingleInferenceResult::Unmodified => Ok(false),
             SingleInferenceResult::Incompatible => Err(()),
+        }
+    }
     /// Applies a type constraint that expects the two provided types to be
     /// equal. We attempt to make progress in inferring the types. If the call
     /// is successful then the composition of all types are made equal.
     /// The "parent" `expr_id` is provided to construct errors.
     fn apply_equal2_constraint(
         &mut self, ctx: &Ctx, expr_id: ExpressionId,
         arg1_id: ExpressionId, arg1_start_idx: usize,
         arg2_id: ExpressionId, arg2_start_idx: usize
     ) -> Result<(bool, bool), ParseError2> {
         debug_assert_expr_ids_unique_and_known!(self, arg1_id, arg2_id);
         let arg1_type: *mut _ = self.expr_types.get_mut(&arg1_id).unwrap();
         let arg2_type: *mut _ = self.expr_types.get_mut(&arg2_id).unwrap();
         let infer_res = unsafe{ InferenceType::infer_subtrees_for_both_types(
             arg1_type, arg1_start_idx,
             arg2_type, arg2_start_idx
         ) };
         if infer_res == DualInferenceResult::Incompatible {
             return Err(self.construct_arg_type_error(ctx, expr_id, arg1_id, arg2_id));
+        }
         Ok((infer_res.modified_lhs(), infer_res.modified_rhs()))
+    }
     fn apply_equal2_constraint_types(
         ctx: &Ctx, expr_id: ExpressionId,
         type1: *mut InferenceType, type1_start_idx: usize,
         type2: *mut InferenceType, type2_start_idx: usize
     ) -> Result<(bool, bool), ParseError2> {
         debug_assert_ptrs_distinct!(type1, type2);
         let infer_res = unsafe {
             InferenceType::infer_subtrees_for_both_types(
                 type1, type1_start_idx,
                 type2, type2_start_idx
+            )
         };
         if infer_res == DualInferenceResult::Incompatible {
             return Err(ParseError2::new_error(
                 &ctx.module.source, ctx.heap[expr_id].position(),
                 "TODO: Write me, apply_equal2_constraint_types"
             ));
+        }
         Ok((infer_res.modified_lhs(), infer_res.modified_rhs()))
+    }
     /// Applies a type constraint that expects all three provided types to be
     /// equal. In case we can make progress in inferring the types then we
     /// attempt to do so. If the call is successful then the composition of all
     /// types is made equal.
     fn apply_equal3_constraint(
         &mut self, ctx: &Ctx, expr_id: ExpressionId,
         arg1_id: ExpressionId, arg2_id: ExpressionId,
         start_idx: usize
     ) -> Result<(bool, bool, bool), ParseError2> {
         // Safety: all expression IDs are always distinct, and we do not modify
         //  the container
         debug_assert_expr_ids_unique_and_known!(self, expr_id, arg1_id, arg2_id);
         let expr_type: *mut _ = self.expr_types.get_mut(&expr_id).unwrap();
         let arg1_type: *mut _ = self.expr_types.get_mut(&arg1_id).unwrap();
         let arg2_type: *mut _ = self.expr_types.get_mut(&arg2_id).unwrap();
         let expr_res = unsafe{
             InferenceType::infer_subtrees_for_both_types(expr_type, start_idx, arg1_type, start_idx)
         };
         if expr_res == DualInferenceResult::Incompatible {
             return Err(self.construct_expr_type_error(ctx, expr_id, arg1_id));
+        }
         let args_res = unsafe{
             InferenceType::infer_subtrees_for_both_types(arg1_type, start_idx, arg2_type, start_idx) };
         if args_res == DualInferenceResult::Incompatible {
             return Err(self.construct_arg_type_error(ctx, expr_id, arg1_id, arg2_id));
+        }
         // If all types are compatible, but the second call caused the arg1_type
         // to be expanded, then we must also assign this to expr_type.
         let mut progress_expr = expr_res.modified_lhs();
         let mut progress_arg1 = expr_res.modified_rhs();
         let mut progress_arg2 = args_res.modified_rhs();
         if args_res.modified_lhs() {
             unsafe {
                 (*expr_type).parts.drain(start_idx..);
                 (*expr_type).parts.extend_from_slice(&((*arg2_type).parts[start_idx..]));
                 let end_idx = InferenceType::find_subtree_end_idx(&(*arg2_type).parts, start_idx);
                 let subtree = &((*arg2_type).parts[start_idx..end_idx]);
                 (*expr_type).replace_subtree(start_idx, subtree);
+            }
             progress_expr = true;
             progress_arg1 = true;
+        }
         Ok((progress_expr, progress_arg1, progress_arg2))
+    }
     // TODO: @optimize Since we only deal with a single type this might be done
     //  a lot more efficiently, methinks (disregarding the allocations here)
     fn apply_equal_n_constraint(
         &mut self, ctx: &Ctx, expr_id: ExpressionId, args: &[ExpressionId],
     ) -> Result<Vec<bool>, ParseError2> {
         // Early exit
         match args.len() {
 => return Ok(vec!()),         // nothing to progress
 => return Ok(vec![false]),    // only one type, so nothing to infer
             _ => {}
+        }
         let mut progress = Vec::new();
         progress.resize(args.len(), false);
         // Do pairwise inference, keep track of the last entry we made progress
         // on. Once done we need to update everything to the most-inferred type.
         let mut arg_iter = args.iter();
         let mut last_arg_id = *arg_iter.next().unwrap();
         let mut last_lhs_progressed = 0;
         let mut lhs_arg_idx = 0;
         while let Some(next_arg_id) = arg_iter.next() {
             let arg1_type: *mut _ = self.expr_types.get_mut(&last_arg_id).unwrap();
             let arg2_type: *mut _ = self.expr_types.get_mut(next_arg_id).unwrap();
             let res = unsafe {
                 InferenceType::infer_subtrees_for_both_types(arg1_type, 0, arg2_type, 0)
             };
             if res == DualInferenceResult::Incompatible {
                 return Err(self.construct_arg_type_error(ctx, expr_id, last_arg_id, *next_arg_id));
+            }
             if res.modified_lhs() {
                 // We re-inferred something on the left hand side, so everything
                 // up until now should be re-inferred.
                 progress[lhs_arg_idx] = true;
                 last_lhs_progressed = lhs_arg_idx;
+            }
             progress[lhs_arg_idx + 1] = res.modified_rhs();
             last_arg_id = *next_arg_id;
             lhs_arg_idx += 1;
+        }
         // Re-infer everything. Note that we do not need to re-infer the type
         // exactly at `last_lhs_progressed`, but only everything up to it.
         let last_type: *mut _ = self.expr_types.get_mut(args.last().unwrap()).unwrap();
         for arg_idx in 0..last_lhs_progressed {
             let arg_type: *mut _ = self.expr_types.get_mut(&args[arg_idx]).unwrap();
             unsafe{
                 (*arg_type).replace_subtree(0, &(*last_type).parts);
+            }
             progress[arg_idx] = true;
+        }
         Ok(progress)
+    }
     /// Determines the `InferenceType` for the expression based on the
     /// expression parent. Note that if the parent is another expression, we do
     /// not take special action, instead we let parent expressions fix the type
     /// of subexpressions before they have a chance to call this function.
     /// Hence: if the expression type is already set, this function doesn't do
     /// anything.
     fn insert_initial_expr_inference_type(
         &mut self, ctx: &mut Ctx, expr_id: ExpressionId
     ) -> Result<(), ParseError2> {
         use ExpressionParent as EP;
         use InferenceTypePart as ITP;
         let expr = &ctx.heap[expr_id];
         let inference_type = match expr.parent() {
             EP::None =>
                 // Should have been set by linker
                 unreachable!(),
             EP::Memory(_) | EP::ExpressionStmt(_) | EP::Expression(_, _) =>
                 // Determined during type inference
                 InferenceType::new(false, false, vec![ITP::Unknown]),
             EP::If(_) | EP::While(_) | EP::Assert(_) =>
                 // Must be a boolean
                 InferenceType::new(false, true, vec![ITP::Bool]),
             EP::Return(_) =>
                 // Must match the return type of the function
                 if let DefinitionType::Function(func_id) = self.definition_type {
                     let return_parser_type_id = ctx.heap[func_id].return_type;
                     self.determine_inference_type_from_parser_type(ctx, return_parser_type_id, true)
                 } else {
                     // Cannot happen: definition always set upon body traversal
                     // and "return" calls in components are illegal.
                     unreachable!();
                 },
             EP::New(_) =>
                 // Must be a component call, which we assign a "Void" return
                 // type
                 InferenceType::new(false, true, vec![ITP::Void]),
             EP::Put(_, 0) =>
                 // TODO: Change put to be a builtin function
                 // port of "put" call
                 InferenceType::new(false, false, vec![ITP::Output, ITP::Unknown]),
             EP::Put(_, 1) =>
                 // TODO: Change put to be a builtin function
                 // message of "put" call
                 InferenceType::new(false, true, vec![ITP::Message]),
             EP::Put(_, _) =>
                 unreachable!()
         };
         match self.expr_types.entry(expr_id) {
             Entry::Vacant(vacant) => {
                 vacant.insert(inference_type);
             },
             Entry::Occupied(mut preexisting) => {
                 // We already have an entry, this happens if our parent fixed
                 // our type (e.g. we're used in a conditional expression's test)
                 // but we have a different type.
                 // TODO: Is this ever called? Seems like it can't
                 debug_assert!(false, "I am actually called, my ID is {}", expr_id.index);
                 let old_type = preexisting.get_mut();
                 if let SingleInferenceResult::Incompatible = InferenceType::infer_subtree_for_single_type(
                     old_type, 0, &inference_type.parts, 0
                 ) {
                     return Err(self.construct_expr_type_error(ctx, expr_id, expr_id))
+                }
+            }
+        }
         Ok(())
+    }
     fn insert_initial_call_polymorph_data(
         &mut self, ctx: &mut Ctx, call_id: CallExpressionId
     ) {
         use InferenceTypePart as ITP;
         // Note: the polymorph variables may be partially specified and may
         // contain references to the wrapping definition's (i.e. the proctype
         // we are currently visiting) polymorphic arguments.
         //
         // The arguments of the call may refer to polymorphic variables in the
         // definition of the function we're calling, not of the wrapping
         // definition. We insert markers in these inferred types to be able to
         // map them back and forth to the polymorphic arguments of the function
         // we are calling.
         let call = &ctx.heap[call_id];
         debug_assert!(!call.poly_args.is_empty());
         // Handle the polymorphic variables themselves
         let mut poly_vars = Vec::with_capacity(call.poly_args.len());
         for poly_arg_type_id in call.poly_args.clone() { // TODO: @performance
             poly_vars.push(self.determine_inference_type_from_parser_type(ctx, poly_arg_type_id, true));
+        }
         // Handle the arguments
         // TODO: @cleanup: Maybe factor this out for reuse in the validator/linker, should also
         //  make the code slightly more robust.
         let (embedded_types, return_type) = match &call.method {
             Method::Create => {
                 // Not polymorphic
                 unreachable!("insert initial polymorph data for builtin 'create()' call")
             },
             Method::Fires => {
                 // bool fires<T>(PortLike<T> arg)
+                (
                     vec![InferenceType::new(true, false, vec![ITP::PortLike, ITP::Marker(0), ITP::Unknown])],
                     InferenceType::new(false, true, vec![ITP::Bool])
+                )
             },
             Method::Get => {
                 // T get<T>(input<T> arg)
+                (
                     vec![InferenceType::new(true, false, vec![ITP::Input, ITP::Marker(0), ITP::Unknown])],
                     InferenceType::new(true, false, vec![ITP::Marker(0), ITP::Unknown])
+                )
             },
             Method::Put => {
                 // void Put<T>(output<T> port, T msg)
+                (
                     vec![
                         InferenceType::new(true, false, vec![ITP::Output, ITP::Marker(0), ITP::Unknown]),
                         InferenceType::new(true, false, vec![ITP::Marker(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) => {
                         let mut parameter_types = Vec::with_capacity(definition.parameters.len());
                         for param_id in definition.parameters.clone() {
                             let param = &ctx.heap[param_id];
                             let param_parser_type_id = param.parser_type;
                             parameter_types.push(self.determine_inference_type_from_parser_type(ctx, param_parser_type_id, false));
+                        }
                         (parameter_types, InferenceType::new(false, true, vec![InferenceTypePart::Void]))
                     },
                     Definition::Function(definition) => {
                         let mut parameter_types = Vec::with_capacity(definition.parameters.len());
                         for param_id in definition.parameters.clone() {
                             let param = &ctx.heap[param_id];
                             let param_parser_type_id = param.parser_type;
                             parameter_types.push(self.determine_inference_type_from_parser_type(ctx, param_parser_type_id, false));
+                        }
                         let return_type = self.determine_inference_type_from_parser_type(ctx, definition.return_type, false);
                         (parameter_types, return_type)
                     },
                     Definition::Struct(_) | Definition::Enum(_) => {
                         unreachable!("insert initial polymorph data for struct/enum");
+                    }
+                }
+            }
         };
         self.extra_data.insert(call_id.upcast(), ExtraData {
             poly_vars,
             embedded: embedded_types,
             returned: return_type
         });
+    }
     /// Determines the initial InferenceType from the provided ParserType. This
     /// may be called with two kinds of intentions:
     /// 1. To resolve a ParserType within the body of a function, or on
     ///     polymorphic arguments to calls/instantiations within that body. This
     ///     means that the polymorphic variables are known and can be replaced
     ///     with the monomorph we're instantiating.
     /// 2. To resolve a ParserType on a called function's definition or on
     ///     an instantiated datatype's members. This means that the polymorphic
     ///     arguments inside those ParserTypes refer to the polymorphic
     ///     variables in the called/instantiated type's definition.
     /// In the second case we place InferenceTypePart::Marker instances such
     /// that we can perform type inference on the polymorphic variables.
     fn determine_inference_type_from_parser_type(
         &mut self, ctx: &Ctx, parser_type_id: ParserTypeId,
         parser_type_in_body: bool
     ) -> InferenceType {
         use ParserTypeVariant as PTV;
         use InferenceTypePart as ITP;
         let mut to_consider = VecDeque::with_capacity(16);
         to_consider.push_back(parser_type_id);
         let mut infer_type = Vec::new();
         let mut has_inferred = false;
         let mut has_markers = false;
         while !to_consider.is_empty() {
             let parser_type_id = to_consider.pop_front().unwrap();
             let parser_type = &ctx.heap[parser_type_id];
             match &parser_type.variant {
                 PTV::Message => { infer_type.push(ITP::Message); },
                 PTV::Bool => { infer_type.push(ITP::Bool); },
                 PTV::Byte => { infer_type.push(ITP::Byte); },
                 PTV::Short => { infer_type.push(ITP::Short); },
                 PTV::Int => { infer_type.push(ITP::Int); },
                 PTV::Long => { infer_type.push(ITP::Long); },
                 PTV::String => { infer_type.push(ITP::String); },
                 PTV::IntegerLiteral => { unreachable!("integer literal type on variable type"); },
                 PTV::Inferred => {
                     infer_type.push(ITP::Unknown);
                     has_inferred = true;
                 },
                 PTV::Array(subtype_id) => {
                     infer_type.push(ITP::Array);
                     to_consider.push_front(*subtype_id);
                 },
                 PTV::Input(subtype_id) => {
                     infer_type.push(ITP::Input);
                     to_consider.push_front(*subtype_id);
                 },
                 PTV::Output(subtype_id) => {
                     infer_type.push(ITP::Output);
                     to_consider.push_front(*subtype_id);
                 },
                 PTV::Symbolic(symbolic) => {
                     debug_assert!(symbolic.variant.is_some(), "symbolic variant not yet determined");
                     match symbolic.variant.unwrap() {
+                    match symbolic.variant.as_ref().unwrap() {
                         SymbolicParserTypeVariant::PolyArg(_, arg_idx) => {
                             // Retrieve concrete type of argument and add it to
                             // the inference type.
                             let arg_idx = *arg_idx;
                             debug_assert!(symbolic.poly_args.is_empty()); // TODO: @hkt
                             if parser_type_in_body {
                                 debug_assert!(arg_idx < self.polyvars.len());
                                 for concrete_part in &self.polyvars[arg_idx].v {
                                     infer_type.push(ITP::from(*concrete_part));
+                                }
                             } else {
                                 has_markers = true;
                                 infer_type.push(ITP::Marker(arg_idx));
                                 infer_type.push(ITP::Unknown);
+                            }
                         },
                         SymbolicParserTypeVariant::Definition(definition_id) => {
                             // TODO: @cleanup
                             if cfg!(debug_assertions) {
                                 let definition = &ctx.heap[definition_id];
+                                let definition = &ctx.heap[*definition_id];
                                 debug_assert!(definition.is_struct() || definition.is_enum()); // TODO: @function_ptrs
                                 let num_poly = match definition {
                                     Definition::Struct(v) => v.poly_vars.len(),
                                     Definition::Enum(v) => v.poly_vars.len(),
                                     _ => unreachable!(),
                                 };
                                 debug_assert_eq!(symbolic.poly_args.len(), num_poly);
+                            }
                             infer_type.push(ITP::Instance(definition_id, symbolic.poly_args.len()));
+                            infer_type.push(ITP::Instance(*definition_id, symbolic.poly_args.len()));
                             let mut poly_arg_idx = symbolic.poly_args.len();
                             while poly_arg_idx > 0 {
                                 poly_arg_idx -= 1;
                                 to_consider.push_front(symbolic.poly_args[poly_arg_idx]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
         InferenceType::new(has_markers, !has_inferred, infer_type)
+    }
     /// Construct an error when an expression's type does not match. This
     /// happens if we infer the expression type from its arguments (e.g. the
     /// expression type of an addition operator is the type of the arguments)
     /// But the expression type was already set due to our parent (e.g. an
     /// "if statement" or a "logical not" always expecting a boolean)
     fn construct_expr_type_error(
         &self, ctx: &Ctx, expr_id: ExpressionId, arg_id: ExpressionId
     ) -> ParseError2 {
         // TODO: Expand and provide more meaningful information for humans
         let expr = &ctx.heap[expr_id];
         let arg_expr = &ctx.heap[arg_id];
         let expr_type = self.expr_types.get(&expr_id).unwrap();
         let arg_type = self.expr_types.get(&arg_id).unwrap();
         return ParseError2::new_error(
             &ctx.module.source, expr.position(),
             &format!(
                 "Incompatible types: this expression expected a '{}'",
                 expr_type.display_name(&ctx.heap)
+            )
         ).with_postfixed_info(
             &ctx.module.source, arg_expr.position(),
             &format!(
                 "But this expression yields a '{}'",
                 arg_type.display_name(&ctx.heap)
+            )
+        )
+    }
     fn construct_arg_type_error(
         &self, ctx: &Ctx, expr_id: ExpressionId,
         arg1_id: ExpressionId, arg2_id: ExpressionId
     ) -> ParseError2 {
         let expr = &ctx.heap[expr_id];
         let arg1 = &ctx.heap[arg1_id];
         let arg2 = &ctx.heap[arg2_id];
         let arg1_type = self.expr_types.get(&arg1_id).unwrap();
         let arg2_type = self.expr_types.get(&arg2_id).unwrap();
         return ParseError2::new_error(
             &ctx.module.source, expr.position(),
             "Incompatible types: cannot apply this expression"
         ).with_postfixed_info(
             &ctx.module.source, arg1.position(),
             &format!(
                 "Because this expression has type '{}'",
                 arg1_type.display_name(&ctx.heap)
+            )
         ).with_postfixed_info(
             &ctx.module.source, arg2.position(),
             &format!(
                 "But this expression has type '{}'",
                 arg2_type.display_name(&ctx.heap)
+            )
+        )
+    }
     fn construct_template_type_error(
         &self, ctx: &Ctx, expr_id: ExpressionId, template: &[InferenceTypePart]
     ) -> ParseError2 {
         let expr = &ctx.heap[expr_id];
         let expr_type = self.expr_types.get(&expr_id).unwrap();
         return ParseError2::new_error(
             &ctx.module.source, expr.position(),
             &format!(
                 "Incompatible types: got a '{}' but expected a '{}'",
                 expr_type.display_name(&ctx.heap),
                 InferenceType::partial_display_name(&ctx.heap, template)
+            )
+        )
+    }
     /// Constructs a human interpretable error in the case that type inference
     /// on a polymorphic variable to a function call failed. This may only be
     /// caused by a pair of inference types (which may come from arguments or
     /// the return type) having two different inferred values for that
     /// polymorphic variable.
     ///
     /// So we find this pair (which may be a argument type or return type
     /// conflicting with itself) and construct the error using it.
     fn construct_poly_arg_error(
         &self, ctx: &Ctx, call_id: CallExpressionId
     ) -> ParseError2 {
         // Helper function to check for polymorph mismatch between two inference
         // types.
         fn has_poly_mismatch<'a>(type_a: &'a InferenceType, type_b: &'a InferenceType) -> Option<(usize, &'a [InferenceTypePart], &'a [InferenceTypePart])> {
             if !type_a.has_marker || !type_b.has_marker {
                 return None
+            }
             for (marker_a, section_a) in type_a.marker_iter() {
                 for (marker_b, section_b) in type_b.marker_iter() {
                     if marker_a != marker_b {
                         // Not the same polymorphic variable
                         continue;
+                    }
                     if !InferenceType::check_subtrees(section_a, 0, section_b, 0) {
                         // Not compatible
                         return Some((marker_a, section_a, section_b))
+                    }
+                }
+            }
             None
+        }
         // Helpers function to retrieve polyvar name and function name
         fn get_poly_var_and_func_name(ctx: &Ctx, poly_var_idx: usize, expr: &CallExpression) -> (String, String) {
             match &expr.method {
                 Method::Create => unreachable!(),
                 Method::Fires => (String::from('T'), String::from("fires")),
                 Method::Get => (String::from('T'), String::from("get")),
                 Method::Put => (String::from('T'), String::from("put")),
                 Method::Symbolic(symbolic) => {
                     let definition = &ctx.heap[symbolic.definition.unwrap()];
                     let poly_var = match definition {
                         Definition::Struct(_) | Definition::Enum(_) => unreachable!(),
                         Definition::Function(definition) => {
                             String::from_utf8_lossy(&definition.poly_vars[poly_var_idx].value).to_string()
                         },
                         Definition::Component(definition) => {
                             String::from_utf8_lossy(&definition.poly_vars[poly_var_idx].value).to_string()
+                        }
                     };
                     let func_name = String::from_utf8_lossy(&symbolic.identifier.value).to_string();
                     (poly_var, func_name)
+                }
+            }
+        }
         // Helper function to construct initial error
         fn construct_main_error(ctx: &Ctx, poly_var_idx: usize, expr: &CallExpression) -> ParseError2 {
             let (poly_var, func_name) = get_poly_var_and_func_name(ctx, poly_var_idx, expr);
             return ParseError2::new_error(
                 &ctx.module.source, expr.position(),
                 &format!(
                     "Conflicting type for polymorphic variable '{}' of '{}'",
                     poly_var, func_name
+                )
+            )
+        }
         // Actual checking
         let extra = self.extra_data.get(&call_id.upcast()).unwrap();
         let expr = &ctx.heap[call_id];
         // - check return type with itself
         if let Some((poly_idx, section_a, section_b)) = has_poly_mismatch(&extra.returned, &extra.returned) {
             return construct_main_error(ctx, poly_idx, expr)
                 .with_postfixed_info(
                     &ctx.module.source, expr.position(),
                     &format!(
                         "The return type inferred the conflicting types '{}' and '{}'",
                         InferenceType::partial_display_name(&ctx.heap, section_a),
                         InferenceType::partial_display_name(&ctx.heap, section_b)
+                    )
+                )
+        }
         // - check arguments with each other argument and with return type
         for (arg_a_idx, arg_a) in extra.embedded.iter().enumerate() {
             for (arg_b_idx, arg_b) in extra.embedded.iter().enumerate() {
                 if arg_b_idx > arg_a_idx {
                     break;
+                }
                 if let Some((poly_idx, section_a, section_b)) = has_poly_mismatch(&arg_a, &arg_b) {
                     let error = construct_main_error(ctx, poly_idx, expr);
                     if arg_a_idx == arg_b_idx {
                         // Same argument
                         let arg = &ctx.heap[expr.arguments[arg_a_idx]];
                         return error.with_postfixed_info(
                             &ctx.module.source, arg.position(),
                             &format!(
                                 "This argument inferred the conflicting types '{}' and '{}'",
                                 InferenceType::partial_display_name(&ctx.heap, section_a),
                                 InferenceType::partial_display_name(&ctx.heap, section_b)
+                            )
+                        )
                     } else {
                         let arg_a = &ctx.heap[expr.arguments[arg_a_idx]];
                         let arg_b = &ctx.heap[expr.arguments[arg_b_idx]];
                         return error.with_postfixed_info(
                             &ctx.module.source, arg_a.position(),
                             &format!(
                                 "This argument inferred it to '{}'",
                                 InferenceType::partial_display_name(&ctx.heap, section_a)
+                            )
                         ).with_postfixed_info(
                             &ctx.module.source, arg_b.position(),
                             &format!(
                                 "While this argument inferred it to '{}'",
                                 InferenceType::partial_display_name(&ctx.heap, section_b)
+                            )
+                        )
+                    }
+                }
+            }
             // Check with return type
             if let Some((poly_idx, section_arg, section_ret)) = has_poly_mismatch(arg_a, &extra.returned) {
                 let arg = &ctx.heap[expr.arguments[arg_a_idx]];
                 return construct_main_error(ctx, poly_idx, expr)
                     .with_postfixed_info(
                         &ctx.module.source, arg.position(),
                         &format!(
                             "This argument inferred it to '{}'",
                             InferenceType::partial_display_name(&ctx.heap, section_arg)
+                        )

src/protocol/parser/type_table.rs

➞

Show inline comments

@@ @@ -88,194 +88,194 @@ impl TypeClass { @@
+    }
     pub(crate) fn is_proc_type(&self) -> bool {
         *self == TypeClass::Function || *self == TypeClass::Component
+    }
+}
 impl std::fmt::Display for TypeClass {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         write!(f, "{}", self.display_name())
+    }
+}
 /// Struct wrapping around a potentially polymorphic type. If the type does not
 /// have any polymorphic arguments then it will not have any monomorphs and
 /// `is_polymorph` will be set to `false`. A type with polymorphic arguments
 /// only has `is_polymorph` set to `true` if the polymorphic arguments actually
 /// appear in the types associated types (function return argument, struct
 /// field, enum variant, etc.). Otherwise the polymorphic argument is just a
 /// marker and does not influence the bytesize of the type.
 pub struct DefinedType {
     pub(crate) ast_definition: DefinitionId,
     pub(crate) definition: DefinedTypeVariant,
     pub(crate) poly_args: Vec<PolyArg>,
     pub(crate) is_polymorph: bool,
     pub(crate) is_pointerlike: bool,
     pub(crate) monomorphs: Vec<u32>, // TODO: ?
+}
 pub enum DefinedTypeVariant {
     Enum(EnumType),
     Union(UnionType),
     Struct(StructType),
     Function(FunctionType),
     Component(ComponentType)
+}
 pub struct PolyArg {
     identifier: Identifier,
     /// Whether the polymorphic argument is used directly in the definition of
     /// the type (not including bodies of function/component types)
     is_in_use: bool,
+}
 impl DefinedTypeVariant {
     pub(crate) fn type_class(&self) -> TypeClass {
         match self {
             DefinedTypeVariant::Enum(_) => TypeClass::Enum,
             DefinedTypeVariant::Union(_) => TypeClass::Union,
             DefinedTypeVariant::Struct(_) => TypeClass::Struct,
             DefinedTypeVariant::Function(_) => TypeClass::Function,
             DefinedTypeVariant::Component(_) => TypeClass::Component
+        }
+    }
+}
 /// `EnumType` is the classical C/C++ enum type. It has various variants with
 /// an assigned integer value. The integer values may be user-defined,
 /// compiler-defined, or a mix of the two. If a user assigns the same enum
 /// value multiple times, we assume the user is an expert and we consider both
 /// variants to be equal to one another.
 pub struct EnumType {
     variants: Vec<EnumVariant>,
     representation: PrimitiveType,
+}
 // TODO: Also support maximum u64 value
 pub struct EnumVariant {
     identifier: Identifier,
     value: i64,
+}
 /// `UnionType` is the algebraic datatype (or sum type, or discriminated union).
 /// A value is an element of the union, identified by its tag, and may contain
 /// a single subtype.
 pub struct UnionType {
     variants: Vec<UnionVariant>,
     tag_representation: PrimitiveType
+}
 pub struct UnionVariant {
     identifier: Identifier,
     parser_type: Option<ParserTypeId>,
     tag_value: i64,
+}
 pub struct StructType {
     fields: Vec<StructField>,
+}
 pub struct StructField {
     identifier: Identifier,
     parser_type: ParserTypeId,
+}
 pub struct FunctionType {
     return_type: ParserTypeId,
     arguments: Vec<FunctionArgument>
     pub return_type: ParserTypeId,
     pub arguments: Vec<FunctionArgument>
+}
 pub struct ComponentType {
     variant: ComponentVariant,
     arguments: Vec<FunctionArgument>
+}
 pub struct FunctionArgument {
     identifier: Identifier,
     parser_type: ParserTypeId,
+}
 //------------------------------------------------------------------------------
 // Type table
 //------------------------------------------------------------------------------
 // TODO: @cleanup Do I really need this, doesn't make the code that much cleaner
 struct TypeIterator {
     breadcrumbs: Vec<(RootId, DefinitionId)>
+}
 impl TypeIterator {
     fn new() -> Self {
         Self{ breadcrumbs: Vec::with_capacity(32) }
+    }
     fn reset(&mut self, root_id: RootId, definition_id: DefinitionId) {
         self.breadcrumbs.clear();
         self.breadcrumbs.push((root_id, definition_id))
+    }
     fn push(&mut self, root_id: RootId, definition_id: DefinitionId) {
         self.breadcrumbs.push((root_id, definition_id));
+    }
     fn contains(&self, root_id: RootId, definition_id: DefinitionId) -> bool {
         for (stored_root_id, stored_definition_id) in self.breadcrumbs.iter() {
             if *stored_root_id == root_id && *stored_definition_id == definition_id { return true; }
+        }
         return false
+    }
     fn top(&self) -> Option<(RootId, DefinitionId)> {
         self.breadcrumbs.last().map(|(r, d)| (*r, *d))
+    }
     fn pop(&mut self) {
         debug_assert!(!self.breadcrumbs.is_empty());
         self.breadcrumbs.pop();
+    }
+}
 #[derive(Copy, Clone)]
 pub(crate) enum ConcreteTypeVariant {
     // No subtypes
     Message,
     Bool,
     Byte,
     Short,
     Int,
     Long,
     String,
     // One subtype
     Array,
     Slice,
     Input,
     Output,
     // Multiple subtypes (definition of thing and number of poly args)
     Instance(DefinitionId, usize)
+}
 pub(crate) struct ConcreteType {
     // serialized version (interpret as serialized depth-first tree, with
     // variant indicating the number of children (subtypes))
     pub(crate) v: Vec<ConcreteTypeVariant>
+}
 /// Result from attempting to resolve a `ParserType` using the symbol table and
 /// the type table.
 enum ResolveResult {
     /// ParserType is a builtin type
     BuiltIn,
     /// ParserType points to a polymorphic argument, contains the index of the
     /// polymorphic argument in the outermost definition (e.g. we may have
     /// structs nested three levels deep, but in the innermost struct we can
     /// only use the polyargs that are specified in the type definition of the
     /// outermost struct).
     PolyArg(usize),
     /// ParserType points to a user-defined type that is already resolved in the
     /// type table.
     Resolved((RootId, DefinitionId)),
     /// ParserType points to a user-defined type that is not yet resolved into
     /// the type table.
     Unresolved((RootId, DefinitionId))
+}
@@ @@ -548,193 +548,194 @@ impl TypeTable { @@
         debug_assert!(!self.lookup.contains_key(&definition_id), "base struct already resolved");
         let definition = ctx.heap[definition_id].as_struct();
         // Make sure all fields point to resolvable types
         for field_definition in &definition.fields {
             let resolve_result = self.resolve_base_parser_type(ctx, &definition.poly_vars, root_id, field_definition.parser_type)?;
             if !self.ingest_resolve_result(ctx, resolve_result)? {
                 return Ok(false)
+            }
+        }
         // All fields types are resolved, construct base type
         let mut fields = Vec::with_capacity(definition.fields.len());
         for field_definition in &definition.fields {
             fields.push(StructField{
                 identifier: field_definition.field.clone(),
                 parser_type: field_definition.parser_type,
             })
+        }
         // And make sure no conflicts exist in field names and/or polymorphic args
         self.check_identifier_collision(
             ctx, root_id, &fields, |field| &field.identifier, "struct field"
         )?;
         self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;
         // Construct representation of polymorphic arguments
         let mut poly_args = self.create_initial_poly_args(&definition.poly_vars);
         for field in &fields {
             self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, field.parser_type)?;
+        }
         let is_polymorph = poly_args.iter().any(|arg| arg.is_in_use);
         self.lookup.insert(definition_id, DefinedType{
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Struct(StructType{
                 fields,
             }),
             poly_args,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic
             monomorphs: Vec::new(),
         });
         Ok(true)
+    }
     /// Resolves the basic function definition to an entry in the type table. It
     /// will not instantiate any monomorphized instances of polymorphic function
     /// definitions.
     fn resolve_base_function_definition(&mut self, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result<bool, ParseError2> {
         debug_assert!(ctx.heap[definition_id].is_function());
         debug_assert!(!self.lookup.contains_key(&definition_id), "base function already resolved");
         let definition = ctx.heap[definition_id].as_function();
         let return_type = definition.return_type;
         // Check the return type
         let resolve_result = self.resolve_base_parser_type(
             ctx, &definition.poly_vars, root_id, definition.return_type
         )?;
         if !self.ingest_resolve_result(ctx, resolve_result)? {
             return Ok(false)
+        }
         // Check the argument types
         for param_id in &definition.parameters {
             let param = &ctx.heap[*param_id];
             let resolve_result = self.resolve_base_parser_type(
                 ctx, &definition.poly_vars, root_id, param.parser_type
             )?;
             if !self.ingest_resolve_result(ctx, resolve_result)? {
                 return Ok(false)
+            }
+        }
         // Construct arguments to function
         let mut arguments = Vec::with_capacity(definition.parameters.len());
         for param_id in &definition.parameters {
             let param = &ctx.heap[*param_id];
             arguments.push(FunctionArgument{
                 identifier: param.identifier.clone(),
                 parser_type: param.parser_type,
             })
+        }
         // Check conflict of argument and polyarg identifiers
         self.check_identifier_collision(
             ctx, root_id, &arguments, |arg| &arg.identifier, "function argument"
         )?;
         self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;
         // Construct polymorphic arguments
         let mut poly_args = self.create_initial_poly_args(&definition.poly_vars);
         self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, definition.return_type)?;
         let return_type_id = definition.return_type;
         self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, return_type_id)?;
         for argument in &arguments {
             self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, argument.parser_type)?;
+        }
         let is_polymorph = poly_args.iter().any(|arg| arg.is_in_use);
         // Construct entry in type table
         self.lookup.insert(definition_id, DefinedType{
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Function(FunctionType{
                 return_type,
                 arguments,
             }),
             poly_args,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic
             monomorphs: Vec::new(),
         });
         Ok(true)
+    }
     /// Resolves the basic component definition to an entry in the type table.
     /// It will not instantiate any monomorphized instancees of polymorphic
     /// component definitions.
     fn resolve_base_component_definition(&mut self, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result<bool, ParseError2> {
         debug_assert!(ctx.heap[definition_id].is_component());
         debug_assert!(!self.lookup.contains_key(&definition_id), "base component already resolved");
         let definition = ctx.heap[definition_id].as_component();
         let component_variant = definition.variant;
         // Check argument types
         for param_id in &definition.parameters {
             let param = &ctx.heap[*param_id];
             let resolve_result = self.resolve_base_parser_type(
                 ctx, &definition.poly_vars, root_id, param.parser_type
             )?;
             if !self.ingest_resolve_result(ctx, resolve_result)? {
                 return Ok(false)
+            }
+        }
         // Construct argument types
         let mut arguments = Vec::with_capacity(definition.parameters.len());
         for param_id in &definition.parameters {
             let param = &ctx.heap[*param_id];
             arguments.push(FunctionArgument{
                 identifier: param.identifier.clone(),
                 parser_type: param.parser_type
             })
+        }
         // Check conflict of argument and polyarg identifiers
         self.check_identifier_collision(
             ctx, root_id, &arguments, |arg| &arg.identifier, "component argument"
         )?;
         self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;
         // Construct polymorphic arguments
         let mut poly_args = self.create_initial_poly_args(&definition.poly_vars);
         for argument in &arguments {
             self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, argument.parser_type)?;
+        }
         let is_polymorph = poly_args.iter().any(|v| v.is_in_use);
         // Construct entry in type table
         self.lookup.insert(definition_id, DefinedType{
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Component(ComponentType{
                 variant: component_variant,
                 arguments,
             }),
             poly_args,
             is_polymorph,
             is_pointerlike: false, // TODO: @cyclic
             monomorphs: Vec::new(),
         });
         Ok(true)
+    }
     /// Takes a ResolveResult and returns `true` if the caller can happily
     /// continue resolving its current type, or `false` if the caller must break
     /// resolving the current type and exit to the outer resolving loop. In the
     /// latter case the `result` value was `ResolveResult::Unresolved`, implying
     /// that the type must be resolved first.
     fn ingest_resolve_result(&mut self, ctx: &TypeCtx, result: ResolveResult) -> Result<bool, ParseError2> {
         match result {
             ResolveResult::BuiltIn | ResolveResult::PolyArg(_) => Ok(true),
             ResolveResult::Resolved(_) => Ok(true),
             ResolveResult::Unresolved((root_id, definition_id)) => {
                 if self.iter.contains(root_id, definition_id) {
                     // Cyclic dependency encountered
                     // TODO: Allow this

src/protocol/parser/visitor.rs

➞

Show inline comments

@@ @@ -41,204 +41,199 @@ pub(crate) trait Visitor2 { @@
                 root.definitions[def_index]
             };
             self.visit_definition(ctx, definition_id)?;
             def_index += 1;
+        }
+    }
     // Definitions
     // --- enum matching
     fn visit_definition(&mut self, ctx: &mut Ctx, id: DefinitionId) -> VisitorResult {
         match &ctx.heap[id] {
             Definition::Enum(def) => {
                 let def = def.this;
                 self.visit_enum_definition(ctx, def)
             },
             Definition::Struct(def) => {
                 let def = def.this;
                 self.visit_struct_definition(ctx, def)
             },
             Definition::Component(def) => {
                 let def = def.this;
                 self.visit_component_definition(ctx, def)
             },
             Definition::Function(def) => {
                 let def = def.this;
                 self.visit_function_definition(ctx, def)
+            }
+        }
+    }
     // --- enum variant handling
     fn visit_enum_definition(&mut self, _ctx: &mut Ctx, _id: EnumId) -> VisitorResult { Ok(()) }
     fn visit_struct_definition(&mut self, _ctx: &mut Ctx, _id: StructId) -> VisitorResult { Ok(()) }
     fn visit_component_definition(&mut self, _ctx: &mut Ctx, _id: ComponentId) -> VisitorResult { Ok(()) }
     fn visit_function_definition(&mut self, _ctx: &mut Ctx, _id: FunctionId) -> VisitorResult { Ok(()) }
     // Statements
     // --- enum matching
     fn visit_stmt(&mut self, ctx: &mut Ctx, id: StatementId) -> VisitorResult {
         match &ctx.heap[id] {
             Statement::Block(stmt) => {
                 let this = stmt.this;
                 self.visit_block_stmt(ctx, this)
             },
             Statement::Local(stmt) => {
                 let this = stmt.this();
                 self.visit_local_stmt(ctx, this)
             },
             Statement::Skip(stmt) => {
                 let this = stmt.this;
                 self.visit_skip_stmt(ctx, this)
             },
             Statement::Labeled(stmt) => {
                 let this = stmt.this;
                 self.visit_labeled_stmt(ctx, this)
             },
             Statement::If(stmt) => {
                 let this = stmt.this;
                 self.visit_if_stmt(ctx, this)
             },
             Statement::EndIf(_stmt) => Ok(()),
             Statement::While(stmt) => {
                 let this = stmt.this;
                 self.visit_while_stmt(ctx, this)
             },
             Statement::EndWhile(_stmt) => Ok(()),
             Statement::Break(stmt) => {
                 let this = stmt.this;
                 self.visit_break_stmt(ctx, this)
             },
             Statement::Continue(stmt) => {
                 let this = stmt.this;
                 self.visit_continue_stmt(ctx, this)
             },
             Statement::Synchronous(stmt) => {
                 let this = stmt.this;
                 self.visit_synchronous_stmt(ctx, this)
             },
             Statement::EndSynchronous(_stmt) => Ok(()),
             Statement::Return(stmt) => {
                 let this = stmt.this;
                 self.visit_return_stmt(ctx, this)
             },
             Statement::Assert(stmt) => {
                 let this = stmt.this;
                 self.visit_assert_stmt(ctx, this)
             },
             Statement::Goto(stmt) => {
                 let this = stmt.this;
                 self.visit_goto_stmt(ctx, this)
             },
             Statement::New(stmt) => {
                 let this = stmt.this;
                 self.visit_new_stmt(ctx, this)
             },
             Statement::Put(stmt) => {
                 let this = stmt.this;
                 self.visit_put_stmt(ctx, this)
             },
             Statement::Expression(stmt) => {
                 let this = stmt.this;
                 self.visit_expr_stmt(ctx, this)
+            }
+        }
+    }
     fn visit_local_stmt(&mut self, ctx: &mut Ctx, id: LocalStatementId) -> VisitorResult {
         match &ctx.heap[id] {
             LocalStatement::Channel(stmt) => {
                 let this = stmt.this;
                 self.visit_local_channel_stmt(ctx, this)
             },
             LocalStatement::Memory(stmt) => {
                 let this = stmt.this;
                 self.visit_local_memory_stmt(ctx, this)
             },
+        }
+    }
     // --- enum variant handling
     fn visit_block_stmt(&mut self, _ctx: &mut Ctx, _id: BlockStatementId) -> VisitorResult { Ok(()) }
     fn visit_local_memory_stmt(&mut self, _ctx: &mut Ctx, _id: MemoryStatementId) -> VisitorResult { Ok(()) }
     fn visit_local_channel_stmt(&mut self, _ctx: &mut Ctx, _id: ChannelStatementId) -> VisitorResult { Ok(()) }
     fn visit_skip_stmt(&mut self, _ctx: &mut Ctx, _id: SkipStatementId) -> VisitorResult { Ok(()) }
     fn visit_labeled_stmt(&mut self, _ctx: &mut Ctx, _id: LabeledStatementId) -> VisitorResult { Ok(()) }
     fn visit_if_stmt(&mut self, _ctx: &mut Ctx, _id: IfStatementId) -> VisitorResult { Ok(()) }
     fn visit_while_stmt(&mut self, _ctx: &mut Ctx, _id: WhileStatementId) -> VisitorResult { Ok(()) }
     fn visit_break_stmt(&mut self, _ctx: &mut Ctx, _id: BreakStatementId) -> VisitorResult { Ok(()) }
     fn visit_continue_stmt(&mut self, _ctx: &mut Ctx, _id: ContinueStatementId) -> VisitorResult { Ok(()) }
     fn visit_synchronous_stmt(&mut self, _ctx: &mut Ctx, _id: SynchronousStatementId) -> VisitorResult { Ok(()) }
     fn visit_return_stmt(&mut self, _ctx: &mut Ctx, _id: ReturnStatementId) -> VisitorResult { Ok(()) }
     fn visit_assert_stmt(&mut self, _ctx: &mut Ctx, _id: AssertStatementId) -> VisitorResult { Ok(()) }
     fn visit_goto_stmt(&mut self, _ctx: &mut Ctx, _id: GotoStatementId) -> VisitorResult { Ok(()) }
     fn visit_new_stmt(&mut self, _ctx: &mut Ctx, _id: NewStatementId) -> VisitorResult { Ok(()) }
     fn visit_put_stmt(&mut self, _ctx: &mut Ctx, _id: PutStatementId) -> VisitorResult { Ok(()) }
     fn visit_expr_stmt(&mut self, _ctx: &mut Ctx, _id: ExpressionStatementId) -> VisitorResult { Ok(()) }
     // Expressions
     // --- enum matching
     fn visit_expr(&mut self, ctx: &mut Ctx, id: ExpressionId) -> VisitorResult {
         match &ctx.heap[id] {
             Expression::Assignment(expr) => {
                 let this = expr.this;
                 self.visit_assignment_expr(ctx, this)
             },
             Expression::Conditional(expr) => {
                 let this = expr.this;
                 self.visit_conditional_expr(ctx, this)
+            }
             Expression::Binary(expr) => {
                 let this = expr.this;
                 self.visit_binary_expr(ctx, this)
+            }
             Expression::Unary(expr) => {
                 let this = expr.this;
                 self.visit_unary_expr(ctx, this)
+            }
             Expression::Indexing(expr) => {
                 let this = expr.this;
                 self.visit_indexing_expr(ctx, this)
+            }
             Expression::Slicing(expr) => {
                 let this = expr.this;
                 self.visit_slicing_expr(ctx, this)
+            }
             Expression::Select(expr) => {
                 let this = expr.this;
                 self.visit_select_expr(ctx, this)
+            }
             Expression::Array(expr) => {
                 let this = expr.this;
                 self.visit_array_expr(ctx, this)
+            }
             Expression::Constant(expr) => {
                 let this = expr.this;
                 self.visit_constant_expr(ctx, this)
+            }
             Expression::Call(expr) => {
                 let this = expr.this;
                 self.visit_call_expr(ctx, this)
+            }
             Expression::Variable(expr) => {
                 let this = expr.this;
                 self.visit_variable_expr(ctx, this)
+            }
+        }
+    }
     fn visit_assignment_expr(&mut self, _ctx: &mut Ctx, _id: AssignmentExpressionId) -> VisitorResult { Ok(()) }
     fn visit_conditional_expr(&mut self, _ctx: &mut Ctx, _id: ConditionalExpressionId) -> VisitorResult { Ok(()) }
     fn visit_binary_expr(&mut self, _ctx: &mut Ctx, _id: BinaryExpressionId) -> VisitorResult { Ok(()) }
     fn visit_unary_expr(&mut self, _ctx: &mut Ctx, _id: UnaryExpressionId) -> VisitorResult { Ok(()) }
     fn visit_indexing_expr(&mut self, _ctx: &mut Ctx, _id: IndexingExpressionId) -> VisitorResult { Ok(()) }
     fn visit_slicing_expr(&mut self, _ctx: &mut Ctx, _id: SlicingExpressionId) -> VisitorResult { Ok(()) }
     fn visit_select_expr(&mut self, _ctx: &mut Ctx, _id: SelectExpressionId) -> VisitorResult { Ok(()) }
     fn visit_array_expr(&mut self, _ctx: &mut Ctx, _id: ArrayExpressionId) -> VisitorResult { Ok(()) }
     fn visit_constant_expr(&mut self, _ctx: &mut Ctx, _id: ConstantExpressionId) -> VisitorResult { Ok(()) }
     fn visit_call_expr(&mut self, _ctx: &mut Ctx, _id: CallExpressionId) -> VisitorResult { Ok(()) }
     fn visit_variable_expr(&mut self, _ctx: &mut Ctx, _id: VariableExpressionId) -> VisitorResult { Ok(()) }
     // Types
     fn visit_parser_type(&mut self, _ctx: &mut Ctx, _id: ParserTypeId) -> VisitorResult { Ok(()) }
+}
@@ \ No newline at end of file @@

src/protocol/parser/visitor_linker.rs

➞

Show inline comments

@@ @@ -468,485 +468,487 @@ impl Visitor2 for ValidityAndLinkerVisitor { @@
                 // We can only goto the current scope or outer scopes. Because
                 // nested sync statements are not allowed so if the value does
                 // not match, then we must be inside a sync scope
                 debug_assert!(self.in_sync.is_some());
                 let goto_stmt = &ctx.heap[id];
                 let sync_stmt = &ctx.heap[self.in_sync.unwrap()];
                 return Err(
                     ParseError2::new_error(&ctx.module.source, goto_stmt.position, "Goto may not escape the surrounding synchronous block")
                         .with_postfixed_info(&ctx.module.source, target.position, "This is the target of the goto statement")
                         .with_postfixed_info(&ctx.module.source, sync_stmt.position, "Which will jump past this statement")
                 );
+            }
+        }
         Ok(())
+    }
     fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {
         // Link the call expression following the new statement
         if self.performing_breadth_pass {
             // TODO: Cleanup error messages, can be done cleaner
             // Make sure new statement occurs within a composite component
             let call_expr_id = ctx.heap[id].expression;
             if !self.def_type.is_composite() {
                 let new_stmt = &ctx.heap[id];
                 return Err(
                     ParseError2::new_error(&ctx.module.source, new_stmt.position, "Instantiating components may only be done in composite components")
                 );
+            }
             // No fancy recursive parsing, must be followed by a call expression
             let definition_id = {
                 let call_expr = &ctx.heap[call_expr_id];
                 if let Method::Symbolic(symbolic) = &call_expr.method {
                     let found_symbol = self.find_symbol_of_type(
                         ctx.module.root_id, &ctx.symbols, &ctx.types,
                         &symbolic.identifier, TypeClass::Component
                     );
                     match found_symbol {
                         FindOfTypeResult::Found(definition_id) => definition_id,
                         FindOfTypeResult::TypeMismatch(got_type_class) => {
                             return Err(ParseError2::new_error(
                                 &ctx.module.source, symbolic.identifier.position,
                                 &format!("New must instantiate a component, this identifier points to a {}", got_type_class)
                             ))
                         },
                         FindOfTypeResult::NotFound => {
                             return Err(ParseError2::new_error(
                                 &ctx.module.source, symbolic.identifier.position,
                                 "Could not find a defined component with this name"
                             ))
+                        }
+                    }
                 } else {
                     return Err(
                         ParseError2::new_error(&ctx.module.source, call_expr.position, "Must instantiate a component")
                     );
+                }
             };
             // Modify new statement's symbolic call to point to the appropriate
             // definition.
             let call_expr = &mut ctx.heap[call_expr_id];
             match &mut call_expr.method {
                 Method::Symbolic(method) => method.definition = Some(definition_id),
                 _ => unreachable!()
+            }
         } else {
             // Performing depth pass. The function definition should have been
             // resolved in the breadth pass, now we recurse to evaluate the
             // arguments
             // TODO: @cleanup Maybe just call `visit_call_expr`?
             let call_expr_id = ctx.heap[id].expression;
             let call_expr = &mut ctx.heap[call_expr_id];
             call_expr.parent = ExpressionParent::New(id);
             let old_num_exprs = self.expression_buffer.len();
             self.expression_buffer.extend(&call_expr.arguments);
             let new_num_exprs = self.expression_buffer.len();
             let old_expr_parent = self.expr_parent;
             for arg_expr_idx in old_num_exprs..new_num_exprs {
                 let arg_expr_id = self.expression_buffer[arg_expr_idx];
                 self.expr_parent = ExpressionParent::Expression(call_expr_id.upcast(), arg_expr_idx as u32);
                 self.visit_expr(ctx, arg_expr_id)?;
+            }
             self.expression_buffer.truncate(old_num_exprs);
             self.expr_parent = old_expr_parent;
+        }
         Ok(())
+    }
     fn visit_put_stmt(&mut self, ctx: &mut Ctx, id: PutStatementId) -> VisitorResult {
         // TODO: Make `put` an expression. Perhaps silly, but much easier to
         //  perform typechecking
         if self.performing_breadth_pass {
             let put_stmt = &ctx.heap[id];
             if self.in_sync.is_none() {
                 return Err(ParseError2::new_error(
                     &ctx.module.source, put_stmt.position, "Put must be called in a synchronous block"
                 ));
+            }
         } else {
             let put_stmt = &ctx.heap[id];
             let port = put_stmt.port;
             let message = put_stmt.message;
             debug_assert_eq!(self.expr_parent, ExpressionParent::None);
             self.expr_parent = ExpressionParent::Put(id, 0);
             self.visit_expr(ctx, port)?;
             self.expr_parent = ExpressionParent::Put(id, 1);
             self.visit_expr(ctx, message)?;
             self.expr_parent = ExpressionParent::None;
+        }
         Ok(())
+    }
     fn visit_expr_stmt(&mut self, ctx: &mut Ctx, id: ExpressionStatementId) -> VisitorResult {
         if !self.performing_breadth_pass {
             let expr_id = ctx.heap[id].expression;
             debug_assert_eq!(self.expr_parent, ExpressionParent::None);
             self.expr_parent = ExpressionParent::ExpressionStmt(id);
             self.visit_expr(ctx, expr_id)?;
             self.expr_parent = ExpressionParent::None;
+        }
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Expression visitors
     //--------------------------------------------------------------------------
     fn visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let upcast_id = id.upcast();
         let assignment_expr = &mut ctx.heap[id];
         let left_expr_id = assignment_expr.left;
         let right_expr_id = assignment_expr.right;
         let old_expr_parent = self.expr_parent;
         assignment_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, left_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, right_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let upcast_id = id.upcast();
         let conditional_expr = &mut ctx.heap[id];
         let test_expr_id = conditional_expr.test;
         let true_expr_id = conditional_expr.true_expression;
         let false_expr_id = conditional_expr.false_expression;
         let old_expr_parent = self.expr_parent;
         conditional_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, test_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, true_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 2);
         self.visit_expr(ctx, false_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let upcast_id = id.upcast();
         let binary_expr = &mut ctx.heap[id];
         let left_expr_id = binary_expr.left;
         let right_expr_id = binary_expr.right;
         let old_expr_parent = self.expr_parent;
         binary_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, left_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, right_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let unary_expr = &mut ctx.heap[id];
         let expr_id = unary_expr.expression;
         let old_expr_parent = self.expr_parent;
         unary_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(id.upcast(), 0);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let upcast_id = id.upcast();
         let indexing_expr = &mut ctx.heap[id];
         let subject_expr_id = indexing_expr.subject;
         let index_expr_id = indexing_expr.index;
         let old_expr_parent = self.expr_parent;
         indexing_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, subject_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, index_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let upcast_id = id.upcast();
         let slicing_expr = &mut ctx.heap[id];
         let subject_expr_id = slicing_expr.subject;
         let from_expr_id = slicing_expr.from_index;
         let to_expr_id = slicing_expr.to_index;
         let old_expr_parent = self.expr_parent;
         slicing_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, subject_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, from_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 2);
         self.visit_expr(ctx, to_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let select_expr = &mut ctx.heap[id];
         let expr_id = select_expr.subject;
         let old_expr_parent = self.expr_parent;
         select_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(id.upcast(), 0);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_array_expr(&mut self, ctx: &mut Ctx, id: ArrayExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let upcast_id = id.upcast();
         let array_expr = &mut ctx.heap[id];
         let old_num_exprs = self.expression_buffer.len();
         self.expression_buffer.extend(&array_expr.elements);
         let new_num_exprs = self.expression_buffer.len();
         let old_expr_parent = self.expr_parent;
         array_expr.parent = old_expr_parent;
         for field_expr_idx in old_num_exprs..new_num_exprs {
             let field_expr_id = self.expression_buffer[field_expr_idx];
             self.expr_parent = ExpressionParent::Expression(upcast_id, field_expr_idx as u32);
             self.visit_expr(ctx, field_expr_id)?;
+        }
         self.expression_buffer.truncate(old_num_exprs);
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_constant_expr(&mut self, ctx: &mut Ctx, id: ConstantExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let constant_expr = &mut ctx.heap[id];
         constant_expr.parent = self.expr_parent;
         Ok(())
+    }
     fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let call_expr = &mut ctx.heap[id];
         let num_expr_args = call_expr.arguments.len();
         // Resolve the method to the appropriate definition and check the
         // legality of the particular method call.
         // TODO: @cleanup Unify in some kind of signature call, see similar
         //  cleanup comments with this `match` format.
-        let num_args;
+        let num_definition_args;
         match &mut call_expr.method {
             Method::Create => {
-                num_args = 1;
+                num_definition_args = 1;
             },
             Method::Fires => {
                 if !self.def_type.is_primitive() {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'fires' may only occur in primitive component definitions"
                     ));
+                }
                 num_args = 1;
                 if self.in_sync.is_none() {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'fires' may only occur inside synchronous blocks"
                     ));
+                }
                 num_definition_args = 1;
             },
             Method::Get => {
                 if !self.def_type.is_primitive() {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'get' may only occur in primitive component definitions"
                     ));
+                }
                 num_args = 1;
                 if self.in_sync.is_none() {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'get' may only occur inside synchronous blocks"
                     ));
+                }
                 num_definition_args = 1;
             },
             Method::Put => {
                 if !self.def_type.is_primitive() {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'put' may only occur in primitive component definitions"
                     ));
+                }
                 if self.in_sync.is_none() {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'put' may only occur inside synchronous blocks"
                     ));
+                }
                 num_definition_args = 2;
+            }
             Method::Symbolic(symbolic) => {
                 // Find symbolic method
                 let found_symbol = self.find_symbol_of_type(
                     ctx.module.root_id, &ctx.symbols, &ctx.types,
                     &symbolic.identifier, TypeClass::Function
                 );
                 let definition_id = match found_symbol {
                     FindOfTypeResult::Found(definition_id) => definition_id,
                     FindOfTypeResult::TypeMismatch(got_type_class) => {
                         return Err(ParseError2::new_error(
                             &ctx.module.source, symbolic.identifier.position,
                             &format!("Only functions can be called, this identifier points to a {}", got_type_class)
                         ))
                     },
                     FindOfTypeResult::NotFound => {
                         return Err(ParseError2::new_error(
                             &ctx.module.source, symbolic.identifier.position,
                             &format!("Could not find a function with this name")
                         ))
+                    }
                 };
                 symbolic.definition = Some(definition_id);
                 match ctx.types.get_base_definition(&definition_id).unwrap() {
                     Definition::Function(definition) => {
                         num_args = definition.parameters.len();
                 match &ctx.types.get_base_definition(&definition_id).unwrap().definition {
                     DefinedTypeVariant::Function(definition) => {
                         num_definition_args = definition.arguments.len();
                     },
                     _ => unreachable!(),
+                }
+            }
+        }
         // Check the poly args and the number of variables in the call
         // expression
         self.visit_call_poly_args(ctx, id)?;
         if call_expr.arguments.len() != num_args {
         let call_expr = &mut ctx.heap[id];
         if num_expr_args != num_definition_args {
             return Err(ParseError2::new_error(
                 &ctx.module.source, call_expr.position,
                 &format!(
                     "This call expects {} arguments, but {} were provided",
-                    num_args, call_expr.arguments.len()
+                    num_definition_args, num_expr_args
+                )
             ));
+        }
         // Recurse into all of the arguments and set the expression's parent
         let call_expr = &mut ctx.heap[id];
         let upcast_id = id.upcast();
         let old_num_exprs = self.expression_buffer.len();
         self.expression_buffer.extend(&call_expr.arguments);
         let new_num_exprs = self.expression_buffer.len();
         let old_expr_parent = self.expr_parent;
         call_expr.parent = old_expr_parent;
         for arg_expr_idx in old_num_exprs..new_num_exprs {
             let arg_expr_id = self.expression_buffer[arg_expr_idx];
             self.expr_parent = ExpressionParent::Expression(upcast_id, arg_expr_idx as u32);
             self.visit_expr(ctx, arg_expr_id)?;
+        }
         self.expression_buffer.truncate(old_num_exprs);
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let var_expr = &ctx.heap[id];
         let variable_id = self.find_variable(ctx, self.relative_pos_in_block, &var_expr.identifier)?;
         let var_expr = &mut ctx.heap[id];
         var_expr.declaration = Some(variable_id);
         var_expr.parent = self.expr_parent;
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // ParserType visitors
     //--------------------------------------------------------------------------
     fn visit_parser_type(&mut self, ctx: &mut Ctx, id: ParserTypeId) -> VisitorResult {
         let old_num_types = self.parser_type_buffer.len();
         match self.visit_parser_type_without_buffer_cleanup(ctx, id) {
             Ok(_) => {
                 debug_assert_eq!(self.parser_type_buffer.len(), old_num_types);
                 Ok(())
             },
             Err(err) => {
                 self.parser_type_buffer.truncate(old_num_types);
                 Err(err)
+            }
+        }
+    }
+}
 enum FindOfTypeResult {
     // Identifier was exactly matched, type matched as well
     Found(DefinitionId),
     // Identifier was matched, but the type differs from the expected one
     TypeMismatch(&'static str),
     // Identifier could not be found
     NotFound,
+}
 impl ValidityAndLinkerVisitor {
     //--------------------------------------------------------------------------
     // Special traversal
     //--------------------------------------------------------------------------
     /// Will visit a statement with a hint about its wrapping statement. This is
     /// used to distinguish block statements with a wrapping synchronous
     /// statement from normal block statements.
     fn visit_stmt_with_hint(&mut self, ctx: &mut Ctx, id: StatementId, hint: Option<SynchronousStatementId>) -> VisitorResult {
         if let Statement::Block(block_stmt) = &ctx.heap[id] {
             let block_id = block_stmt.this;
             self.visit_block_stmt_with_hint(ctx, block_id, hint)
         } else {
             self.visit_stmt(ctx, id)
+        }
+    }
     fn visit_block_stmt_with_hint(&mut self, ctx: &mut Ctx, id: BlockStatementId, hint: Option<SynchronousStatementId>) -> VisitorResult {
         if self.performing_breadth_pass {
             // Performing a breadth pass, so don't traverse into the statements
             // of the block.
             return Ok(())
+        }
         // Set parent scope and relative position in the parent scope. Remember
         // these values to set them back to the old values when we're done with
         // the traversal of the block's statements.
         let body = &mut ctx.heap[id];
         body.parent_scope = self.cur_scope.clone();
         body.relative_pos_in_parent = self.relative_pos_in_block;
         let old_scope = self.cur_scope.replace(match hint {
             Some(sync_id) => Scope::Synchronous((sync_id, id)),
             None => Scope::Regular(id),
         });
@@ @@ -1385,151 +1387,154 @@ impl ValidityAndLinkerVisitor { @@
     fn has_parent_while_scope(&self, ctx: &Ctx, id: WhileStatementId) -> bool {
         debug_assert!(self.cur_scope.is_some());
         let mut scope = self.cur_scope.as_ref().unwrap();
         let while_stmt = &ctx.heap[id];
         loop {
             debug_assert!(scope.is_block());
             let block = scope.to_block();
             if while_stmt.body == block.upcast() {
                 return true;
+            }
             let block = &ctx.heap[block];
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();
             if !scope.is_block() {
                 return false;
+            }
+        }
+    }
     /// This function should be called while dealing with break/continue
     /// statements. It will try to find the targeted while statement, using the
     /// target label if provided. If a valid target is found then the loop's
     /// ID will be returned, otherwise a parsing error is constructed.
     /// The provided input position should be the position of the break/continue
     /// statement.
     fn resolve_break_or_continue_target(&self, ctx: &Ctx, position: InputPosition, label: &Option<Identifier>) -> Result<WhileStatementId, ParseError2> {
         let target = match label {
             Some(label) => {
                 let target_id = self.find_label(ctx, label)?;
                 // Make sure break target is a while statement
                 let target = &ctx.heap[target_id];
                 if let Statement::While(target_stmt) = &ctx.heap[target.body] {
                     // Even though we have a target while statement, the break might not be
                     // present underneath this particular labeled while statement
                     if !self.has_parent_while_scope(ctx, target_stmt.this) {
                         ParseError2::new_error(&ctx.module.source, label.position, "Break statement is not nested under the target label's while statement")
                             .with_postfixed_info(&ctx.module.source, target.position, "The targeted label is found here");
+                    }
                     target_stmt.this
                 } else {
                     return Err(
                         ParseError2::new_error(&ctx.module.source, label.position, "Incorrect break target label, it must target a while loop")
                             .with_postfixed_info(&ctx.module.source, target.position, "The targeted label is found here")
                     );
+                }
             },
             None => {
                 // Use the enclosing while statement, the break must be
                 // nested within that while statement
                 if self.in_while.is_none() {
                     return Err(
                         ParseError2::new_error(&ctx.module.source, position, "Break statement is not nested under a while loop")
                     );
+                }
                 self.in_while.unwrap()
+            }
         };
         // We have a valid target for the break statement. But we need to
         // make sure we will not break out of a synchronous block
+        {
             let target_while = &ctx.heap[target];
             if target_while.in_sync != self.in_sync {
                 // Break is nested under while statement, so can only escape a
                 // sync block if the sync is nested inside the while statement.
                 debug_assert!(self.in_sync.is_some());
                 let sync_stmt = &ctx.heap[self.in_sync.unwrap()];
                 return Err(
                     ParseError2::new_error(&ctx.module.source, position, "Break may not escape the surrounding synchronous block")
                         .with_postfixed_info(&ctx.module.source, target_while.position, "The break escapes out of this loop")
                         .with_postfixed_info(&ctx.module.source, sync_stmt.position, "And would therefore escape this synchronous block")
                 );
+            }
+        }
         Ok(target)
+    }
     fn visit_call_poly_args(&mut self, ctx: &mut Ctx, call_id: CallExpressionId) -> VisitorResult {
         let call_expr = &ctx.heap[call_id];
         // Determine the polyarg signature
         let num_expected_poly_args = match &call_expr.method {
             Method::Create => {
             },
             Method::Fires => {
             },
             Method::Get => {
             },
             Method::Put => {
+            }
             Method::Symbolic(symbolic) => {
                 let definition = &ctx.heap[symbolic.definition.unwrap()];
                 if let Definition::Function(definition) = definition {
                     definition.poly_vars.len()
                 } else {
                     debug_assert!(false, "expected function while visiting call poly args");
                     unreachable!();
+                }
+            }
         };
         // We allow zero polyargs to imply all args are inferred. Otherwise the
         // number of arguments must be equal
         if call_expr.poly_args.is_empty() {
             if num_expected_poly_args != 0 {
                 // Infer all polyargs
                 // TODO: @cleanup Not nice to use method position as implicitly
                 //  inferred parser type pos.
                 let pos = call_expr.position();
                 for _ in 0..num_expected_poly_args {
                     self.parser_type_buffer.push(ctx.heap.alloc_parser_type(|this| ParserType {
                         this,
                         pos,
                         variant: ParserTypeVariant::Inferred,
                     }));
+                }
                 let call_expr = &mut ctx.heap[call_id];
                 call_expr.poly_args.reserve(num_expected_poly_args);
                 for _ in 0..num_expected_poly_args {
                     call_expr.poly_args.push(self.parser_type_buffer.pop().unwrap());
+                }
+            }
             Ok(())
         } else if call_expr.poly_args.len() == num_expected_poly_args {
             // Number of args is not 0, so parse all the specified ParserTypes
             let old_num_types = self.parser_type_buffer.len();
             self.parser_type_buffer.extend(&call_expr.poly_args);
             while self.parser_type_buffer.len() > old_num_types {
                 let parser_type_id = self.parser_type_buffer.pop().unwrap();
                 self.visit_parser_type(ctx, parser_type_id);
+            }
             self.parser_type_buffer.truncate(old_num_types);
             Ok(())
         } else {
             return Err(ParseError2::new_error(
                 &ctx.module.source, call_expr.position,
                 &format!(
                     "Expected {} polymorphic arguments (or none, to infer them), but {} were specified",
                     num_expected_poly_args, call_expr.poly_args.len()
+                )
             ));
+        }
+    }
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)