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

Changeset - 1f0d50fa632f

Parent rev.

Child rev.

[Not reviewed]

0 5 0

MH - 4 years ago 2021-03-07 15:51:23
henger@cwi.nl

first pass on arena/index refactoring

5 files changed with 183 insertions and 181 deletions:

src/protocol/ast.rs

112

110

src/protocol/ast_printer.rs

src/protocol/parser/symbol_table.rs

src/protocol/parser/type_table.rs

src/protocol/parser/visitor_linker.rs

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

 use std::fmt;
 use std::fmt::{Debug, Display, Formatter};
 use std::ops::{Index, IndexMut};
 use super::arena::{Arena, Id};
 // use super::containers::StringAllocator;
 // TODO: @cleanup, transform wrapping types into type aliases where possible
 use crate::protocol::inputsource::*;
 /// Helper macro that defines a type alias for a AST element ID. In this case
 /// only used to alias the `Id<T>` types.
 macro_rules! define_aliased_ast_id {
     ($name:ident, $parent:ty) => {
         type $name = $parent;
+        pub type $name = $parent;
+    }
+}
 /// Helper macro that defines a subtype for a particular variant of an AST
 /// element ID.
 macro_rules! define_new_ast_id {
     ($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
+            }
+        }
     };
+}
 define_aliased_ast_id!(RootId, Id<Root>);
 define_aliased_ast_id!(PragmaId, Id<Pragma>);
 define_aliased_ast_id!(ImportId, Id<Import>);
 define_aliased_ast_id!(TypeAnnotationId, Id<TypeAnnotation>);
 define_aliased_ast_id!(VariableId, Id<Variable>);
 define_new_ast_id!(ParameterId, VariableId);
 define_new_ast_id!(LocalId, VariableId);
 define_aliased_ast_id!(DefinitionId, Id<Definition>);
 define_new_ast_id!(StructId, DefinitionId);
 define_new_ast_id!(EnumId, DefinitionId);
 define_new_ast_id!(ComponentId, DefinitionId);
 define_new_ast_id!(FunctionId, DefinitionId);
 define_aliased_ast_id!(StatementId, Id<Statement>);
 define_new_ast_id!(BlockStatementId, StatementId);
 define_new_ast_id!(LocalStatementId, StatementId);
 define_new_ast_id!(MemoryStatementId, LocalStatementId);
 define_new_ast_id!(ChannelStatementId, LocalStatementId);
 define_new_ast_id!(SkipStatementId, StatementId);
 define_new_ast_id!(LabeledStatementId, StatementId);
 define_new_ast_id!(IfStatementId, StatementId);
 define_new_ast_id!(EndIfStatementId, StatementId);
 define_new_ast_id!(WhileStatementId, StatementId);
 define_new_ast_id!(EndWhileStatementId, StatementId);
 define_new_ast_id!(BreakStatementId, StatementId);
 define_new_ast_id!(ContinueStatementId, StatementId);
 define_new_ast_id!(SynchronousStatementId, StatementId);
 define_new_ast_id!(EndSynchronousStatementId, StatementId);
 define_new_ast_id!(ReturnStatementId, StatementId);
 define_new_ast_id!(AssertStatementId, StatementId);
 define_new_ast_id!(GotoStatementId, StatementId);
 define_new_ast_id!(NewStatementId, StatementId);
 define_new_ast_id!(PutStatementId, StatementId);
 define_new_ast_id!(ExpressionStatementId, StatementId);
 define_aliased_ast_id!(ExpressionId, Id<Expression>);
 define_new_ast_id!(AssignmentExpressionId, ExpressionId);
 define_new_ast_id!(ConditionalExpressionId, ExpressionId);
 define_new_ast_id!(BinaryExpressionId, ExpressionId);
 define_new_ast_id!(UnaryExpressionId, ExpressionId);
 define_new_ast_id!(IndexingExpressionId, ExpressionId);
 define_new_ast_id!(SlicingExpressionId, ExpressionId);
 define_new_ast_id!(SelectExpressionId, ExpressionId);
 define_new_ast_id!(ArrayExpressionId, ExpressionId);
 define_new_ast_id!(ConstantExpressionId, ExpressionId);
 define_new_ast_id!(CallExpressionId, ExpressionId);
 define_new_ast_id!(VariableExpressionId, ExpressionId);
-define_new_ast_id!(DeclarationId, ExpressionId); // TODO: @cleanup
+define_aliased_ast_id!(DeclarationId, Id<Declaration>); // TODO: @cleanup
 define_new_ast_id!(DefinedDeclarationId, DeclarationId);
 define_new_ast_id!(ImportedDeclarationId, DeclarationId);
 // TODO: @cleanup - pub qualifiers can be removed once done
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 pub struct Heap {
     // Allocators
     // #[serde(skip)] string_alloc: StringAllocator,
     // 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) type_annotations: Arena<TypeAnnotation>,
     pub(crate) variables: Arena<Variable>,
     pub(crate) definitions: Arena<Definition>,
     pub(crate) statements: Arena<Statement>,
     pub(crate) expressions: Arena<Expression>,
     declarations: Arena<Declaration>,
+}
 impl Heap {
     pub fn new() -> Heap {
         Heap {
             // string_alloc: StringAllocator::new(),
             protocol_descriptions: Arena::new(),
             pragmas: Arena::new(),
             imports: Arena::new(),
             identifiers: Arena::new(),
             type_annotations: Arena::new(),
             variables: Arena::new(),
             definitions: Arena::new(),
             statements: Arena::new(),
             expressions: Arena::new(),
             declarations: Arena::new(),
+        }
+    }
     pub fn alloc_type_annotation(
         &mut self,
         f: impl FnOnce(TypeAnnotationId) -> TypeAnnotation,
     ) -> TypeAnnotationId {
         self.type_annotations.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,
     ) -> UnaryExpressionId {
         UnaryExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Unary(f(UnaryExpressionId(id)))),
+        )
+    }
     pub fn alloc_slicing_expression(
         &mut self,
         f: impl FnOnce(SlicingExpressionId) -> SlicingExpression,
     ) -> SlicingExpressionId {
         SlicingExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Slicing(f(SlicingExpressionId(id)))),
+        )
+    }
     pub fn alloc_indexing_expression(
         &mut self,
         f: impl FnOnce(IndexingExpressionId) -> IndexingExpression,
     ) -> IndexingExpressionId {
         IndexingExpressionId(
             self.expressions.alloc_with_id(|id| {
                 Expression::Indexing(f(IndexingExpressionId(id)))
             }),
+        )
+    }
     pub fn alloc_select_expression(
         &mut self,
         f: impl FnOnce(SelectExpressionId) -> SelectExpression,
     ) -> SelectExpressionId {
         SelectExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Select(f(SelectExpressionId(id)))),
+        )
+    }
     pub fn alloc_array_expression(
         &mut self,
         f: impl FnOnce(ArrayExpressionId) -> ArrayExpression,
     ) -> ArrayExpressionId {
         ArrayExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Array(f(ArrayExpressionId(id)))),
+        )
+    }
     pub fn alloc_constant_expression(
         &mut self,
         f: impl FnOnce(ConstantExpressionId) -> ConstantExpression,
     ) -> ConstantExpressionId {
         ConstantExpressionId(
             self.expressions.alloc_with_id(|id| {
                 Expression::Constant(f(ConstantExpressionId(id)))
             }),
+        )
+    }
     pub fn alloc_call_expression(
         &mut self,
         f: impl FnOnce(CallExpressionId) -> CallExpression,
     ) -> CallExpressionId {
         CallExpressionId(
             self.expressions
                 .alloc_with_id(|id| Expression::Call(f(CallExpressionId(id)))),
+        )
+    }
     pub fn alloc_variable_expression(
         &mut self,
         f: impl FnOnce(VariableExpressionId) -> VariableExpression,
     ) -> VariableExpressionId {
         VariableExpressionId(
             self.expressions.alloc_with_id(|id| {
                 Expression::Variable(f(VariableExpressionId(id)))
             }),
+        )
+    }
     pub fn alloc_block_statement(
         &mut self,
         f: impl FnOnce(BlockStatementId) -> BlockStatement,
     ) -> BlockStatementId {
         BlockStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Block(f(BlockStatementId(id)))),
+        )
+    }
     pub fn alloc_memory_statement(
         &mut self,
         f: impl FnOnce(MemoryStatementId) -> MemoryStatement,
     ) -> MemoryStatementId {
         MemoryStatementId(LocalStatementId(self.statements.alloc_with_id(|id| {
             Statement::Local(LocalStatement::Memory(
                 f(MemoryStatementId(LocalStatementId(id)))
             ))
         })))
+    }
     pub fn alloc_channel_statement(
         &mut self,
         f: impl FnOnce(ChannelStatementId) -> ChannelStatement,
     ) -> ChannelStatementId {
         ChannelStatementId(LocalStatementId(self.statements.alloc_with_id(|id| {
             Statement::Local(LocalStatement::Channel(
                 f(ChannelStatementId(LocalStatementId(id)))
             ))
         })))
+    }
     pub fn alloc_skip_statement(
         &mut self,
         f: impl FnOnce(SkipStatementId) -> SkipStatement,
     ) -> SkipStatementId {
         SkipStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Skip(f(SkipStatementId(id)))),
+        )
+    }
     pub fn alloc_if_statement(
         &mut self,
         f: impl FnOnce(IfStatementId) -> IfStatement,
     ) -> IfStatementId {
         IfStatementId(
             self.statements.alloc_with_id(|id| Statement::If(f(IfStatementId(id)))),
+        )
+    }
     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(StatementId(self.statements.alloc_with_id(|id| {
             Statement::Synchronous(f(SynchronousStatementId(StatementId(id))))
         })))
         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(StatementId(self.statements.alloc_with_id(|id| {
             Statement::EndSynchronous(f(EndSynchronousStatementId(StatementId(id))))
         })))
         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(StatementId(
         ReturnStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Return(f(ReturnStatementId(StatementId(id))))),
         ))
                 .alloc_with_id(|id| Statement::Return(f(ReturnStatementId(id)))),
+        )
+    }
     pub fn alloc_assert_statement(
         &mut self,
         f: impl FnOnce(AssertStatementId) -> AssertStatement,
     ) -> AssertStatementId {
-        AssertStatementId(StatementId(
         AssertStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Assert(f(AssertStatementId(StatementId(id))))),
         ))
                 .alloc_with_id(|id| Statement::Assert(f(AssertStatementId(id)))),
+        )
+    }
     pub fn alloc_goto_statement(
         &mut self,
         f: impl FnOnce(GotoStatementId) -> GotoStatement,
     ) -> GotoStatementId {
-        GotoStatementId(StatementId(
         GotoStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Goto(f(GotoStatementId(StatementId(id))))),
         ))
                 .alloc_with_id(|id| Statement::Goto(f(GotoStatementId(id)))),
+        )
+    }
     pub fn alloc_new_statement(
         &mut self,
         f: impl FnOnce(NewStatementId) -> NewStatement,
     ) -> NewStatementId {
         NewStatementId(StatementId(
             self.statements.alloc_with_id(|id| Statement::New(f(NewStatementId(StatementId(id))))),
         ))
         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(StatementId(
             self.statements.alloc_with_id(|id| Statement::Put(f(PutStatementId(StatementId(id))))),
         ))
         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(StatementId(
         LabeledStatementId(
             self.statements
                 .alloc_with_id(|id| Statement::Labeled(f(LabeledStatementId(StatementId(id))))),
         ))
                 .alloc_with_id(|id| Statement::Labeled(f(LabeledStatementId(id)))),
+        )
+    }
     pub fn alloc_expression_statement(
         &mut self,
         f: impl FnOnce(ExpressionStatementId) -> ExpressionStatement,
     ) -> ExpressionStatementId {
-        ExpressionStatementId(StatementId(
         ExpressionStatementId(
             self.statements.alloc_with_id(|id| {
-                Statement::Expression(f(ExpressionStatementId(StatementId(id))))
                 Statement::Expression(f(ExpressionStatementId(id)))
             }),
-        ))
+        )
+    }
     pub fn alloc_struct_definition(&mut self, f: impl FnOnce(StructId) -> StructDefinition) -> StructId {
         StructId(DefinitionId(self.definitions.alloc_with_id(|id| {
             Definition::Struct(f(StructId(DefinitionId(id))))
         })))
         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(DefinitionId(self.definitions.alloc_with_id(|id| {
             Definition::Enum(f(EnumId(DefinitionId(id))))
         })))
         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(DefinitionId(self.definitions.alloc_with_id(|id| {
             Definition::Component(f(ComponentId(
                 DefinitionId(id),
             )))
         })))
         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(DefinitionId(
         FunctionId(
             self.definitions
                 .alloc_with_id(|id| Definition::Function(f(FunctionId(DefinitionId(id))))),
         ))
                 .alloc_with_id(|id| Definition::Function(f(FunctionId(id)))),
+        )
+    }
     pub fn alloc_pragma(&mut self, f: impl FnOnce(PragmaId) -> Pragma) -> PragmaId {
-        PragmaId(self.pragmas.alloc_with_id(|id| f(PragmaId(id))))
         self.pragmas.alloc_with_id(|id| f(id))
+    }
     pub fn alloc_import(&mut self, f: impl FnOnce(ImportId) -> Import) -> ImportId {
-        ImportId(self.imports.alloc_with_id(|id| f(ImportId(id))))
         self.imports.alloc_with_id(|id| f(id))
+    }
     pub fn alloc_protocol_description(&mut self, f: impl FnOnce(RootId) -> Root) -> RootId {
-        RootId(self.protocol_descriptions.alloc_with_id(|id| f(RootId(id))))
         self.protocol_descriptions.alloc_with_id(|id| f(id))
+    }
     pub fn alloc_imported_declaration(
         &mut self,
         f: impl FnOnce(ImportedDeclarationId) -> ImportedDeclaration,
     ) -> ImportedDeclarationId {
         ImportedDeclarationId(DeclarationId(self.declarations.alloc_with_id(|id| {
             Declaration::Imported(f(ImportedDeclarationId(DeclarationId(id))))
         })))
         ImportedDeclarationId(self.declarations.alloc_with_id(|id| {
             Declaration::Imported(f(ImportedDeclarationId(id)))
         }))
+    }
     pub fn alloc_defined_declaration(
         &mut self,
         f: impl FnOnce(DefinedDeclarationId) -> DefinedDeclaration,
     ) -> DefinedDeclarationId {
-        DefinedDeclarationId(DeclarationId(
         DefinedDeclarationId(
             self.declarations.alloc_with_id(|id| {
-                Declaration::Defined(f(DefinedDeclarationId(DeclarationId(id))))
                 Declaration::Defined(f(DefinedDeclarationId(id)))
             }),
-        ))
+        )
+    }
+}
 impl Index<RootId> for Heap {
     type Output = Root;
     fn index(&self, index: RootId) -> &Self::Output {
-        &self.protocol_descriptions[index.0]
         &self.protocol_descriptions[index]
+    }
+}
 impl IndexMut<RootId> for Heap {
     fn index_mut(&mut self, index: RootId) -> &mut Self::Output {
-        &mut self.protocol_descriptions[index.0]
         &mut self.protocol_descriptions[index]
+    }
+}
 impl Index<PragmaId> for Heap {
     type Output = Pragma;
     fn index(&self, index: PragmaId) -> &Self::Output {
-        &self.pragmas[index.0]
         &self.pragmas[index]
+    }
+}
 impl Index<ImportId> for Heap {
     type Output = Import;
     fn index(&self, index: ImportId) -> &Self::Output {
-        &self.imports[index.0]
         &self.imports[index]
+    }
+}
 impl IndexMut<ImportId> for Heap {
     fn index_mut(&mut self, index: ImportId) -> &mut Self::Output {
-        &mut self.imports[index.0]
         &mut self.imports[index]
+    }
+}
 impl Index<TypeAnnotationId> for Heap {
     type Output = TypeAnnotation;
     fn index(&self, index: TypeAnnotationId) -> &Self::Output {
-        &self.type_annotations[index.0]
         &self.type_annotations[index]
+    }
+}
 impl Index<VariableId> for Heap {
     type Output = Variable;
     fn index(&self, index: VariableId) -> &Self::Output {
-        &self.variables[index.0]
         &self.variables[index]
+    }
+}
 impl Index<ParameterId> for Heap {
     type Output = Parameter;
     fn index(&self, index: ParameterId) -> &Self::Output {
-        &self.variables[(index.0).0].as_parameter()
         &self.variables[index.0].as_parameter()
+    }
+}
 impl Index<LocalId> for Heap {
     type Output = Local;
     fn index(&self, index: LocalId) -> &Self::Output {
-        &self.variables[(index.0).0].as_local()
         &self.variables[index.0].as_local()
+    }
+}
 impl IndexMut<LocalId> for Heap {
     fn index_mut(&mut self, index: LocalId) -> &mut Self::Output {
-        self.variables[index.0.0].as_local_mut()
         self.variables[index.0].as_local_mut()
+    }
+}
 impl Index<DefinitionId> for Heap {
     type Output = Definition;
     fn index(&self, index: DefinitionId) -> &Self::Output {
-        &self.definitions[index.0]
         &self.definitions[index]
+    }
+}
 impl Index<ComponentId> for Heap {
     type Output = Component;
     fn index(&self, index: ComponentId) -> &Self::Output {
-        &self.definitions[(index.0).0].as_component()
         &self.definitions[index.0].as_component()
+    }
+}
 impl Index<FunctionId> for Heap {
     type Output = Function;
     fn index(&self, index: FunctionId) -> &Self::Output {
-        &self.definitions[(index.0).0].as_function()
         &self.definitions[index.0].as_function()
+    }
+}
 impl Index<StatementId> for Heap {
     type Output = Statement;
     fn index(&self, index: StatementId) -> &Self::Output {
-        &self.statements[index.0]
         &self.statements[index]
+    }
+}
 impl IndexMut<StatementId> for Heap {
     fn index_mut(&mut self, index: StatementId) -> &mut Self::Output {
-        &mut self.statements[index.0]
         &mut self.statements[index]
+    }
+}
 impl Index<BlockStatementId> for Heap {
     type Output = BlockStatement;
     fn index(&self, index: BlockStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_block()
         &self.statements[index.0].as_block()
+    }
+}
 impl IndexMut<BlockStatementId> for Heap {
     fn index_mut(&mut self, index: BlockStatementId) -> &mut Self::Output {
-        (&mut self.statements[(index.0).0]).as_block_mut()
         (&mut self.statements[index.0]).as_block_mut()
+    }
+}
 impl Index<LocalStatementId> for Heap {
     type Output = LocalStatement;
     fn index(&self, index: LocalStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_local()
         &self.statements[index.0].as_local()
+    }
+}
 impl Index<MemoryStatementId> for Heap {
     type Output = MemoryStatement;
     fn index(&self, index: MemoryStatementId) -> &Self::Output {
-        &self.statements[((index.0).0).0].as_memory()
         &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).0].as_channel()
         &self.statements[index.0.0].as_channel()
+    }
+}
 impl Index<SkipStatementId> for Heap {
     type Output = SkipStatement;
     fn index(&self, index: SkipStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_skip()
         &self.statements[index.0].as_skip()
+    }
+}
 impl Index<LabeledStatementId> for Heap {
     type Output = LabeledStatement;
     fn index(&self, index: LabeledStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_labeled()
         &self.statements[index.0].as_labeled()
+    }
+}
 impl IndexMut<LabeledStatementId> for Heap {
     fn index_mut(&mut self, index: LabeledStatementId) -> &mut Self::Output {
-        (&mut self.statements[(index.0).0]).as_labeled_mut()
         (&mut self.statements[index.0]).as_labeled_mut()
+    }
+}
 impl Index<IfStatementId> for Heap {
     type Output = IfStatement;
     fn index(&self, index: IfStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_if()
         &self.statements[index.0].as_if()
+    }
+}
 impl IndexMut<IfStatementId> for Heap {
     fn index_mut(&mut self, index: IfStatementId) -> &mut Self::Output {
-        self.statements[(index.0).0].as_if_mut()
         self.statements[index.0].as_if_mut()
+    }
+}
 impl Index<EndIfStatementId> for Heap {
     type Output = EndIfStatement;
     fn index(&self, index: EndIfStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_end_if()
         &self.statements[index.0].as_end_if()
+    }
+}
 impl Index<WhileStatementId> for Heap {
     type Output = WhileStatement;
     fn index(&self, index: WhileStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_while()
         &self.statements[index.0].as_while()
+    }
+}
 impl IndexMut<WhileStatementId> for Heap {
     fn index_mut(&mut self, index: WhileStatementId) -> &mut Self::Output {
-        (&mut self.statements[(index.0).0]).as_while_mut()
         (&mut self.statements[index.0]).as_while_mut()
+    }
+}
 impl Index<BreakStatementId> for Heap {
     type Output = BreakStatement;
     fn index(&self, index: BreakStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_break()
         &self.statements[index.0].as_break()
+    }
+}
 impl IndexMut<BreakStatementId> for Heap {
     fn index_mut(&mut self, index: BreakStatementId) -> &mut Self::Output {
-        (&mut self.statements[(index.0).0]).as_break_mut()
         (&mut self.statements[index.0]).as_break_mut()
+    }
+}
 impl Index<ContinueStatementId> for Heap {
     type Output = ContinueStatement;
     fn index(&self, index: ContinueStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_continue()
         &self.statements[index.0].as_continue()
+    }
+}
 impl IndexMut<ContinueStatementId> for Heap {
     fn index_mut(&mut self, index: ContinueStatementId) -> &mut Self::Output {
-        (&mut self.statements[(index.0).0]).as_continue_mut()
         (&mut self.statements[index.0]).as_continue_mut()
+    }
+}
 impl Index<SynchronousStatementId> for Heap {
     type Output = SynchronousStatement;
     fn index(&self, index: SynchronousStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_synchronous()
         &self.statements[index.0].as_synchronous()
+    }
+}
 impl IndexMut<SynchronousStatementId> for Heap {
     fn index_mut(&mut self, index: SynchronousStatementId) -> &mut Self::Output {
-        (&mut self.statements[(index.0).0]).as_synchronous_mut()
         (&mut self.statements[index.0]).as_synchronous_mut()
+    }
+}
 impl Index<EndSynchronousStatementId> for Heap {
     type Output = EndSynchronousStatement;
     fn index(&self, index: EndSynchronousStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_end_synchronous()
         &self.statements[index.0].as_end_synchronous()
+    }
+}
 impl Index<ReturnStatementId> for Heap {
     type Output = ReturnStatement;
     fn index(&self, index: ReturnStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_return()
         &self.statements[index.0].as_return()
+    }
+}
 impl Index<AssertStatementId> for Heap {
     type Output = AssertStatement;
     fn index(&self, index: AssertStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_assert()
         &self.statements[index.0].as_assert()
+    }
+}
 impl Index<GotoStatementId> for Heap {
     type Output = GotoStatement;
     fn index(&self, index: GotoStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_goto()
         &self.statements[index.0].as_goto()
+    }
+}
 impl IndexMut<GotoStatementId> for Heap {
     fn index_mut(&mut self, index: GotoStatementId) -> &mut Self::Output {
-        (&mut self.statements[(index.0).0]).as_goto_mut()
         (&mut self.statements[index.0]).as_goto_mut()
+    }
+}
 impl Index<NewStatementId> for Heap {
     type Output = NewStatement;
     fn index(&self, index: NewStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_new()
         &self.statements[index.0].as_new()
+    }
+}
 impl Index<PutStatementId> for Heap {
     type Output = PutStatement;
     fn index(&self, index: PutStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_put()
         &self.statements[index.0].as_put()
+    }
+}
 impl Index<ExpressionStatementId> for Heap {
     type Output = ExpressionStatement;
     fn index(&self, index: ExpressionStatementId) -> &Self::Output {
-        &self.statements[(index.0).0].as_expression()
         &self.statements[index.0].as_expression()
+    }
+}
 impl Index<ExpressionId> for Heap {
     type Output = Expression;
     fn index(&self, index: ExpressionId) -> &Self::Output {
-        &self.expressions[index.0]
         &self.expressions[index]
+    }
+}
 impl Index<AssignmentExpressionId> for Heap {
     type Output = AssignmentExpression;
     fn index(&self, index: AssignmentExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_assignment()
         &self.expressions[index.0].as_assignment()
+    }
+}
 impl Index<ConditionalExpressionId> for Heap {
     type Output = ConditionalExpression;
     fn index(&self, index: ConditionalExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_conditional()
         &self.expressions[index.0].as_conditional()
+    }
+}
 impl Index<BinaryExpressionId> for Heap {
     type Output = BinaryExpression;
     fn index(&self, index: BinaryExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_binary()
         &self.expressions[index.0].as_binary()
+    }
+}
 impl Index<UnaryExpressionId> for Heap {
     type Output = UnaryExpression;
     fn index(&self, index: UnaryExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_unary()
         &self.expressions[index.0].as_unary()
+    }
+}
 impl Index<IndexingExpressionId> for Heap {
     type Output = IndexingExpression;
     fn index(&self, index: IndexingExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_indexing()
         &self.expressions[index.0].as_indexing()
+    }
+}
 impl Index<SlicingExpressionId> for Heap {
     type Output = SlicingExpression;
     fn index(&self, index: SlicingExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_slicing()
         &self.expressions[index.0].as_slicing()
+    }
+}
 impl Index<SelectExpressionId> for Heap {
     type Output = SelectExpression;
     fn index(&self, index: SelectExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_select()
         &self.expressions[index.0].as_select()
+    }
+}
 impl Index<ArrayExpressionId> for Heap {
     type Output = ArrayExpression;
     fn index(&self, index: ArrayExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_array()
         &self.expressions[index.0].as_array()
+    }
+}
 impl Index<ConstantExpressionId> for Heap {
     type Output = ConstantExpression;
     fn index(&self, index: ConstantExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_constant()
         &self.expressions[index.0].as_constant()
+    }
+}
 impl Index<CallExpressionId> for Heap {
     type Output = CallExpression;
     fn index(&self, index: CallExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_call()
         &self.expressions[index.0].as_call()
+    }
+}
 impl IndexMut<CallExpressionId> for Heap {
     fn index_mut(&mut self, index: CallExpressionId) -> &mut Self::Output {
-        (&mut self.expressions[(index.0).0]).as_call_mut()
         (&mut self.expressions[index.0]).as_call_mut()
+    }
+}
 impl Index<VariableExpressionId> for Heap {
     type Output = VariableExpression;
     fn index(&self, index: VariableExpressionId) -> &Self::Output {
-        &self.expressions[(index.0).0].as_variable()
         &self.expressions[index.0].as_variable()
+    }
+}
 impl IndexMut<VariableExpressionId> for Heap {
     fn index_mut(&mut self, index: VariableExpressionId) -> &mut Self::Output {
-        (&mut self.expressions[(index.0).0]).as_variable_mut()
         (&mut self.expressions[index.0]).as_variable_mut()
+    }
+}
 impl Index<DeclarationId> for Heap {
     type Output = Declaration;
     fn index(&self, index: DeclarationId) -> &Self::Output {
-        &self.declarations[index.0]
         &self.declarations[index]
+    }
+}
 #[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>,
     // Pase 2: linker
     pub declarations: Vec<DeclarationId>,
+}
 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
+    }
     pub fn get_declaration(&self, h: &Heap, id: &Identifier) -> Option<DeclarationId> {
         for declaration_id in self.declarations.iter() {
             let declaration = &h[*declaration_id];
             if declaration.identifier().value == id.value {
                 return Some(*declaration_id);
+            }
+        }
         None
+    }
     pub fn get_declaration_namespaced(&self, h: &Heap, id: &NamespacedIdentifier) -> Option<DeclarationId> {
         for declaration_id in self.declarations.iter() {
             let declaration = &h[*declaration_id];
             // TODO: @fixme
             if declaration.identifier().value == id.value {
                 return Some(*declaration_id);
+            }
+        }
         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)
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PragmaVersion {
     pub this: PragmaId,
     // Phase 1: parser
     pub position: InputPosition,
     pub version: u64,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PragmaModule {
     pub this: PragmaId,
     // Phase 1: parser
     pub position: InputPosition,
     pub value: Vec<u8>,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PragmaOld {
     pub this: PragmaId,
     // Phase 1: parser
     pub position: InputPosition,
     pub value: Vec<u8>,
+}
 impl SyntaxElement for PragmaOld {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Import {
     Module(ImportModule),
     Symbols(ImportSymbols)
+}
 impl Import {
     pub(crate) fn as_module(&self) -> &ImportModule {
         match self {
             Import::Module(m) => m,
             _ => panic!("Unable to cast 'Import' to 'ImportModule'")
+        }
+    }
     pub(crate) fn as_symbols(&self) -> &ImportSymbols {
         match self {
             Import::Symbols(m) => m,
             _ => panic!("Unable to cast 'Import' to 'ImportSymbols'")
+        }
+    }
+}
 impl SyntaxElement for Import {
     fn position(&self) -> InputPosition {
         match self {
             Import::Module(m) => m.position,
             Import::Symbols(m) => m.position
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ImportModule {
     pub this: ImportId,
     // Phase 1: parser
     pub position: InputPosition,
     pub module_name: Vec<u8>,
     pub alias: Vec<u8>,
     // Phase 2: module resolving
     pub module_id: Option<RootId>,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct AliasedSymbol {
     // Phase 1: parser
     pub position: InputPosition,
     pub name: Vec<u8>,
     pub alias: Vec<u8>,
     // Phase 2: symbol resolving
     pub definition_id: Option<DefinitionId>,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ImportSymbols {
     pub this: ImportId,
     // Phase 1: parser
     pub position: InputPosition,
     pub module_name: Vec<u8>,
     // Phase 2: module resolving
     pub module_id: Option<RootId>,
     // Phase 1&2
     // if symbols is empty, then we implicitly import all symbols without any
     // aliases for them. If it is not empty, then symbols are explicitly
     // specified, and optionally given an alias.
     pub symbols: Vec<AliasedSymbol>,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Identifier {
     pub position: InputPosition,
     pub value: Vec<u8>
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct NamespacedIdentifier {
     pub position: InputPosition,
     pub num_namespaces: u8,
     pub value: Vec<u8>,
+}
 impl NamespacedIdentifier {
     pub(crate) fn iter(&self) -> NamespacedIdentifierIter {
         NamespacedIdentifierIter{
             value: &self.value,
             cur_offset: 0,
             num_returned: 0,
             num_total: self.num_namespaces
+        }
+    }
+}
 impl PartialEq for NamespacedIdentifier {
     fn eq(&self, other: &Self) -> bool {
         return self.value == other.value
+    }
+}
 impl Eq for NamespacedIdentifier{}
 // TODO: Just keep ref to NamespacedIdentifier
 pub(crate) struct NamespacedIdentifierIter<'a> {
     value: &'a Vec<u8>,
     cur_offset: usize,
     num_returned: u8,
     num_total: u8,
+}
 impl<'a> NamespacedIdentifierIter<'a> {
     pub(crate) fn num_returned(&self) -> u8 {
         return self.num_returned;
+    }
     pub(crate) fn num_remaining(&self) -> u8 {
         return self.num_total - self.num_returned
+    }
+}
 impl<'a> Iterator for NamespacedIdentifierIter<'a> {
     type Item = &'a [u8];
     fn next(&mut self) -> Option<Self::Item> {
         if self.cur_offset >= self.value.len() {
             debug_assert_eq!(self.num_returned, self.num_total);
             None
         } else {
             debug_assert!(self.num_returned < self.num_total);
             let start = self.cur_offset;
             let mut end = start;
             while end < self.value.len() - 1 {
                 if self.value[end] == b':' && self.value[end + 1] == b':' {
                     self.cur_offset = end + 2;
                     self.num_returned += 1;
                     return Some(&self.value[start..end]);
+                }
                 end += 1;
+            }
             // If NamespacedIdentifier is constructed properly, then we cannot
             // end with "::" in the value, so
             debug_assert!(end == 0 || (self.value[end - 1] != b':' && self.value[end] != b':'));
             debug_assert_eq!(self.num_returned + 1, self.num_total);
             self.cur_offset = self.value.len();
             self.num_returned += 1;
             return Some(&self.value[start..]);
+        }
+    }
+}
 impl Display for Identifier {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         // A source identifier is in ASCII range.
         write!(f, "{}", String::from_utf8_lossy(&self.value))
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum PrimitiveType {
     Input,
     Output,
     Message,
     Boolean,
     Byte,
     Short,
     Int,
     Long,
     Symbolic(PrimitiveSymbolic)
+}
 // TODO: @cleanup, remove PartialEq implementations
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PrimitiveSymbolic {
     // Phase 1: parser
     pub(crate) identifier: NamespacedIdentifier,
     // Phase 2: typing
     pub(crate) definition: Option<DefinitionId>
+}
 impl PartialEq for PrimitiveSymbolic {
     fn eq(&self, other: &Self) -> bool {
         self.identifier == other.identifier
+    }
+}
 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.0.index
                         id.index
                     )?;
                 } else {
                     write!(
                         f, "Symbolic({}, id: Unresolved)",
                         String::from_utf8_lossy(&data.identifier.value)
                     )?;
+                }
+            }
+        }
         if self.array {
             write!(f, "[]")
         } else {
             Ok(())
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct TypeAnnotation {
     pub this: TypeAnnotationId,
     // Phase 1: parser
     pub position: InputPosition,
     pub the_type: Type,
+}
 impl SyntaxElement for TypeAnnotation {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 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,
     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`"),
+        }
+    }
     pub fn as_local(&self) -> &Local {
         match self {
             Variable::Local(result) => result,
             _ => panic!("Unable to cast `Variable` to `Local`"),
+        }
+    }
     pub fn as_local_mut(&mut self) -> &mut Local {
         match self {
             Variable::Local(result) => result,
             _ => panic!("Unable to cast 'Variable' to 'Local'"),
+        }
+    }
     pub fn the_type<'b>(&self, h: &'b Heap) -> &'b Type {
         match self {
             Variable::Parameter(param) => &h[param.type_annotation].the_type,
             Variable::Local(local) => &h[local.type_annotation].the_type,
+        }
+    }
+}
 impl SyntaxElement for Variable {
     fn position(&self) -> InputPosition {
         match self {
             Variable::Parameter(decl) => decl.position(),
             Variable::Local(decl) => decl.position(),
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Parameter {
     pub this: ParameterId,
     // Phase 1: parser
     pub position: InputPosition,
     pub type_annotation: TypeAnnotationId,
     pub identifier: Identifier,
+}
 impl SyntaxElement for Parameter {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Local {
     pub this: LocalId,
     // Phase 1: parser
     pub position: InputPosition,
     pub type_annotation: TypeAnnotationId,
     pub identifier: Identifier,
     // Phase 2: linker
     pub relative_pos_in_block: u32,
+}
 impl SyntaxElement for Local {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Definition {
     Struct(StructDefinition),
     Enum(EnumDefinition),
     Component(Component),
     Function(Function),
+}
 impl Definition {
     pub fn is_struct(&self) -> bool {
         match self {
             Definition::Struct(_) => true,
             _ => false
+        }
+    }
     pub fn as_struct(&self) -> &StructDefinition {
         match self {
             Definition::Struct(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'StructDefinition'"),
+        }
+    }
     pub fn is_enum(&self) -> bool {
         match self {
             Definition::Enum(_) => true,
             _ => false,
+        }
+    }
     pub fn as_enum(&self) -> &EnumDefinition {
         match self {
             Definition::Enum(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'EnumDefinition'"),
+        }
+    }
     pub fn is_component(&self) -> bool {
         match self {
             Definition::Component(_) => true,
             _ => false,
+        }
+    }
     pub fn as_component(&self) -> &Component {
         match self {
             Definition::Component(result) => result,
             _ => panic!("Unable to cast `Definition` to `Component`"),
+        }
+    }
     pub fn as_function(&self) -> &Function {
         match self {
             Definition::Function(result) => result,
             _ => panic!("Unable to cast `Definition` to `Function`"),
+        }
+    }
     pub fn identifier(&self) -> &Identifier {
         match self {
             Definition::Struct(def) => &def.identifier,
             Definition::Enum(def) => &def.identifier,
             Definition::Component(com) => &com.identifier,
             Definition::Function(fun) => &fun.identifier,
+        }
+    }
     pub fn parameters(&self) -> &Vec<ParameterId> {
         // TODO: Fix this
         static EMPTY_VEC: Vec<ParameterId> = Vec::new();
         match self {
             Definition::Component(com) => &com.parameters,
             Definition::Function(fun) => &fun.parameters,
             _ => &EMPTY_VEC,
+        }
+    }
     pub fn body(&self) -> StatementId {
         // TODO: Fix this
         match self {
             Definition::Component(com) => com.body,
             Definition::Function(fun) => fun.body,
             _ => panic!("cannot retrieve body (for EnumDefinition or StructDefinition)")
+        }
+    }
+}
 impl SyntaxElement for Definition {
     fn position(&self) -> InputPosition {
         match self {
             Definition::Struct(def) => def.position,
             Definition::Enum(def) => def.position,
             Definition::Component(def) => def.position(),
             Definition::Function(def) => def.position(),
+        }
+    }
+}
 impl VariableScope for Definition {
     fn parent_scope(&self, _h: &Heap) -> Option<Scope> {
         None
+    }
     fn get_variable(&self, h: &Heap, id: &Identifier) -> Option<VariableId> {
         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 StructFieldDefinition {
     pub position: InputPosition,
     pub field: Identifier,
     pub the_type: TypeAnnotationId,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct StructDefinition {
     pub this: StructId,
     // Phase 1: parser
     pub position: InputPosition,
     pub identifier: Identifier,
     pub fields: Vec<StructFieldDefinition>
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq)]
 pub enum EnumVariantValue {
     None,
     Integer(i64),
     Type(TypeAnnotationId),
+}
 #[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 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 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: TypeAnnotationId,
     pub identifier: 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 Declaration {
     Defined(DefinedDeclaration),
     Imported(ImportedDeclaration),
+}
 impl Declaration {
     pub fn signature(&self) -> &Signature {
         match self {
             Declaration::Defined(decl) => &decl.signature,
             Declaration::Imported(decl) => &decl.signature,
+        }
+    }
     pub fn identifier(&self) -> &Identifier {
         self.signature().identifier()
+    }
     pub fn is_component(&self) -> bool {
         self.signature().is_component()
+    }
     pub fn is_function(&self) -> bool {
         self.signature().is_function()
+    }
     pub fn as_defined(&self) -> &DefinedDeclaration {
         match self {
             Declaration::Defined(result) => result,
             _ => panic!("Unable to cast `Declaration` to `DefinedDeclaration`"),
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct DefinedDeclaration {
     pub this: DefinedDeclarationId,
     // Phase 2: linker
     pub definition: DefinitionId,
     pub signature: Signature,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ImportedDeclaration {
     pub this: ImportedDeclarationId,
     // Phase 2: linker
     pub import: ImportId,
     pub signature: Signature,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Signature {
     Component(ComponentSignature),
     Function(FunctionSignature),
+}
 impl Signature {
     pub fn from_definition(h: &Heap, def: DefinitionId) -> Signature {
         // TODO: Fix this
         match &h[def] {
             Definition::Component(com) => Signature::Component(ComponentSignature {
                 identifier: com.identifier.clone(), // TODO: @fix
                 arity: Signature::convert_parameters(h, &com.parameters),
             }),
             Definition::Function(fun) => Signature::Function(FunctionSignature {
                 return_type: h[fun.return_type].the_type.clone(),
                 identifier: fun.identifier.clone(), // TODO: @fix
                 arity: Signature::convert_parameters(h, &fun.parameters),
             }),
             _ => panic!("cannot retrieve signature (for StructDefinition or EnumDefinition)")
+        }
+    }
     fn convert_parameters(h: &Heap, params: &Vec<ParameterId>) -> Vec<Type> {
         let mut result = Vec::new();
         for &param in params.iter() {
             result.push(h[h[param].type_annotation].the_type.clone());
+        }
         result
+    }
     fn identifier(&self) -> &Identifier {
         match self {
             Signature::Component(com) => &com.identifier,
             Signature::Function(fun) => &fun.identifier,
+        }
+    }
     pub fn is_component(&self) -> bool {
         match self {
             Signature::Component(_) => true,
             Signature::Function(_) => false,
+        }
+    }
     pub fn is_function(&self) -> bool {
         match self {
             Signature::Component(_) => false,
             Signature::Function(_) => true,
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ComponentSignature {
     pub identifier: Identifier,
     pub arity: Vec<Type>,
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct FunctionSignature {
     pub return_type: Type,
     pub identifier: Identifier,
     pub arity: Vec<Type>,
+}
 #[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.

src/protocol/ast_printer.rs

➞

Show inline comments

 use std::fmt::{Debug, Display, Write};
 use std::io::Write as IOWrite;
 use super::ast::*;
 use std::borrow::Borrow;
 const INDENT: usize = 2;
 const PREFIX_EMPTY: &'static str = "    ";
 const PREFIX_ROOT_ID: &'static str = "Root";
 const PREFIX_PRAGMA_ID: &'static str = "Prag";
 const PREFIX_IMPORT_ID: &'static str = "Imp ";
 const PREFIX_TYPE_ANNOT_ID: &'static str = "TyAn";
 const PREFIX_VARIABLE_ID: &'static str = "Var ";
 const PREFIX_PARAMETER_ID: &'static str = "Par ";
 const PREFIX_LOCAL_ID: &'static str = "Loc ";
 const PREFIX_DEFINITION_ID: &'static str = "Def ";
 const PREFIX_STRUCT_ID: &'static str = "DefS";
 const PREFIX_ENUM_ID: &'static str = "DefE";
 const PREFIX_COMPONENT_ID: &'static str = "DefC";
 const PREFIX_FUNCTION_ID: &'static str = "DefF";
 const PREFIX_STMT_ID: &'static str = "Stmt";
 const PREFIX_BLOCK_STMT_ID: &'static str = "SBl ";
 const PREFIX_LOCAL_STMT_ID: &'static str = "SLoc";
 const PREFIX_MEM_STMT_ID: &'static str = "SMem";
 const PREFIX_CHANNEL_STMT_ID: &'static str = "SCha";
 const PREFIX_SKIP_STMT_ID: &'static str = "SSki";
 const PREFIX_LABELED_STMT_ID: &'static str = "SLab";
 const PREFIX_IF_STMT_ID: &'static str = "SIf ";
 const PREFIX_ENDIF_STMT_ID: &'static str = "SEIf";
 const PREFIX_WHILE_STMT_ID: &'static str = "SWhi";
 const PREFIX_ENDWHILE_STMT_ID: &'static str = "SEWh";
 const PREFIX_BREAK_STMT_ID: &'static str = "SBre";
 const PREFIX_CONTINUE_STMT_ID: &'static str = "SCon";
 const PREFIX_SYNC_STMT_ID: &'static str = "SSyn";
 const PREFIX_ENDSYNC_STMT_ID: &'static str = "SESy";
 const PREFIX_RETURN_STMT_ID: &'static str = "SRet";
 const PREFIX_ASSERT_STMT_ID: &'static str = "SAsr";
 const PREFIX_GOTO_STMT_ID: &'static str = "SGot";
 const PREFIX_NEW_STMT_ID: &'static str = "SNew";
 const PREFIX_PUT_STMT_ID: &'static str = "SPut";
 const PREFIX_EXPR_STMT_ID: &'static str = "SExp";
 const PREFIX_ASSIGNMENT_EXPR_ID: &'static str = "EAsi";
 const PREFIX_CONDITIONAL_EXPR_ID: &'static str = "ECnd";
 const PREFIX_BINARY_EXPR_ID: &'static str = "EBin";
 const PREFIX_UNARY_EXPR_ID: &'static str = "EUna";
 const PREFIX_INDEXING_EXPR_ID: &'static str = "EIdx";
 const PREFIX_SLICING_EXPR_ID: &'static str = "ESli";
 const PREFIX_SELECT_EXPR_ID: &'static str = "ESel";
 const PREFIX_ARRAY_EXPR_ID: &'static str = "EArr";
 const PREFIX_CONST_EXPR_ID: &'static str = "ECns";
 const PREFIX_CALL_EXPR_ID: &'static str = "ECll";
 const PREFIX_VARIABLE_EXPR_ID: &'static str = "EVar";
 struct KV<'a> {
     buffer: &'a mut String,
     prefix: Option<(&'static str, u32)>,
     indent: usize,
     temp_key: &'a mut String,
     temp_val: &'a mut String,
+}
 impl<'a> KV<'a> {
     fn new(buffer: &'a mut String, temp_key: &'a mut String, temp_val: &'a mut String, indent: usize) -> Self {
         temp_key.clear();
         temp_val.clear();
         KV{
             buffer,
             prefix: None,
             indent,
             temp_key,
             temp_val
+        }
+    }
     fn with_id(mut self, prefix: &'static str, id: u32) -> Self {
         self.prefix = Some((prefix, id));
         self
+    }
     fn with_s_key(self, key: &str) -> Self {
         self.temp_key.push_str(key);
         self
+    }
     fn with_d_key<D: Display>(mut self, key: &D) -> Self {
         write!(&mut self.temp_key, "{}", key);
         self
+    }
     fn with_s_val(self, val: &str) -> Self {
         self.temp_val.push_str(val);
         self
+    }
     fn with_disp_val<D: Display>(mut self, val: &D) -> Self {
         write!(&mut self.temp_val, "{}", val);
         self
+    }
     fn with_debug_val<D: Debug>(mut self, val: &D) -> Self {
         write!(&mut self.temp_val, "{:?}", val);
         self
+    }
     fn with_ascii_val(self, val: &[u8]) -> Self {
         self.temp_val.write_str(&*String::from_utf8_lossy(val));
         self
+    }
     fn with_opt_disp_val<D: Display>(mut self, val: Option<&D>) -> Self {
         match val {
             Some(v) => { write!(&mut self.temp_val, "Some({})", v); },
             None => { self.temp_val.write_str("None"); }
+        }
         self
+    }
     fn with_opt_ascii_val(self, val: Option<&[u8]>) -> Self {
         match val {
             Some(v) => {
                 self.temp_val.write_str("Some(");
                 self.temp_val.write_str(&*String::from_utf8_lossy(v));
                 self.temp_val.write_char(')');
             },
             None => {
                 self.temp_val.write_str("None");
+            }
+        }
         self
+    }
     fn with_custom_val<F: Fn(&mut String)>(mut self, val_fn: F) -> Self {
         val_fn(&mut self.temp_val);
         self
+    }
+}
 impl<'a> Drop for KV<'a> {
     fn drop(&mut self) {
         // Prefix and indent
         if let Some((prefix, id)) = &self.prefix {
             write!(&mut self.buffer, "{}[{:04}] ", prefix, id);
         } else {
             write!(&mut self.buffer, "           ");
+        }
         for _ in 0..self.indent * INDENT {
             self.buffer.push(' ');
+        }
         // Leading dash
         self.buffer.write_str("- ");
         // Key and value
         self.buffer.write_str(self.temp_key);
         if self.temp_val.is_empty() {
             self.buffer.push(':');
         } else {
             self.buffer.push_str(": ");
             self.buffer.push_str(&self.temp_val);
+        }
         self.buffer.push('\n');
+    }
+}
 pub(crate) struct ASTWriter {
     buffer: String,
     temp1: String,
     temp2: String,
+}
 impl ASTWriter {
     pub(crate) fn new() -> Self {
         Self{
             buffer: String::with_capacity(4096),
             temp1: String::with_capacity(256),
             temp2: String::with_capacity(256),
+        }
+    }
     pub(crate) fn write_ast<W: IOWrite>(&mut self, w: &mut W, heap: &Heap) {
         for root_id in heap.protocol_descriptions.iter().map(|v| v.this) {
             self.write_module(heap, root_id);
             w.write_all(self.buffer.as_bytes()).expect("flush buffer");
             self.buffer.clear();
+        }
+    }
     //--------------------------------------------------------------------------
     // Top-level module writing
     //--------------------------------------------------------------------------
     fn write_module(&mut self, heap: &Heap, root_id: RootId) {
-        self.kv(0).with_id(PREFIX_ROOT_ID, root_id.0.index)
         self.kv(0).with_id(PREFIX_ROOT_ID, root_id.index)
             .with_s_key("Module");
         let root = &heap[root_id];
         self.kv(1).with_s_key("Pragmas");
         for pragma_id in &root.pragmas {
             self.write_pragma(heap, *pragma_id, 2);
+        }
         self.kv(1).with_s_key("Imports");
         for import_id in &root.imports {
             self.write_import(heap, *import_id, 2);
+        }
         self.kv(1).with_s_key("Definitions");
         for def_id in &root.definitions {
             self.write_definition(heap, *def_id, 2);
+        }
+    }
     fn write_pragma(&mut self, heap: &Heap, pragma_id: PragmaId, indent: usize) {
         match &heap[pragma_id] {
             Pragma::Version(pragma) => {
-                self.kv(indent).with_id(PREFIX_PRAGMA_ID, pragma.this.0.index)
                 self.kv(indent).with_id(PREFIX_PRAGMA_ID, pragma.this.index)
                     .with_s_key("PragmaVersion")
                     .with_disp_val(&pragma.version);
             },
             Pragma::Module(pragma) => {
-                self.kv(indent).with_id(PREFIX_PRAGMA_ID, pragma.this.0.index)
                 self.kv(indent).with_id(PREFIX_PRAGMA_ID, pragma.this.index)
                     .with_s_key("PragmaModule")
                     .with_ascii_val(&pragma.value);
+            }
+        }
+    }
     fn write_import(&mut self, heap: &Heap, import_id: ImportId, indent: usize) {
         let import = &heap[import_id];
         let indent2 = indent + 1;
         match import {
             Import::Module(import) => {
-                self.kv(indent).with_id(PREFIX_IMPORT_ID, import.this.0.index)
                 self.kv(indent).with_id(PREFIX_IMPORT_ID, import.this.index)
                     .with_s_key("ImportModule");
                 self.kv(indent2).with_s_key("Name").with_ascii_val(&import.module_name);
                 self.kv(indent2).with_s_key("Alias").with_ascii_val(&import.alias);
                 self.kv(indent2).with_s_key("Target")
-                    .with_opt_disp_val(import.module_id.as_ref().map(|v| &v.0.index));
                     .with_opt_disp_val(import.module_id.as_ref().map(|v| &v.index));
             },
             Import::Symbols(import) => {
-                self.kv(indent).with_id(PREFIX_IMPORT_ID, import.this.0.index)
                 self.kv(indent).with_id(PREFIX_IMPORT_ID, import.this.index)
                     .with_s_key("ImportSymbol");
                 self.kv(indent2).with_s_key("Name").with_ascii_val(&import.module_name);
                 self.kv(indent2).with_s_key("Target")
-                    .with_opt_disp_val(import.module_id.as_ref().map(|v| &v.0.index));
                     .with_opt_disp_val(import.module_id.as_ref().map(|v| &v.index));
                 self.kv(indent2).with_s_key("Symbols");
                 let indent3 = indent2 + 1;
                 let indent4 = indent3 + 1;
                 for symbol in &import.symbols {
                     self.kv(indent3).with_s_key("AliasedSymbol");
                     self.kv(indent4).with_s_key("Name").with_ascii_val(&symbol.name);
                     self.kv(indent4).with_s_key("Alias").with_ascii_val(&symbol.alias);
                     self.kv(indent4).with_s_key("Definition")
-                        .with_opt_disp_val(symbol.definition_id.as_ref().map(|v| &v.0.index));
                         .with_opt_disp_val(symbol.definition_id.as_ref().map(|v| &v.index));
+                }
+            }
+        }
+    }
     //--------------------------------------------------------------------------
     // Top-level definition writing
     //--------------------------------------------------------------------------
     fn write_definition(&mut self, heap: &Heap, def_id: DefinitionId, indent: usize) {
         let indent2 = indent + 1;
         let indent3 = indent2 + 1;
         let indent4 = indent3 + 1;
         match &heap[def_id] {
             Definition::Struct(_) => todo!("implement Definition::Struct"),
             Definition::Enum(_) => todo!("implement Definition::Enum"),
             Definition::Function(_) => todo!("implement Definition::Function"),
             Definition::Component(def) => {
-                self.kv(indent).with_id(PREFIX_COMPONENT_ID,def.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_COMPONENT_ID,def.this.0.index)
                     .with_s_key("DefinitionComponent");
                 self.kv(indent2).with_s_key("Name").with_ascii_val(&def.identifier.value);
                 self.kv(indent2).with_s_key("Variant").with_debug_val(&def.variant);
                 self.kv(indent2).with_s_key("Parameters");
                 for param_id in &def.parameters {
                     let param = &heap[*param_id];
-                    self.kv(indent3).with_id(PREFIX_PARAMETER_ID, param_id.0.0.index)
                     self.kv(indent3).with_id(PREFIX_PARAMETER_ID, param_id.0.index)
                         .with_s_key("Parameter");
                     self.kv(indent4).with_s_key("Name").with_ascii_val(&param.identifier.value);
                     self.kv(indent4).with_s_key("Type").with_custom_val(|w| write_type(w, &heap[param.type_annotation]));
+                }
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, def.body, indent3);
+            }
+        }
+    }
     fn write_stmt(&mut self, heap: &Heap, stmt_id: StatementId, indent: usize) {
         let stmt = &heap[stmt_id];
         let indent2 = indent + 1;
         let indent3 = indent2 + 1;
         match stmt {
             Statement::Block(stmt) => {
-                self.kv(indent).with_id(PREFIX_BLOCK_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_BLOCK_STMT_ID, stmt.this.0.index)
                     .with_s_key("Block");
                 for stmt_id in &stmt.statements {
                     self.write_stmt(heap, *stmt_id, indent2);
+                }
             },
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Channel(stmt) => {
-                        self.kv(indent).with_id(PREFIX_CHANNEL_STMT_ID, stmt.this.0.0.0.index)
                         self.kv(indent).with_id(PREFIX_CHANNEL_STMT_ID, stmt.this.0.0.index)
                             .with_s_key("LocalChannel");
                         self.kv(indent2).with_s_key("From");
                         self.write_local(heap, stmt.from, indent3);
                         self.kv(indent2).with_s_key("To");
                         self.write_local(heap, stmt.to, indent3);
                         self.kv(indent2).with_s_key("Next")
-                            .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.0.index));
                             .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
                     },
                     LocalStatement::Memory(stmt) => {
-                        self.kv(indent).with_id(PREFIX_MEM_STMT_ID, stmt.this.0.0.0.index)
                         self.kv(indent).with_id(PREFIX_MEM_STMT_ID, stmt.this.0.0.index)
                             .with_s_key("LocalMemory");
                         self.kv(indent2).with_s_key("Variable");
                         self.write_local(heap, stmt.variable, indent3);
                         self.kv(indent2).with_s_key("initial");
                         self.write_expr(heap, stmt.initial, indent3);
                         self.kv(indent2).with_s_key("Next")
-                            .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.0.index));
                             .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
+                    }
+                }
             },
             Statement::Skip(stmt) => {
-                self.kv(indent).with_id(PREFIX_SKIP_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_SKIP_STMT_ID, stmt.this.0.index)
                     .with_s_key("Skip");
                 self.kv(indent2).with_s_key("Next")
-                    .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.0.index));
                     .with_opt_disp_val(stmt.next.as_ref().map(|v| &v.index));
             },
             Statement::Labeled(stmt) => {
-                self.kv(indent).with_id(PREFIX_LABELED_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_LABELED_STMT_ID, stmt.this.0.index)
                     .with_s_key("Labeled");
                 self.kv(indent2).with_s_key("Label").with_ascii_val(&stmt.label.value);
                 self.kv(indent2).with_s_key("Statement");
                 self.write_stmt(heap, stmt.body, indent3);
             },
             Statement::If(stmt) => {
-                self.kv(indent).with_id(PREFIX_IF_STMT_ID, stmt.this.0.0.index)
                 self.kv(indent).with_id(PREFIX_IF_STMT_ID, stmt.this.0.index)
                     .with_s_key("If");
                 self.kv(indent2).with_s_key("EndIf")
-                    .with_opt_disp_val(stmt.end_if.as_ref().map(|v| &v.0.0.index));
                     .with_opt_disp_val(stmt.end_if.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("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.0.index)
                 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.0.index);
                 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.0.index));
                     .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.0.index)
                 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.0.index));
                     .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.0.index));
                     .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.0.index)
                 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.0.index);
                 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.0.index));
                     .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.0.index)
                 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.0.index));
                     .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.0.index)
                 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.0.index));
                     .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.0.index)
                 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.0.index));
                     .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.0.index)
                 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.0.index);
                 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.0.index));
                     .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.0.index)
                 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.0.index)
                 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.0.index));
                     .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.0.index)
                 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.0.index));
                     .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.0.index)
                 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.0.index));
                     .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.0.index)
                 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.0.index));
                     .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.0.index)
                 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.0.index));
                     .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.0.index)
                 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);
             },
             Expression::Conditional(expr) => {
-                self.kv(indent).with_id(PREFIX_CONDITIONAL_EXPR_ID, expr.this.0.0.index)
                 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);
             },
             Expression::Binary(expr) => {
-                self.kv(indent).with_id(PREFIX_BINARY_EXPR_ID, expr.this.0.0.index)
                 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);
             },
             Expression::Unary(expr) => {
-                self.kv(indent).with_id(PREFIX_UNARY_EXPR_ID, expr.this.0.0.index)
                 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);
             },
             Expression::Indexing(expr) => {
-                self.kv(indent).with_id(PREFIX_INDEXING_EXPR_ID, expr.this.0.0.index)
                 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);
             },
             Expression::Slicing(expr) => {
-                self.kv(indent).with_id(PREFIX_SLICING_EXPR_ID, expr.this.0.0.index)
                 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);
             },
             Expression::Select(expr) => {
-                self.kv(indent).with_id(PREFIX_SELECT_EXPR_ID, expr.this.0.0.index)
                 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);
+                    }
+                }
             },
             Expression::Array(expr) => {
-                self.kv(indent).with_id(PREFIX_ARRAY_EXPR_ID, expr.this.0.0.index)
                 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);
+                }
             },
             Expression::Constant(expr) => {
-                self.kv(indent).with_id(PREFIX_CONST_EXPR_ID, expr.this.0.0.index)
                 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); },
+                }
             },
             Expression::Call(expr) => {
-                self.kv(indent).with_id(PREFIX_CALL_EXPR_ID, expr.this.0.0.index)
                 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::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.0.index));
                             .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);
+                }
             },
             Expression::Variable(expr) => {
-                self.kv(indent).with_id(PREFIX_VARIABLE_EXPR_ID, expr.this.0.0.index)
                 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.0.index));
                     .with_opt_disp_val(expr.declaration.as_ref().map(|v| &v.index));
+            }
+        }
+    }
     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.0.index)
         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[local.type_annotation]));
+    }
     //--------------------------------------------------------------------------
     // 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, t: &TypeAnnotation) {
     match &t.the_type.primitive {
         PrimitiveType::Input => target.write_str("in"),
         PrimitiveType::Output => target.write_str("out"),
         PrimitiveType::Message => target.write_str("msg"),
         PrimitiveType::Boolean => target.write_str("bool"),
         PrimitiveType::Byte => target.write_str("byte"),
         PrimitiveType::Short => target.write_str("short"),
         PrimitiveType::Int => target.write_str("int"),
         PrimitiveType::Long => target.write_str("long"),
         PrimitiveType::Symbolic(symbolic) => {
             let mut temp = String::new();
-            write_option(&mut temp, symbolic.definition.map(|v| v.0.index));
             write_option(&mut temp, symbolic.definition.map(|v| v.index));
             write!(target, "Symbolic(name: {}, target: {})", String::from_utf8_lossy(&symbolic.identifier.value), &temp)
+        }
     };
     if t.the_type.array {
         target.push_str("[]");
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/symbol_table.rs

➞

Show inline comments

 // TODO: Maybe allow namespaced-aliased imports. It is currently not possible
 //  to express the following:
 //      import Module.Submodule as SubMod
 //      import SubMod::{Symbol}
 //  And it is especially not possible to express the following:
 //      import SubMod::{Symbol}
 //      import Module.Submodule as SubMod
 use crate::protocol::ast::*;
 use crate::protocol::inputsource::*;
 use std::collections::{HashMap, hash_map::Entry};
 use crate::protocol::parser::LexedModule;
 #[derive(PartialEq, Eq, Hash)]
 struct SymbolKey {
     module_id: RootId,
     symbol_name: Vec<u8>,
+}
 pub(crate) enum Symbol {
     Namespace(RootId),
     Definition((RootId, DefinitionId)),
+}
 pub(crate) struct SymbolValue {
     // Position refers to the origin of the symbol definition (i.e. the module's
     // RootId that is in the key being used to lookup this value)
     pub(crate) position: InputPosition,
     pub(crate) symbol: Symbol,
+}
 impl SymbolValue {
     pub(crate) fn is_namespace(&self) -> bool {
         match &self.symbol {
             Symbol::Namespace(_) => true,
             _ => false
+        }
+    }
     pub(crate) fn as_namespace(&self) -> Option<RootId> {
         match &self.symbol {
             Symbol::Namespace(root_id) => Some(*root_id),
             _ => None,
+        }
+    }
     pub(crate) fn as_definition(&self) -> Option<(RootId, DefinitionId)> {
         match &self.symbol {
             Symbol::Definition((root_id, definition_id)) => Some((*root_id, *definition_id)),
             _ => None,
+        }
+    }
+}
 /// `SymbolTable` is responsible for two parts of the parsing process: firstly
 /// it ensures that there are no clashing symbol definitions within each file,
 /// and secondly it will resolve all symbols within a module to their
 /// appropriate definitions (in case of enums, functions, etc.) and namespaces
 /// (currently only external modules can act as namespaces). If a symbol clashes
 /// or if a symbol cannot be resolved this will be an error.
 ///
 /// Within the compilation process the symbol table is responsible for resolving
 /// namespaced identifiers (e.g. Module::Enum::EnumVariant) to the appropriate
 /// definition (i.e. not namespaces; as the language has no way to use
 /// namespaces except for using them in namespaced identifiers).
 pub(crate) struct SymbolTable {
     // Lookup from module name (not any aliases) to the root id
     module_lookup: HashMap<Vec<u8>, RootId>,
     // Lookup from within a module, to a particular imported (potentially
     // aliased) or defined symbol. Basically speaking: if the source code of a
     // module contains correctly imported/defined symbols, then this lookup
     // will always return the corresponding definition
     symbol_lookup: HashMap<SymbolKey, SymbolValue>,
+}
 impl SymbolTable {
     pub(crate) fn new(heap: &Heap, modules: &[LexedModule]) -> Result<Self, ParseError2> {
         // Sanity check
         if cfg!(debug_assertions) {
             for (index, module) in modules.iter().enumerate() {
                 debug_assert_eq!(
-                    index, module.root_id.0.index as usize,
                     index, module.root_id.index as usize,
                     "module RootId does not correspond to LexedModule index"
+                )
+            }
+        }
         // Preparation: create a lookup from module name to root id. This does
         // not take aliasing into account.
         let mut module_lookup = HashMap::with_capacity(modules.len());
         for module in modules {
             // TODO: Maybe put duplicate module name checking here?
             // TODO: @string
             module_lookup.insert(module.module_name.clone(), module.root_id);
+        }
         // Preparation: determine total number of imports we will be inserting
         // into the lookup table. We could just iterate over the arena, but then
         // we don't know the source file the import belongs to.
         let mut lookup_reserve_size = 0;
         for module in modules {
             let module_root = &heap[module.root_id];
             for import_id in &module_root.imports {
                 match &heap[*import_id] {
                     Import::Module(_) => lookup_reserve_size += 1,
                     Import::Symbols(import) => {
                         if import.symbols.is_empty() {
                             // Add all symbols from the other module
                             match module_lookup.get(&import.module_name) {
                                 Some(target_module_id) => {
                                     lookup_reserve_size += heap[*target_module_id].definitions.len()
                                 },
                                 None => {
                                     return Err(
                                         ParseError2::new_error(&module.source, import.position, "Cannot resolve module")
                                     );
+                                }
+                            }
                         } else {
                             lookup_reserve_size += import.symbols.len();
+                        }
+                    }
+                }
+            }
             lookup_reserve_size += module_root.definitions.len();
+        }
         let mut table = Self{
             module_lookup,
             symbol_lookup: HashMap::with_capacity(lookup_reserve_size)
         };
         // First pass: we go through all of the modules and add lookups to
         // symbols that are defined within that module. Cross-module imports are
         // not yet resolved
         for module in modules {
             let root = &heap[module.root_id];
             for definition_id in &root.definitions {
                 let definition = &heap[*definition_id];
                 let identifier = definition.identifier();
                 if let Err(previous_position) = table.add_definition_symbol(
                     module.root_id, identifier.position, &identifier.value,
                     module.root_id, *definition_id
                 ) {
                     return Err(
                         ParseError2::new_error(&module.source, definition.position(), "Symbol is multiply defined")
                             .with_postfixed_info(&module.source, previous_position, "Previous definition was here")
+                    )
+                }
+            }
+        }
         // Second pass: now that we can find symbols in modules, we can resolve
         // all imports (if they're correct, that is)
         for module in modules {
             let root = &heap[module.root_id];
             for import_id in &root.imports {
                 let import = &heap[*import_id];
                 match import {
                     Import::Module(import) => {
                         // Find the module using its name
                         let target_root_id = table.resolve_module(&import.module_name);
                         if target_root_id.is_none() {
                             return Err(ParseError2::new_error(&module.source, import.position, "Could not resolve module"));
+                        }
                         let target_root_id = target_root_id.unwrap();
                         if target_root_id == module.root_id {
                             return Err(ParseError2::new_error(&module.source, import.position, "Illegal import of self"));
+                        }
                         // Add the target module under its alias
                         if let Err(previous_position) = table.add_namespace_symbol(
                             module.root_id, import.position,
                             &import.alias, target_root_id
                         ) {
                             return Err(
                                 ParseError2::new_error(&module.source, import.position, "Symbol is multiply defined")
                                     .with_postfixed_info(&module.source, previous_position, "Previous definition was here")
                             );
+                        }
                     },
                     Import::Symbols(import) => {
                         // Find the target module using its name
                         let target_root_id = table.resolve_module(&import.module_name);
                         if target_root_id.is_none() {
                             return Err(ParseError2::new_error(&module.source, import.position, "Could not resolve module of symbol imports"));
+                        }
                         let target_root_id = target_root_id.unwrap();
                         if target_root_id == module.root_id {
                             return Err(ParseError2::new_error(&module.source, import.position, "Illegal import of self"));
+                        }
                         // Determine which symbols to import
                         if import.symbols.is_empty() {
                             // Import of all symbols, not using any aliases
                             for definition_id in &heap[target_root_id].definitions {
                                 let definition = &heap[*definition_id];
                                 let identifier = definition.identifier();
                                 if let Err(previous_position) = table.add_definition_symbol(
                                     module.root_id, import.position, &identifier.value,
                                     target_root_id, *definition_id
                                 ) {
                                     return Err(
                                         ParseError2::new_error(
                                             &module.source, import.position,
                                             &format!("Imported symbol '{}' is already defined", String::from_utf8_lossy(&identifier.value))
+                                        )
                                         .with_postfixed_info(
-                                            &modules[target_root_id.0.index as usize].source,
                                             &modules[target_root_id.index as usize].source,
                                             definition.position(),
                                             "The imported symbol is defined here"
+                                        )
                                         .with_postfixed_info(
                                             &module.source, previous_position, "And is previously defined here"
+                                        )
+                                    )
+                                }
+                            }
                         } else {
                             // Import of specific symbols, optionally using aliases
                             for symbol in &import.symbols {
                                 // Because we have already added per-module definitions, we can use
                                 // the table to lookup this particular symbol. Note: within a single
                                 // module a namespace-import and a symbol-import may not collide.
                                 // Hence per-module symbols are unique.
                                 // However: if we import a symbol from another module, we don't want
                                 // to "import a module's imported symbol". And so if we do find
                                 // a symbol match, we need to make sure it is a definition from
                                 // within that module by checking `source_root_id == target_root_id`
                                 let target_symbol = table.resolve_symbol(target_root_id, &symbol.name);
                                 let symbol_definition_id = match target_symbol {
                                     Some(target_symbol) => {
                                         match target_symbol.symbol {
                                             Symbol::Definition((symbol_root_id, symbol_definition_id)) => {
                                                 if symbol_root_id == target_root_id {
                                                     Some(symbol_definition_id)
                                                 } else {
                                                     // This is imported within the target module, and not
                                                     // defined within the target module
                                                     None
+                                                }
                                             },
                                             Symbol::Namespace(_) => {
                                                 // We don't import a module's "module import"
                                                 None
+                                            }
+                                        }
                                     },
                                     None => None
                                 };
                                 if symbol_definition_id.is_none() {
                                     return Err(
                                         ParseError2::new_error(&module.source, symbol.position, "Could not resolve symbol")
+                                    )
+                                }
                                 let symbol_definition_id = symbol_definition_id.unwrap();
                                 if let Err(previous_position) = table.add_definition_symbol(
                                     module.root_id, symbol.position, &symbol.alias,
                                     target_root_id, symbol_definition_id
                                 ) {
                                     return Err(
                                         ParseError2::new_error(&module.source, symbol.position, "Symbol is multiply defined")
                                             .with_postfixed_info(&module.source, previous_position, "Previous definition was here")
+                                    )
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
         fn find_name(heap: &Heap, root_id: RootId) -> String {
             let root = &heap[root_id];
             for pragma_id in &root.pragmas {
                 match &heap[*pragma_id] {
                     Pragma::Module(module) => {
                         return String::from_utf8_lossy(&module.value).to_string()
                     },
                     _ => {},
+                }
+            }
             return String::from("Unknown")
+        }
         debug_assert_eq!(
             table.symbol_lookup.len(), lookup_reserve_size,
             "miscalculated reserved size for symbol lookup table"
         );
         Ok(table)
+    }
     /// Resolves a module by its defined name
     pub(crate) fn resolve_module(&self, identifier: &Vec<u8>) -> Option<RootId> {
         self.module_lookup.get(identifier).map(|v| *v)
+    }
     /// Resolves a symbol within a particular module, indicated by its RootId,
     /// with a single non-namespaced identifier
     pub(crate) fn resolve_symbol(&self, within_module_id: RootId, identifier: &Vec<u8>) -> Option<&SymbolValue> {
         self.symbol_lookup.get(&SymbolKey{ module_id: within_module_id, symbol_name: identifier.clone() })
+    }
     /// Resolves a namespaced symbol. It will try to go as far as possible in
     /// actually finding a definition or a namespace. So a namespace might be
     /// resolved, after it which it finds an actual definition. It may be that
     /// the namespaced identifier has more elements that should be checked
     /// (i.e. an enum variant, or simply an erroneous instance of too many
     /// chained identifiers). This function will return None if nothing could be
     /// resolved at all.
     pub(crate) fn resolve_namespaced_symbol<'t, 'i>(
         &'t self, root_module_id: RootId, identifier: &'i NamespacedIdentifier
     ) -> Option<(&SymbolValue, NamespacedIdentifierIter<'i>)> {
         let mut iter = identifier.iter();
         let mut symbol: Option<&SymbolValue> = None;
         let mut within_module_id = root_module_id;
         while let Some(partial) = iter.next() {
             // Lookup the symbol within the currently iterated upon module
             let lookup_key = SymbolKey{ module_id: within_module_id, symbol_name: Vec::from(partial) };
             let new_symbol = self.symbol_lookup.get(&lookup_key);
             match new_symbol {
                 None => {
                     // Can't find anything
                     break;
                 },
                 Some(new_symbol) => {
                     // Found something, but if we already moved to another
                     // module then we don't want to keep jumping across modules,
                     // we're only interested in symbols defined within that
                     // module.
                     match &new_symbol.symbol {
                         Symbol::Namespace(new_root_id) => {
                             if root_module_id != within_module_id {
                                 // Don't jump from module to module, keep the
                                 // old symbol (which must be a Namespace) and
                                 // break
                                 debug_assert!(symbol.is_some());
                                 debug_assert!(symbol.unwrap().is_namespace());
                                 debug_assert!(iter.num_returned() > 1);
                                 // For handling this error, we need to revert
                                 // the iterator by one
                                 let to_skip = iter.num_returned() - 1;
                                 iter = identifier.iter();
                                 for _ in 0..to_skip { iter.next(); }
                                 break;
+                            }
                             within_module_id = *new_root_id;
                             symbol = Some(new_symbol);
                         },
                         Symbol::Definition((definition_root_id, _)) => {
                             // Found a definition, but if we already jumped
                             // modules, then this must be defined within that
                             // module.
                             if root_module_id != within_module_id && within_module_id != *definition_root_id {
                                 // This is an imported definition within the module
                                 // TODO: Maybe factor out? Dunno...
                                 debug_assert!(symbol.is_some());
                                 debug_assert!(symbol.unwrap().is_namespace());
                                 debug_assert!(iter.num_returned() > 1);
                                 let to_skip = iter.num_returned() - 1;
                                 iter = identifier.iter();
                                 for _ in 0..to_skip { iter.next(); }
                                 break;
+                            }
                             symbol = Some(new_symbol);
                             break;
+                        }
+                    }
+                }
+            }
+        }
         match symbol {
             None => None,
             Some(symbol) => Some((symbol, iter))
+        }
+    }
     /// Attempts to add a namespace symbol. Returns `Ok` if the symbol was
     /// inserted. If the symbol already exists then `Err` will be returned
     /// together with the previous definition's source position (in the origin
     /// module's source file).
     // Note: I would love to return a reference to the value, but Rust is
     // preventing me from doing so... That, or I'm not smart enough...
     fn add_namespace_symbol(
         &mut self, origin_module_id: RootId, origin_position: InputPosition, symbol_name: &Vec<u8>, target_module_id: RootId
     ) -> Result<(), InputPosition> {
         let key = SymbolKey{
             module_id: origin_module_id,
             symbol_name: symbol_name.clone()
         };
         match self.symbol_lookup.entry(key) {
             Entry::Occupied(o) => Err(o.get().position),
             Entry::Vacant(v) => {
                 v.insert(SymbolValue{
                     position: origin_position,
                     symbol: Symbol::Namespace(target_module_id)
                 });
                 Ok(())
+            }
+        }
+    }
     /// Attempts to add a definition symbol. Returns `Ok` if the symbol was
     /// inserted. If the symbol already exists then `Err` will be returned
     /// together with the previous definition's source position (in the origin
     /// module's source file).
     fn add_definition_symbol(
         &mut self, origin_module_id: RootId, origin_position: InputPosition, symbol_name: &Vec<u8>,
         target_module_id: RootId, target_definition_id: DefinitionId,
     ) -> Result<(), InputPosition> {
         let key = SymbolKey{
             module_id: origin_module_id,
             symbol_name: symbol_name.clone()
         };
         match self.symbol_lookup.entry(key) {
             Entry::Occupied(o) => Err(o.get().position),
             Entry::Vacant(v) => {
                 v.insert(SymbolValue {
                     position: origin_position,
                     symbol: Symbol::Definition((target_module_id, target_definition_id))
                 });
                 Ok(())
+            }
+        }
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/type_table.rs

➞

Show inline comments

 // TODO: @fix PrimitiveType for enums/unions
 use crate::protocol::ast::*;
 use crate::protocol::parser::symbol_table::{SymbolTable, Symbol};
 use crate::protocol::inputsource::*;
 use crate::protocol::parser::*;
 use std::collections::HashMap;
 use crate::common::Formatter;
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum TypeClass {
     Enum,
     Union,
     Struct,
     Function,
     Component
+}
 impl TypeClass {
     pub(crate) fn display_name(&self) -> &'static str {
         match self {
             TypeClass::Enum => "enum",
             TypeClass::Union => "enum",
             TypeClass::Struct => "struct",
             TypeClass::Function => "function",
             TypeClass::Component => "component",
+        }
+    }
+}
 impl std::fmt::Display for TypeClass {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.display_name())
+    }
+}
 pub enum DefinedType {
     Enum(EnumType),
     Union(UnionType),
     Struct(StructType),
     Function(FunctionType),
     Component(ComponentType)
+}
 impl DefinedType {
     pub(crate) fn type_class(&self) -> TypeClass {
         match self {
             DefinedType::Enum(_) => TypeClass::Enum,
             DefinedType::Union(_) => TypeClass::Union,
             DefinedType::Struct(_) => TypeClass::Struct,
             DefinedType::Function(_) => TypeClass::Function,
             DefinedType::Component(_) => TypeClass::Component
+        }
+    }
+}
 // TODO: Also support maximum u64 value
 pub struct EnumVariant {
     identifier: Identifier,
     value: i64,
+}
 /// `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,
+}
 pub struct UnionVariant {
     identifier: Identifier,
     embedded_type: Option<TypeAnnotationId>,
     tag_value: i64,
+}
 pub struct UnionType {
     variants: Vec<UnionVariant>,
     tag_representation: PrimitiveType
+}
 pub struct StructField {
     identifier: Identifier,
     field_type: TypeAnnotationId,
+}
 pub struct StructType {
     fields: Vec<StructField>,
+}
 pub struct FunctionArgument {
     identifier: Identifier,
     argument_type: TypeAnnotationId,
+}
 pub struct FunctionType {
     return_type: TypeAnnotationId,
     arguments: Vec<FunctionArgument>
+}
 pub struct ComponentType {
     variant: ComponentVariant,
     arguments: Vec<FunctionArgument>
+}
 pub struct TypeTable {
     lookup: HashMap<DefinitionId, DefinedType>,
+}
 enum LookupResult {
     BuiltIn,
     Resolved((RootId, DefinitionId)),
     Unresolved((RootId, DefinitionId)),
     Error((InputPosition, String)),
+}
 /// `TypeTable` is responsible for walking the entire lexed AST and laying out
 /// the various user-defined types in terms of bytes and offsets. This process
 /// may be pseudo-recursive (meaning: it is implemented in a recursive fashion,
 /// but not in the recursive-function-call kind of way) in case a type depends
 /// on another type to be resolved.
 /// TODO: Distinction between resolved types and unresolved types (regarding the
 ///     mixed use of BuiltIns and resolved types) is a bit yucky at the moment,
 ///     will have to come up with something nice in the future.
 /// TODO: Need to factor out the repeated lookup in some kind of state machine.
 impl TypeTable {
     pub(crate) fn new(
         symbols: &SymbolTable, heap: &Heap, modules: &[LexedModule]
     ) -> Result<TypeTable, ParseError2> {
         if cfg!(debug_assertions) {
             for (index, module) in modules.iter().enumerate() {
-                debug_assert_eq!(index, module.root_id.0.index as usize)
                 debug_assert_eq!(index, module.root_id.index as usize)
+            }
+        }
         // Estimate total number of definitions we will encounter
         let num_definitions = heap.definitions.len();
         let mut table = TypeTable{
             lookup: HashMap::with_capacity(num_definitions),
         };
         // Perform the breadcrumb-based type parsing. For now we do not allow
         // cyclic types.
         // TODO: Allow cyclic types. However, we want to have an implementation
         //  that is somewhat efficient: if a type is cyclic, then we have to
         //  insert a pointer somewhere. However, we don't want to insert them
         //  everywhere, for each possible type. Without any further context the
         //  decision to place a pointer somewhere is "random", we need to know
         //  how the type is used to have an informed opinion on where to place
         //  the pointer.
         enum Breadcrumb {
             Linear((usize, usize)),
             Jumping((RootId, DefinitionId))
+        }
         // Helper to handle the return value from lookup_type_definition. If
         // resolved/builtin we return `true`, if an error we complete the error
         // and return it. If unresolved then we check for cyclic types and
         // return an error if cyclic, otherwise return false (indicating we need
         // to continue in the breadcrumb-based resolving loop)
         let handle_lookup_result = |
             heap: &Heap, all_modules: &[LexedModule], cur_module: &LexedModule,
             breadcrumbs: &mut Vec<Breadcrumb>, result: LookupResult
         | -> Result<bool, ParseError2> {
             return match result {
                 LookupResult::BuiltIn | LookupResult::Resolved(_) => Ok(true),
                 LookupResult::Unresolved((new_root_id, new_definition_id)) => {
                     // Check for cyclic dependencies
                     let mut is_cyclic = false;
                     for breadcrumb in breadcrumbs.iter() {
                         let (root_id, definition_id) = match breadcrumb {
                             Breadcrumb::Linear((root_index, definition_index)) => {
                                 let root_id = all_modules[*root_index].root_id;
                                 let definition_id = heap[root_id].definitions[*definition_index];
                                 (root_id, definition_id)
                             },
                             Breadcrumb::Jumping(root_id_and_definition_id) => *root_id_and_definition_id
                         };
                         if root_id == new_root_id && definition_id == new_definition_id {
                             // Oh noes!
                             is_cyclic = true;
                             break;
+                        }
+                    }
                     if is_cyclic {
                         let mut error = ParseError2::new_error(
-                            &all_modules[new_root_id.0.index as usize].source,
                             &all_modules[new_root_id.index as usize].source,
                             heap[new_definition_id].position(),
                             "Evaluating this definition results in a a cyclic dependency"
                         );
                         for (index, breadcrumb) in breadcrumbs.iter().enumerate() {
                             match breadcrumb {
                                 Breadcrumb::Linear((root_index, definition_index)) => {
                                     debug_assert_eq!(index, 0);
                                     error = error.with_postfixed_info(
                                         &all_modules[*root_index].source,
                                         heap[heap[all_modules[*root_index].root_id].definitions[*definition_index]].position(),
                                         "The cycle started with this definition"
+                                    )
                                 },
                                 Breadcrumb::Jumping((root_id, definition_id)) => {
                                     debug_assert!(index > 0);
                                     error = error.with_postfixed_info(
-                                        &all_modules[root_id.0.index as usize].source,
                                         &all_modules[root_id.index as usize].source,
                                         heap[*definition_id].position(),
                                         "Which depends on this definition"
+                                    )
+                                }
+                            }
+                        }
                         Err(error)
                     } else {
                         breadcrumbs.push(Breadcrumb::Jumping((new_root_id, new_definition_id)));
                         Ok(false)
+                    }
                 },
                 LookupResult::Error((position, message)) => {
                     Err(ParseError2::new_error(&cur_module.source, position, &message))
+                }
+            }
         };
         let mut module_index = 0;
         let mut definition_index = 0;
         let mut breadcrumbs = Vec::with_capacity(32); // if a user exceeds this, the user sucks at programming
         while module_index < modules.len() {
             // Go to next module if needed
+            {
                 let root = &heap[modules[module_index].root_id];
                 if definition_index >= root.definitions.len() {
                     module_index += 1;
                     definition_index = 0;
                     continue;
+                }
+            }
             // Construct breadcrumbs in case we need to follow some types around
             debug_assert!(breadcrumbs.is_empty());
             breadcrumbs.push(Breadcrumb::Linear((module_index, definition_index)));
             'resolve_loop: while !breadcrumbs.is_empty() {
                 // Retrieve module, the module's root and the definition
                 let (module, definition_id) = match breadcrumbs.last().unwrap() {
                     Breadcrumb::Linear((module_index, definition_index)) => {
                         let module = &modules[*module_index];
                         let root = &heap[module.root_id];
                         let definition_id = root.definitions[*definition_index];
                         (module, definition_id)
                     },
                     Breadcrumb::Jumping((root_id, definition_id)) => {
-                        let module = &modules[root_id.0.index as usize];
                         let module = &modules[root_id.index as usize];
                         debug_assert_eq!(module.root_id, *root_id);
                         (module, *definition_id)
+                    }
                 };
                 let definition = &heap[definition_id];
                 // Because we might have chased around to this particular
                 // definition before, we check if we haven't resolved the type
                 // already.
                 if table.lookup.contains_key(&definition_id) {
                     breadcrumbs.pop();
                     continue;
+                }
                 match definition {
                     Definition::Enum(definition) => {
                         // Check the definition to see if we're dealing with an
                         // enum or a union. If we find any union variants then
                         // we immediately check if the type is already resolved.
                         let mut has_tag_values = None;
                         let mut has_int_values = None;
                         for variant in &definition.variants {
                             match &variant.value {
                                 EnumVariantValue::None => {},
                                 EnumVariantValue::Integer(_) => {
                                     if has_int_values.is_none() { has_int_values = Some(variant.position); }
                                  },
                                 EnumVariantValue::Type(variant_type) => {
                                     if has_tag_values.is_none() { has_tag_values = Some(variant.position); }
                                     let variant_type = &heap[*variant_type];
                                     let lookup_result = lookup_type_definition(
                                         heap, &table, symbols, module.root_id,
                                         &variant_type.the_type.primitive
                                     );
                                     if !handle_lookup_result(heap, modules, module, &mut breadcrumbs, lookup_result)? {
                                         continue 'resolve_loop;
+                                    }
                                 },
+                            }
+                        }
                         if has_tag_values.is_some() && has_int_values.is_some() {
                             // Not entirely illegal, but probably not desired
                             let tag_pos = has_tag_values.unwrap();
                             let int_pos = has_int_values.unwrap();
                             return Err(
                                 ParseError2::new_error(&module.source, definition.position, "Illegal combination of enum integer variant(s) and enum union variant(s)")
                                 .with_postfixed_info(&module.source, int_pos, "Explicitly assigning an integer value here")
                                 .with_postfixed_info(&module.source, tag_pos, "Explicitly declaring a union variant here")
+                            )
+                        }
                         // If here, then the definition is a valid discriminated
                         // union with all of its types resolved, or a valid
                         // enum.
                         // Decide whether to implement as enum or as union
                         let is_union = has_tag_values.is_some();
                         if is_union {
                             // Implement as discriminated union. Because we
                             // checked the availability of types above, we are
                             // safe to lookup type definitions
                             let mut tag_value = -1;
                             let mut variants = Vec::with_capacity(definition.variants.len());
                             for variant in &definition.variants {
                                 tag_value += 1;
                                 let embedded_type = match &variant.value {
                                     EnumVariantValue::None => {
                                         None
                                     },
                                     EnumVariantValue::Type(type_annotation_id) => {
                                         // Type should be resolvable, we checked this above
                                         let type_annotation = &heap[*type_annotation_id];
                                         // TODO: Remove the assert once I'm clear on how to layout "the types" of types
                                         if cfg!(debug_assertions) {
                                             ensure_type_definition(heap, &table, symbols, module.root_id, &type_annotation.the_type.primitive);
+                                        }
                                         Some(*type_annotation_id)
                                     },
                                     EnumVariantValue::Integer(_) => {
                                         debug_assert!(false, "Encountered `Integer` variant after asserting enum is a discriminated union");
                                         unreachable!();
+                                    }
                                 };
                                 variants.push(UnionVariant{
                                     identifier: variant.identifier.clone(),
                                     embedded_type,
                                     tag_value,
                                 })
+                            }
                             table.add_definition(definition_id, DefinedType::Union(UnionType{
                                 variants,
                                 tag_representation: enum_representation(tag_value)
                             }));
                         } else {
                             // Implement as regular enum
                             let mut enum_value = -1; // TODO: allow u64 max size
                             let mut variants = Vec::with_capacity(definition.variants.len());
                             for variant in &definition.variants {
                                 enum_value += 1;
                                 match &variant.value {
                                     EnumVariantValue::None => {
                                         variants.push(EnumVariant{
                                             identifier: variant.identifier.clone(),
                                             value: enum_value,
                                         });
                                     },
                                     EnumVariantValue::Integer(override_value) => {
                                         enum_value = *override_value;
                                         variants.push(EnumVariant{
                                             identifier: variant.identifier.clone(),
                                             value: enum_value,
                                         });
                                     },
                                     EnumVariantValue::Type(_) => {
                                         debug_assert!(false, "Encountered `Type` variant after asserting enum is not a discriminated union");
                                         unreachable!();
+                                    }
+                                }
+                            }
                             table.add_definition(definition_id, DefinedType::Enum(EnumType{
                                 variants,
                                 representation: enum_representation(enum_value),
                             }));
+                        }
                     },
                     Definition::Struct(definition) => {
                         // Before we start allocating fields, make sure we can
                         // actually resolve all of the field types
                         for field_definition in &definition.fields {
                             let type_definition = &heap[field_definition.the_type];
                             let lookup_result = lookup_type_definition(
                                 heap, &table, symbols, module.root_id,
                                 &type_definition.the_type.primitive
                             );
                             if !handle_lookup_result(heap, modules, module, &mut breadcrumbs, lookup_result)? {
                                 continue 'resolve_loop;
+                            }
+                        }
                         // We can resolve everything
                         let mut fields = Vec::with_capacity(definition.fields.len());
                         for field_definition in &definition.fields {
                             let type_annotation = &heap[field_definition.the_type];
                             if cfg!(debug_assertions) {
                                 ensure_type_definition(heap, &table, symbols, module.root_id, &type_annotation.the_type.primitive);
+                            }
                             fields.push(StructField{
                                 identifier: field_definition.field.clone(),
                                 field_type: field_definition.the_type
                             });
+                        }
                         table.add_definition(definition_id, DefinedType::Struct(StructType{
                             fields,
                         }));
                     },
                     Definition::Component(definition) => {
                         // As always, ensure all parameter types are resolved
                         for parameter_id in &definition.parameters {
                             let parameter = &heap[*parameter_id];
                             let type_definition = &heap[parameter.type_annotation];
                             let lookup_result = lookup_type_definition(
                                 heap, &table, symbols, module.root_id,
                                 &type_definition.the_type.primitive
                             );
                             if !handle_lookup_result(heap, modules, module, &mut breadcrumbs, lookup_result)? {
                                 continue 'resolve_loop;
+                            }
+                        }
                         // We can resolve everything
                         let mut parameters = Vec::with_capacity(definition.parameters.len());
                         for parameter_id in &definition.parameters {
                             let parameter = &heap[*parameter_id];
                             let type_definition = &heap[parameter.type_annotation];
                             if cfg!(debug_assertions) {
                                 ensure_type_definition(heap, &table, symbols, module.root_id, &type_definition.the_type.primitive);
+                            }
                             parameters.push(FunctionArgument{
                                 identifier: parameter.identifier.clone(),
                                 argument_type: parameter.type_annotation,
                             });
+                        }
                         table.add_definition(definition_id, DefinedType::Component(ComponentType{
                             variant: definition.variant,
                             arguments: parameters, // Arguments, parameters, tomayto, tomahto
                         }));
                     },
                     Definition::Function(definition) => {
                         // Handle checking the return type
                         let lookup_result = lookup_type_definition(
                             heap, &table, symbols, module.root_id,
                             &heap[definition.return_type].the_type.primitive
                         );
                         if !handle_lookup_result(heap, modules, module, &mut breadcrumbs, lookup_result)? {
                             continue 'resolve_loop;
+                        }
                         for parameter_id in &definition.parameters {
                             let parameter = &heap[*parameter_id];
                             let type_definition = &heap[parameter.type_annotation];
                             let lookup_result = lookup_type_definition(
                                 heap, &table, symbols, module.root_id,
                                 &type_definition.the_type.primitive
                             );
                             if !handle_lookup_result(heap, modules, module, &mut breadcrumbs, lookup_result)? {
                                 continue 'resolve_loop;
+                            }
+                        }
                         // Resolve function's types
                         let mut parameters = Vec::with_capacity(definition.parameters.len());
                         for parameter_id in &definition.parameters {
                             let parameter = &heap[*parameter_id];
                             let type_definition = &heap[parameter.type_annotation];
                             if cfg!(debug_assertions) {
                                 ensure_type_definition(heap, &table, symbols, module.root_id, &type_definition.the_type.primitive);
+                            }
                             parameters.push(FunctionArgument{
                                 identifier: parameter.identifier.clone(),
                                 argument_type: parameter.type_annotation
                             });
+                        }
                         table.add_definition(definition_id, DefinedType::Function(FunctionType{
                             return_type: definition.return_type.clone(),
                             arguments: parameters,
                         }));
                     },
+                }
                 // If here, then we layed out the current type definition under
                 // investigation, so:
                 debug_assert!(!breadcrumbs.is_empty());
                 breadcrumbs.pop();
+            }
             // Go to next definition
             definition_index += 1;
+        }
         debug_assert_eq!(
             num_definitions, table.lookup.len(),
             "expected {} (reserved) definitions in table, got {}",
             num_definitions, table.lookup.len()
         );
         Ok(table)
+    }
     pub(crate) fn get_definition(&self, definition_id: &DefinitionId) -> Option<&DefinedType> {
         self.lookup.get(definition_id)
+    }
     fn add_definition(&mut self, definition_id: DefinitionId, definition: DefinedType) {
         debug_assert!(!self.lookup.contains_key(&definition_id), "already added definition");
         self.lookup.insert(definition_id, definition);
+    }
+}
 /// Attempts to lookup a type definition using a namespaced identifier. We have
 /// three success cases: the first is simply that the type is a `BuiltIn` type.
 /// In the two other cases both we find the definition of the type in the symbol
 /// table, but in one case it is already `Resolved` in the type table, and in
 /// the other case it is `Unresolved`. In this last case the type has to be
 /// resolved before we're able to use it in the `TypeTable` construction
 /// algorithm.
 /// In the `Error` case something goes wrong with resolving the type. The error
 /// message aims to be as helpful as possible to the user.
 /// The caller should ensure that the `module_root` is where the `identifier`
 /// lives.
 fn lookup_type_definition(
     heap: &Heap, types: &TypeTable, symbols: &SymbolTable,
     module_root: RootId, type_to_resolve: &PrimitiveType
 ) -> LookupResult {
     if let PrimitiveType::Symbolic(type_to_resolve) = type_to_resolve {
         let identifier = &type_to_resolve.identifier;
         match symbols.resolve_namespaced_symbol(module_root, identifier) {
             None => {
                 // Failed to find anything at all
                 LookupResult::Error((identifier.position, String::from("Unknown type")))
             },
             Some((symbol, mut identifier_iter)) => {
                 match symbol.symbol {
                     Symbol::Namespace(_root_id) => {
                         // Reference to a namespace, which is not a type. However,
                         // the error message depends on whether we have identifiers
                         // remaining or not
                         if identifier_iter.num_remaining() == 0 {
                             LookupResult::Error((
                                 identifier.position,
                                 String::from("Expected a type, got a module name")
                             ))
                         } else {
                             let next_identifier = identifier_iter.next().unwrap();
                             LookupResult::Error((
                                 identifier.position,
                                 format!("Cannot find symbol '{}' in this module", String::from_utf8_lossy(next_identifier))
                             ))
+                        }
                     },
                     Symbol::Definition((definition_root_id, definition_id)) => {
                         // Got a definition, but we may also have more identifier's
                         // remaining in the identifier iterator
                         let definition = &heap[definition_id];
                         if identifier_iter.num_remaining() == 0 {
                             // See if the type is resolved, and make sure it is
                             // a non-function, non-component type. Ofcourse
                             // these are valid types, but we cannot (yet?) use
                             // them as function arguments, struct fields or enum
                             // variants
                             match definition {
                                 Definition::Component(definition) => {
                                     return LookupResult::Error((
                                         identifier.position,
                                         format!(
                                             "Cannot use the component '{}' as an embedded type",
                                             String::from_utf8_lossy(&definition.identifier.value)
+                                        )
                                     ));
                                 },
                                 Definition::Function(definition) => {
                                     return LookupResult::Error((
                                         identifier.position,
                                         format!(
                                             "Cannot use the function '{}' as an embedded type",
                                             String::from_utf8_lossy(&definition.identifier.value)
+                                        )
                                     ));
                                 },
                                 Definition::Enum(_) | Definition::Struct(_) => {}
+                            }
                             return if types.lookup.contains_key(&definition_id) {
                                 LookupResult::Resolved((definition_root_id, definition_id))
                             } else {
                                 LookupResult::Unresolved((definition_root_id, definition_id))
+                            }
                         } else if identifier_iter.num_remaining() == 1 {
                             // This is always invalid, but if the type is an
                             // enumeration or a union then we want to return a
                             // different error message.
                             if definition.is_enum() {
                                 let last_identifier = identifier_iter.next().unwrap();
                                 return LookupResult::Error((
                                     identifier.position,
                                     format!(
                                         "Expected a type, but got a (possible) enum variant '{}'. Only the enum '{}' itself can be used as a type",
                                         String::from_utf8_lossy(last_identifier),
                                         String::from_utf8_lossy(&definition.identifier().value)
+                                    )
                                 ));
+                            }
+                        }
                         // Too much identifiers (>1) for an enumeration, or not an
                         // enumeration and we had more identifiers remaining
                         LookupResult::Error((
                             identifier.position,
                             format!(
                                 "Unknown type '{}', did you mean to use '{}'?",
                                 String::from_utf8_lossy(&identifier.value),
                                 String::from_utf8_lossy(&definition.identifier().value)
+                            )
                         ))
+                    }
+                }
+            }
+        }
     } else {
         LookupResult::BuiltIn
+    }
+}
 /// Debugging function to ensure a type is resolved (calling
 /// `lookup_type_definition` and ensuring its return value is `BuiltIn` or
 /// `Resolved`
 #[cfg(debug_assertions)]
 fn ensure_type_definition(
     heap: &Heap, types: &TypeTable, symbols: &SymbolTable,
     module_root: RootId, type_to_resolve: &PrimitiveType
 ) {
     match lookup_type_definition(heap, types, symbols, module_root, type_to_resolve) {
         LookupResult::BuiltIn | LookupResult::Resolved(_) => {},
         LookupResult::Unresolved((_, definition_id)) => {
             assert!(
                 false,
                 "Expected that type definition for {} was resolved by the type table, but it wasn't",
                 String::from_utf8_lossy(&heap[definition_id].identifier().value)
+            )
         },
         LookupResult::Error((_, error)) => {
             let message = if let PrimitiveType::Symbolic(symbolic) = type_to_resolve {
                 format!(
                     "Expected that type definition for {} was resolved by the type table, but it returned: {}",
                     String::from_utf8_lossy(&symbolic.identifier.value), &error
+                )
             } else {
                 format!(
                     "Expected (non-symbolic!?) type definition to be resolved, but it returned: {}",
                     &error
+                )
             };
             assert!(false, "{}", message)
+        }
+    }
+}
 /// Determines an enumeration's integer representation type, or a union's tag
 /// type, using the maximum value of the tag. The returned type is always a
 /// builtin type.
 /// TODO: Fix for maximum u64 value
 fn enum_representation(max_tag_value: i64) -> PrimitiveType {
     if max_tag_value <= u8::max_value() as i64 {
         PrimitiveType::Byte
     } else if max_tag_value <= u16::max_value() as i64 {
         PrimitiveType::Short
     } else if max_tag_value <= u32::max_value() as i64 {
         PrimitiveType::Int
     } else {
         PrimitiveType::Long
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/visitor_linker.rs

➞

Show inline comments

 use crate::protocol::ast::*;
 use crate::protocol::inputsource::*;
 use crate::protocol::parser::{symbol_table::*, type_table::*};
 use super::visitor::{
     STMT_BUFFER_INIT_CAPACITY,
     EXPR_BUFFER_INIT_CAPACITY,
     Ctx,
     Visitor2,
     VisitorResult
 };
 #[derive(PartialEq, Eq)]
 enum DefinitionType {
     Primitive,
     Composite,
     Function
+}
 /// This particular visitor will go through the entire AST in a recursive manner
 /// and check if all statements and expressions are legal (e.g. no "return"
 /// statements in component definitions), and will link certain AST nodes to
 /// their appropriate targets (e.g. goto statements, or function calls).
 ///
 /// This visitor will not perform control-flow analysis (e.g. making sure that
 /// each function actually returns) and will also not perform type checking. So
 /// the linking of function calls and component instantiations will be checked
 /// and linked to the appropriate definitions, but the return types and/or
 /// arguments will not be checked for validity.
 ///
 /// The visitor visits each statement in a block in a breadth-first manner
 /// first. We are thereby sure that we have found all variables/labels in a
 /// particular block. In this phase nodes may queue statements for insertion
 /// (e.g. the insertion of an `EndIf` statement for a particular `If`
 /// statement). These will be inserted after visiting every node, after which
 /// the visitor recurses into each statement in a block.
 ///
 /// Because of this scheme expressions will not be visited in the breadth-first
 /// pass.
 pub(crate) struct ValidityAndLinkerVisitor {
     /// `in_sync` is `Some(id)` if the visitor is visiting the children of a
     /// synchronous statement. A single value is sufficient as nested
     /// synchronous statements are not allowed
     in_sync: Option<SynchronousStatementId>,
     /// `in_while` contains the last encountered `While` statement. This is used
     /// to resolve unlabeled `Continue`/`Break` statements.
     in_while: Option<WhileStatementId>,
     // Traversal state: current scope (which can be used to find the parent
     // scope), the definition variant we are considering, and whether the
     // visitor is performing breadthwise block statement traversal.
     cur_scope: Option<Scope>,
     def_type: DefinitionType,
     performing_breadth_pass: bool,
     // Keeping track of relative position in block in the breadth-first pass.
     // May not correspond to block.statement[index] if any statements are
     // inserted after the breadth-pass
     relative_pos_in_block: u32,
     // Single buffer of statement IDs that we want to traverse in a block.
     // Required to work around Rust borrowing rules and to prevent constant
     // cloning of vectors.
     statement_buffer: Vec<StatementId>,
     // Another buffer, now with expression IDs, to prevent constant cloning of
     // vectors while working around rust's borrowing rules
     expression_buffer: Vec<ExpressionId>,
     // Statements to insert after the breadth pass in a single block
     insert_buffer: Vec<(u32, StatementId)>,
+}
 impl ValidityAndLinkerVisitor {
     pub(crate) fn new() -> Self {
         Self{
             in_sync: None,
             in_while: None,
             cur_scope: None,
             def_type: DefinitionType::Primitive,
             performing_breadth_pass: false,
             relative_pos_in_block: 0,
             statement_buffer: Vec::with_capacity(STMT_BUFFER_INIT_CAPACITY),
             expression_buffer: Vec::with_capacity(EXPR_BUFFER_INIT_CAPACITY),
             insert_buffer: Vec::with_capacity(32),
+        }
+    }
     fn reset_state(&mut self) {
         self.in_sync = None;
         self.in_while = None;
         self.cur_scope = None;
         self.def_type = DefinitionType::Primitive;
         self.relative_pos_in_block = 0;
         self.performing_breadth_pass = false;
         self.statement_buffer.clear();
         self.insert_buffer.clear();
+    }
+}
 impl Visitor2 for ValidityAndLinkerVisitor {
     //--------------------------------------------------------------------------
     // Definition visitors
     //--------------------------------------------------------------------------
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentId) -> VisitorResult {
         self.reset_state();
         self.def_type = match &ctx.heap[id].variant {
             ComponentVariant::Primitive => DefinitionType::Primitive,
             ComponentVariant::Composite => DefinitionType::Composite,
         };
         self.cur_scope = Some(Scope::Definition(id.upcast()));
         let body_id = ctx.heap[id].body;
         self.performing_breadth_pass = true;
         self.visit_stmt(ctx, body_id)?;
         self.performing_breadth_pass = false;
         self.visit_stmt(ctx, body_id)
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionId) -> VisitorResult {
         self.reset_state();
         // Set internal statement indices
         self.def_type = DefinitionType::Function;
         self.cur_scope = Some(Scope::Definition(id.upcast()));
         let body_id = ctx.heap[id].body;
         self.performing_breadth_pass = true;
         self.visit_stmt(ctx, body_id)?;
         self.performing_breadth_pass = false;
         self.visit_stmt(ctx, body_id)
+    }
     //--------------------------------------------------------------------------
     // Statement visitors
     //--------------------------------------------------------------------------
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         self.visit_block_stmt_with_hint(ctx, id, None)
+    }
     fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let variable_id = ctx.heap[id].variable;
             self.checked_local_add(ctx, self.relative_pos_in_block, variable_id)?;
         } else {
             self.visit_expr(ctx, ctx.heap[id].initial)?;
+        }
         Ok(())
+    }
     fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let (from_id, to_id) = {
                 let stmt = &ctx.heap[id];
                 (stmt.from, stmt.to)
             };
             self.checked_local_add(ctx, self.relative_pos_in_block, from_id)?;
             self.checked_local_add(ctx, self.relative_pos_in_block, to_id)?;
+        }
         Ok(())
+    }
     fn visit_labeled_stmt(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             // Add label to block lookup
             self.checked_label_add(ctx, id)?;
             // Modify labeled statement itself
             let labeled = &mut ctx.heap[id];
             labeled.relative_pos_in_block = self.relative_pos_in_block;
             labeled.in_sync = self.in_sync.clone();
+        }
         let body_id = ctx.heap[id].body;
         self.visit_stmt(ctx, body_id)?;
         Ok(())
+    }
     fn visit_if_stmt(&mut self, ctx: &mut Ctx, id: IfStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let position = ctx.heap[id].position;
             let end_if_id = ctx.heap.alloc_end_if_statement(|this| {
                 EndIfStatement {
                     this,
                     start_if: id,
                     position,
                     next: None,
+                }
             });
             let stmt = &mut ctx.heap[id];
             stmt.end_if = Some(end_if_id);
             self.insert_buffer.push((self.relative_pos_in_block + 1, end_if_id.upcast()));
         } else {
             // Traverse expression and bodies
             let (test_id, true_id, false_id) = {
                 let stmt = &ctx.heap[id];
                 (stmt.test, stmt.true_body, stmt.false_body)
             };
             self.visit_expr(ctx, test_id)?;
             self.visit_stmt(ctx, true_id)?;
             self.visit_stmt(ctx, false_id)?;
+        }
         Ok(())
+    }
     fn visit_while_stmt(&mut self, ctx: &mut Ctx, id: WhileStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let position = ctx.heap[id].position;
             let end_while_id = ctx.heap.alloc_end_while_statement(|this| {
                 EndWhileStatement {
                     this,
                     start_while: id,
                     position,
                     next: None,
+                }
             });
             let stmt = &mut ctx.heap[id];
             stmt.end_while = Some(end_while_id);
             stmt.in_sync = self.in_sync.clone();
             self.insert_buffer.push((self.relative_pos_in_block + 1, end_while_id.upcast()));
         } else {
             let (test_id, body_id) = {
                 let stmt = &ctx.heap[id];
                 (stmt.test, stmt.body)
             };
             let old_while = self.in_while.replace(id);
             self.visit_expr(ctx, test_id)?;
             self.visit_stmt(ctx, body_id)?;
             self.in_while = old_while;
+        }
         Ok(())
+    }
     fn visit_break_stmt(&mut self, ctx: &mut Ctx, id: BreakStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             // Should be able to resolve break statements with a label in the
             // breadth pass, no need to do after resolving all labels
             let target_end_while = {
                 let stmt = &ctx.heap[id];
                 let target_while_id = self.resolve_break_or_continue_target(ctx, stmt.position, &stmt.label)?;
                 let target_while = &ctx.heap[target_while_id];
                 debug_assert!(target_while.end_while.is_some());
                 target_while.end_while.unwrap()
             };
             let stmt = &mut ctx.heap[id];
             stmt.target = Some(target_end_while);
+        }
         Ok(())
+    }
     fn visit_continue_stmt(&mut self, ctx: &mut Ctx, id: ContinueStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let target_while_id = {
                 let stmt = &ctx.heap[id];
                 self.resolve_break_or_continue_target(ctx, stmt.position, &stmt.label)?
             };
             let stmt = &mut ctx.heap[id];
             stmt.target = Some(target_while_id)
+        }
         Ok(())
+    }
     fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             // Check for validity of synchronous statement
             let cur_sync_position = ctx.heap[id].position;
             if self.in_sync.is_some() {
                 // Nested synchronous statement
                 let old_sync = &ctx.heap[self.in_sync.unwrap()];
                 return Err(
                     ParseError2::new_error(&ctx.module.source, cur_sync_position, "Illegal nested synchronous statement")
                         .with_postfixed_info(&ctx.module.source, old_sync.position, "It is nested in this synchronous statement")
                 );
+            }
             if self.def_type != DefinitionType::Primitive {
                 return Err(ParseError2::new_error(
                     &ctx.module.source, cur_sync_position,
                     "Synchronous statements may only be used in primitive components"
                 ));
+            }
             // Append SynchronousEnd pseudo-statement
             let sync_end_id = ctx.heap.alloc_end_synchronous_statement(|this| EndSynchronousStatement{
                 this,
                 position: cur_sync_position,
                 start_sync: id,
                 next: None,
             });
             let sync_start = &mut ctx.heap[id];
             sync_start.end_sync = Some(sync_end_id);
             self.insert_buffer.push((self.relative_pos_in_block + 1, sync_end_id.upcast()));
         } else {
             let sync_body = ctx.heap[id].body;
             let old = self.in_sync.replace(id);
             self.visit_stmt_with_hint(ctx, sync_body, Some(id))?;
             self.in_sync = old;
+        }
         Ok(())
+    }
     fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let stmt = &ctx.heap[id];
             if self.def_type != DefinitionType::Function {
                 return Err(
                     ParseError2::new_error(&ctx.module.source, stmt.position, "Return statements may only appear in function bodies")
                 );
+            }
         } else {
             // If here then we are within a function
             self.visit_expr(ctx, ctx.heap[id].expression)?;
+        }
         Ok(())
+    }
     fn visit_assert_stmt(&mut self, ctx: &mut Ctx, id: AssertStatementId) -> VisitorResult {
         let stmt = &ctx.heap[id];
         if self.performing_breadth_pass {
             if self.def_type == DefinitionType::Function {
                 // TODO: We probably want to allow this. Mark the function as
                 //  using asserts, and then only allow calls to these functions
                 //  within components. Such a marker will cascade through any
                 //  functions that then call an asserting function
                 return Err(
                     ParseError2::new_error(&ctx.module.source, stmt.position, "Illegal assert statement in a function")
                 );
+            }
             // We are in a component of some sort, but we also need to be within a
             // synchronous statement
             if self.in_sync.is_none() {
                 return Err(
                     ParseError2::new_error(&ctx.module.source, stmt.position, "Illegal assert statement outside of a synchronous block")
                 );
+            }
         } else {
             let expr_id = stmt.expression;
             self.visit_expr(ctx, expr_id)?;
+        }
         Ok(())
+    }
     fn visit_goto_stmt(&mut self, ctx: &mut Ctx, id: GotoStatementId) -> VisitorResult {
         if !self.performing_breadth_pass {
             // Must perform goto label resolving after the breadth pass, this
             // way we are able to find all the labels in current and outer
             // scopes.
             let target_id = self.find_label(ctx, &ctx.heap[id].label)?;
             ctx.heap[id].target = Some(target_id);
             let target = &ctx.heap[target_id];
             if self.in_sync != target.in_sync {
                 // We can only goto the current scope or outer scopes. Because
                 // nested sync statements are not allowed so if the value does
                 // not match, then we must be inside a sync scope
                 debug_assert!(self.in_sync.is_some());
                 let goto_stmt = &ctx.heap[id];
                 let sync_stmt = &ctx.heap[self.in_sync.unwrap()];
                 return Err(
                     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 != DefinitionType::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
             let call_expr_id = ctx.heap[id].expression;
             let call_expr = &ctx.heap[call_expr_id];
             let old_num_exprs = self.expression_buffer.len();
             self.expression_buffer.extend(&call_expr.arguments);
             let new_num_exprs = self.expression_buffer.len();
             for arg_expr_idx in old_num_exprs..new_num_exprs {
                 let arg_expr_id = self.expression_buffer[arg_expr_idx];
                 self.visit_expr(ctx, arg_expr_id)?;
+            }
             self.expression_buffer.truncate(old_num_exprs);
+        }
         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;
             self.visit_expr(ctx, port)?;
             self.visit_expr(ctx, message)?;
+        }
         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;
             self.visit_expr(ctx, expr_id)?;
+        }
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Expression visitors
     //--------------------------------------------------------------------------
     fn visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let assignment_expr = &ctx.heap[id];
         let left_expr_id = assignment_expr.left;
         let right_expr_id = assignment_expr.right;
         self.visit_expr(ctx, left_expr_id)?;
         self.visit_expr(ctx, right_expr_id)?;
         Ok(())
+    }
     fn visit_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         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.visit_expr(ctx, test_expr_id)?;
         self.visit_expr(ctx, true_expr_id)?;
         self.visit_expr(ctx, false_expr_id)?;
         Ok(())
+    }
     fn visit_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let binary_expr = &ctx.heap[id];
         let left_expr_id = binary_expr.left;
         let right_expr_id = binary_expr.right;
         self.visit_expr(ctx, left_expr_id)?;
         self.visit_expr(ctx, right_expr_id)?;
         Ok(())
+    }
     fn visit_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let expr_id = ctx.heap[id].expression;
         self.visit_expr(ctx, expr_id)?;
         Ok(())
+    }
     fn visit_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         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)?;
         Ok(())
+    }
     fn visit_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         // TODO: Same as the select expression: slicing depends on the type of
         //  the thing that is being sliced.
         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)?;
         Ok(())
+    }
     fn visit_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let expr_id = ctx.heap[id].subject;
         self.visit_expr(ctx, expr_id)?;
         Ok(())
+    }
     fn visit_array_expr(&mut self, ctx: &mut Ctx, id: ArrayExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let array_expr = &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();
         for field_expr_idx in old_num_exprs..new_num_exprs {
             let field_expr_id = self.expression_buffer[field_expr_idx];
             self.visit_expr(ctx, field_expr_id)?;
+        }
         self.expression_buffer.truncate(old_num_exprs);
         Ok(())
+    }
     fn visit_constant_expr(&mut self, _ctx: &mut Ctx, _id: ConstantExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         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];
         // Resolve the method to the appropriate definition and check the
         // legality of the particular method call.
         match &mut call_expr.method {
             Method::Create => {},
             Method::Fires => {
                 if self.def_type != DefinitionType::Primitive {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'fires' may only occur in primitive component definitions"
                     ));
+                }
             },
             Method::Get => {
                 if self.def_type != DefinitionType::Primitive {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'get' may only occur in primitive component definitions"
                     ));
+                }
             },
             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);
+            }
+        }
         // Parse all the arguments in the depth pass as well
         let call_expr = &mut ctx.heap[id];
         let old_num_exprs = self.expression_buffer.len();
         self.expression_buffer.extend(&call_expr.arguments);
         let new_num_exprs = self.expression_buffer.len();
         for arg_expr_idx in old_num_exprs..new_num_exprs {
             let arg_expr_id = self.expression_buffer[arg_expr_idx];
             self.visit_expr(ctx, arg_expr_id)?;
+        }
         self.expression_buffer.truncate(old_num_exprs);
         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);
         Ok(())
+    }
+}
 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();
-        println!("DEBUG: Assigning relative {} to block {}", self.relative_pos_in_block, id.0.0.index);
         println!("DEBUG: Assigning relative {} to block {}", self.relative_pos_in_block, id.0.index);
         body.relative_pos_in_parent = self.relative_pos_in_block;
         let old_scope = self.cur_scope.replace(match hint {
             Some(sync_id) => Scope::Synchronous((sync_id, id)),
             None => Scope::Regular(id),
         });
         let old_relative_pos = self.relative_pos_in_block;
         // Copy statement IDs into buffer
         let old_num_stmts = self.statement_buffer.len();
+        {
             let body = &ctx.heap[id];
             self.statement_buffer.extend_from_slice(&body.statements);
+        }
         let new_num_stmts = self.statement_buffer.len();
         // Perform the breadth-first pass. Its main purpose is to find labeled
         // statements such that we can find the `goto`-targets immediately when
         // performing the depth pass
         self.performing_breadth_pass = true;
         for stmt_idx in old_num_stmts..new_num_stmts {
             self.relative_pos_in_block = (stmt_idx - old_num_stmts) as u32;
             self.visit_stmt(ctx, self.statement_buffer[stmt_idx])?;
+        }
         if !self.insert_buffer.is_empty() {
             let body = &mut ctx.heap[id];
             for (insert_idx, (pos, stmt)) in self.insert_buffer.drain(..).enumerate() {
                 body.statements.insert(pos as usize + insert_idx, stmt);
+            }
+        }
         // And the depth pass. Because we're not actually visiting any inserted
         // nodes because we're using the statement buffer, we may safely use the
         // relative_pos_in_block counter.
         self.performing_breadth_pass = false;
         for stmt_idx in old_num_stmts..new_num_stmts {
             self.relative_pos_in_block = (stmt_idx - old_num_stmts) as u32;
             self.visit_stmt(ctx, self.statement_buffer[stmt_idx])?;
+        }
         self.cur_scope = old_scope;
         self.relative_pos_in_block = old_relative_pos;
         // Pop statement buffer
         debug_assert!(self.insert_buffer.is_empty(), "insert buffer not empty after depth pass");
         self.statement_buffer.truncate(old_num_stmts);
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Utilities
     //--------------------------------------------------------------------------
     /// Adds a local variable to the current scope. It will also annotate the
     /// `Local` in the AST with its relative position in the block.
     fn checked_local_add(&mut self, ctx: &mut Ctx, relative_pos: u32, id: LocalId) -> Result<(), ParseError2> {
         debug_assert!(self.cur_scope.is_some());
         // Make sure we do not conflict with any global symbols
+        {
             let ident = &ctx.heap[id].identifier;
             if let Some(symbol) = ctx.symbols.resolve_symbol(ctx.module.root_id, &ident.value) {
                 return Err(
                     ParseError2::new_error(&ctx.module.source, ident.position, "Local variable declaration conflicts with symbol")
                         .with_postfixed_info(&ctx.module.source, symbol.position, "Conflicting symbol is found here")
                 );
+            }
+        }
         let local = &mut ctx.heap[id];
         local.relative_pos_in_block = relative_pos;
         // Make sure we do not shadow any variables in any of the scopes. Note
         // that variables in parent scopes may be declared later
         let local = &ctx.heap[id];
         let mut scope = self.cur_scope.as_ref().unwrap();
         let mut local_relative_pos = self.relative_pos_in_block;
         loop {
             debug_assert!(scope.is_block(), "scope is not a block");
             let block = &ctx.heap[scope.to_block()];
             for other_local_id in &block.locals {
                 let other_local = &ctx.heap[*other_local_id];
                 // Position check in case another variable with the same name
                 // is defined in a higher-level scope, but later than the scope
                 // in which the current variable resides.
                 if local.this != *other_local_id &&
                     local_relative_pos >= other_local.relative_pos_in_block &&
                     local.identifier.value == other_local.identifier.value {
                     // Collision within this scope
                     return Err(
                         ParseError2::new_error(&ctx.module.source, local.position, "Local variable name conflicts with another variable")
                             .with_postfixed_info(&ctx.module.source, other_local.position, "Previous variable is found here")
                     );
+                }
+            }
             // Current scope is fine, move to parent scope if any
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();
             if let Scope::Definition(definition_id) = scope {
                 // At outer scope, check parameters of function/component
                 for parameter_id in ctx.heap[*definition_id].parameters() {
                     let parameter = &ctx.heap[*parameter_id];
                     if local.identifier.value == parameter.identifier.value {
                         return Err(
                             ParseError2::new_error(&ctx.module.source, local.position, "Local variable name conflicts with parameter")
                                 .with_postfixed_info(&ctx.module.source, parameter.position, "Parameter definition is found here")
                         );
+                    }
+                }
                 break;
+            }
             // If here, then we are dealing with a block-like parent block
             local_relative_pos = ctx.heap[scope.to_block()].relative_pos_in_parent;
+        }
         // No collisions at all
         let block = &mut ctx.heap[self.cur_scope.as_ref().unwrap().to_block()];
         block.locals.push(id);
         Ok(())
+    }
     /// Finds a variable in the visitor's scope that must appear before the
     /// specified relative position within that block.
     fn find_variable(&self, ctx: &Ctx, mut relative_pos: u32, identifier: &NamespacedIdentifier) -> Result<VariableId, ParseError2> {
         debug_assert!(self.cur_scope.is_some());
         debug_assert!(identifier.num_namespaces > 0);
         // TODO: Update once globals are possible as well
         if identifier.num_namespaces > 1 {
             todo!("Implement namespaced constant seeking")
+        }
         // TODO: May still refer to an alias of a global symbol using a single
         //  identifier in the namespace.
         // No need to use iterator over namespaces if here
         let mut scope = self.cur_scope.as_ref().unwrap();
         loop {
             debug_assert!(scope.is_block());
             let block = &ctx.heap[scope.to_block()];
             for local_id in &block.locals {
                 let local = &ctx.heap[*local_id];
                 if local.relative_pos_in_block < relative_pos && local.identifier.value == identifier.value {
                     return Ok(local_id.upcast());
+                }
+            }
             debug_assert!(block.parent_scope.is_some());
             scope = block.parent_scope.as_ref().unwrap();
             if !scope.is_block() {
                 // Definition scope, need to check arguments to definition
                 match scope {
                     Scope::Definition(definition_id) => {
                         let definition = &ctx.heap[*definition_id];
                         for parameter_id in definition.parameters() {
                             let parameter = &ctx.heap[*parameter_id];
                             if parameter.identifier.value == identifier.value {
                                 return Ok(parameter_id.upcast());
+                            }
+                        }
                     },
                     _ => unreachable!(),
+                }
                 // Variable could not be found
                 return Err(ParseError2::new_error(
                     &ctx.module.source, identifier.position, "This variable is not declared"
                 ));
             } else {
                 relative_pos = block.relative_pos_in_parent;
+            }
+        }
+    }
     /// Adds a particular label to the current scope. Will return an error if
     /// there is another label with the same name visible in the current scope.
     fn checked_label_add(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> Result<(), ParseError2> {
         debug_assert!(self.cur_scope.is_some());
         // Make sure label is not defined within the current scope or any of the
         // parent scope.
         let label = &ctx.heap[id];
         let mut scope = self.cur_scope.as_ref().unwrap();
         loop {
             debug_assert!(scope.is_block(), "scope is not a block");
             let block = &ctx.heap[scope.to_block()];
             for other_label_id in &block.labels {
                 let other_label = &ctx.heap[*other_label_id];
                 if other_label.label.value == label.label.value {
                     // Collision
                     return Err(
                         ParseError2::new_error(&ctx.module.source, label.position, "Label name conflicts with another label")
                             .with_postfixed_info(&ctx.module.source, other_label.position, "Other label is found here")
                     );
+                }
+            }
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();
             if !scope.is_block() {
                 break;
+            }
+        }
         // No collisions
         let block = &mut ctx.heap[self.cur_scope.as_ref().unwrap().to_block()];
         block.labels.push(id);
         Ok(())
+    }
     /// Finds a particular labeled statement by its identifier. Once found it
     /// will make sure that the target label does not skip over any variable
     /// declarations within the scope in which the label was found.
     fn find_label(&self, ctx: &Ctx, identifier: &Identifier) -> Result<LabeledStatementId, ParseError2> {
         debug_assert!(self.cur_scope.is_some());
         let mut scope = self.cur_scope.as_ref().unwrap();
         loop {
             debug_assert!(scope.is_block(), "scope is not a block");
             let relative_scope_pos = ctx.heap[scope.to_block()].relative_pos_in_parent;
             let block = &ctx.heap[scope.to_block()];
             for label_id in &block.labels {
                 let label = &ctx.heap[*label_id];
                 if label.label.value == identifier.value {
                     for local_id in &block.locals {
                         // TODO: Better to do this in control flow analysis, it
                         //  is legal to skip over a variable declaration if it
                         //  is not actually being used. I might be missing
                         //  something here when laying out the bytecode...
                         let local = &ctx.heap[*local_id];
                         if local.relative_pos_in_block > relative_scope_pos && local.relative_pos_in_block < label.relative_pos_in_block {
                             return Err(
                                 ParseError2::new_error(&ctx.module.source, identifier.position, "This target label skips over a variable declaration")
                                     .with_postfixed_info(&ctx.module.source, label.position, "Because it jumps to this label")
                                     .with_postfixed_info(&ctx.module.source, local.position, "Which skips over this variable")
                             );
+                        }
+                    }
                     return Ok(*label_id);
+                }
+            }
             debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent");
             scope = block.parent_scope.as_ref().unwrap();
             if !scope.is_block() {
                 return Err(ParseError2::new_error(&ctx.module.source, identifier.position, "Could not find this label"));
+            }
+        }
+    }
     /// Finds a particular symbol in the symbol table which must correspond to
     /// a definition of a particular type.
     // Note: root_id, symbols and types passed in explicitly to prevent
     //  borrowing errors
     fn find_symbol_of_type(
         &self, root_id: RootId, symbols: &SymbolTable, types: &TypeTable,
         identifier: &NamespacedIdentifier, expected_type_class: TypeClass
     ) -> FindOfTypeResult {
         // Find symbol associated with identifier
         let symbol = symbols.resolve_namespaced_symbol(root_id, &identifier);
         if symbol.is_none() { return FindOfTypeResult::NotFound; }
         let (symbol, iter) = symbol.unwrap();
         if iter.num_remaining() != 0 { return FindOfTypeResult::NotFound; }
         match &symbol.symbol {
             Symbol::Definition((_, definition_id)) => {
                 // Make sure definition is of the expected type
                 let definition_type = types.get_definition(definition_id);
                 debug_assert!(definition_type.is_some(), "Found symbol '{}' in symbol table, but not in type table", String::from_utf8_lossy(&identifier.value));
                 let definition_type_class = definition_type.unwrap().type_class();
                 if definition_type_class != expected_type_class {
                     FindOfTypeResult::TypeMismatch(definition_type_class.display_name())
                 } else {
                     FindOfTypeResult::Found(*definition_id)
+                }
             },
             Symbol::Namespace(_) => FindOfTypeResult::TypeMismatch("namespace"),
+        }
+    }
     /// This function will check if the provided while statement ID has a block
     /// statement that is one of our current parents.
     fn has_parent_while_scope(&self, ctx: &Ctx, id: WhileStatementId) -> bool {
         debug_assert!(self.cur_scope.is_some());
         let mut scope = self.cur_scope.as_ref().unwrap();
         let while_stmt = &ctx.heap[id];
         loop {
             debug_assert!(scope.is_block());
             let block = scope.to_block();
             if while_stmt.body == block.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)
+    }
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)