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

Changeset - 3bb9f89521a1

Parent rev.

Child rev.

[Not reviewed]

0 9 1

MH - 4 years ago 2021-05-25 18:58:12
contact@maxhenger.nl

Prepare for binding expression inference

5 files changed:

src/protocol/ast.rs

src/protocol/ast_printer.rs

src/protocol/parser/depth_visitor.rs

src/protocol/parser/pass_definitions.rs

src/protocol/parser/pass_typing.rs

Changeset was too big and was cut off... Show full diff anyway

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -433,1351 +433,1369 @@ pub struct ParserTypeIter<'a> { @@
 impl<'a> ParserTypeIter<'a> {
     fn new(elements: &'a [ParserTypeElement], parent_idx: usize) -> Self {
         debug_assert!(parent_idx < elements.len(), "parent index exceeds number of elements in ParserType");
         if elements[0].variant.num_embedded() == 0 {
             // Parent element does not have any embedded types, place
             // `cur_embedded_idx` at end so we will always return `None`
             Self{ elements, cur_embedded_idx: elements.len() }
         } else {
             // Parent element has an embedded type
             Self{ elements, cur_embedded_idx: parent_idx + 1 }
+        }
+    }
+}
 impl<'a> Iterator for ParserTypeIter<'a> {
     type Item = &'a [ParserTypeElement];
     fn next(&mut self) -> Option<Self::Item> {
         let elements_len = self.elements.len();
         if self.cur_embedded_idx >= elements_len {
             return None;
+        }
         // Seek to the end of the subtree
         let mut depth = 1;
         let start_element = self.cur_embedded_idx;
         while self.cur_embedded_idx < elements_len {
             let cur_element = &self.elements[self.cur_embedded_idx];
             let depth_change = cur_element.variant.num_embedded() as i32 - 1;
             depth += depth_change;
             debug_assert!(depth >= 0, "illegally constructed ParserType: {:?}", self.elements);
             self.cur_embedded_idx += 1;
             if depth == 0 {
                 break;
+            }
+        }
         debug_assert!(depth == 0, "illegally constructed ParserType: {:?}", self.elements);
         return Some(&self.elements[start_element..self.cur_embedded_idx]);
+    }
+}
 /// Specifies whether the symbolic type points to an actual user-defined type,
 /// or whether it points to a polymorphic argument within the definition (e.g.
 /// a defined variable `T var` within a function `int func<T>()`
 #[derive(Debug, Clone)]
 pub enum SymbolicParserTypeVariant {
     Definition(DefinitionId),
     // TODO: figure out if I need the DefinitionId here
     PolyArg(DefinitionId, usize), // index of polyarg in the definition
+}
 /// ConcreteType is the representation of a type after resolving symbolic types
 /// and performing type inference
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub enum ConcreteTypePart {
     // Special types (cannot be explicitly constructed by the programmer)
     Void,
     // Builtin types without nested types
     Message,
     Bool,
     UInt8, UInt16, UInt32, UInt64,
     SInt8, SInt16, SInt32, SInt64,
     Character, String,
     // Builtin types with one nested type
     Array,
     Slice,
     Input,
     Output,
     // User defined type with any number of nested types
     Instance(DefinitionId, u32),
+}
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct ConcreteType {
     pub(crate) parts: Vec<ConcreteTypePart>
+}
 impl Default for ConcreteType {
     fn default() -> Self {
         Self{ parts: Vec::new() }
+    }
+}
 // TODO: Remove at some point
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum PrimitiveType {
     Unassigned,
     Input,
     Output,
     Message,
     Boolean,
     Byte,
     Short,
     Int,
     Long,
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Type {
     pub primitive: PrimitiveType,
     pub array: bool,
+}
 #[allow(dead_code)]
 impl Type {
     pub const UNASSIGNED: Type = Type { primitive: PrimitiveType::Unassigned, array: false };
     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::Unassigned => {
                 write!(f, "unassigned")?;
+            }
             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")?;
+            }
+        }
         if self.array {
             write!(f, "[]")
         } else {
             Ok(())
+        }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 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")
+        }
+    }
+}
 /// `ScopeNode` is a helper that links scopes in two directions. It doesn't
 /// actually contain any information associated with the scope, this may be
 /// found on the AST elements that `Scope` points to.
 #[derive(Debug, Clone)]
 pub struct ScopeNode {
     pub parent: Scope,
     pub nested: Vec<Scope>,
+}
 impl ScopeNode {
     pub(crate) fn new_invalid() -> Self {
         ScopeNode{
             parent: Scope::Definition(DefinitionId::new_invalid()),
             nested: Vec::new(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub enum VariableKind {
     Parameter,
     Local,
     Parameter,      // in parameter list of function/component
     Local,          // declared in function/component body
     Binding,        // may be bound to in a binding expression (determined in validator/linker)
+}
 #[derive(Debug, Clone)]
 pub struct Variable {
     pub this: VariableId,
     // Parsing
     pub kind: VariableKind,
     pub parser_type: ParserType,
     pub identifier: Identifier,
     // Validator/linker
     pub relative_pos_in_block: u32,
     pub unique_id_in_scope: i32, // Temporary fix until proper bytecode/asm is generated
+}
 #[derive(Debug, Clone)]
 pub enum Definition {
     Struct(StructDefinition),
     Enum(EnumDefinition),
     Union(UnionDefinition),
     Component(ComponentDefinition),
     Function(FunctionDefinition),
+}
 impl Definition {
     pub fn is_struct(&self) -> bool {
         match self {
             Definition::Struct(_) => true,
             _ => false
+        }
+    }
     pub(crate) fn as_struct(&self) -> &StructDefinition {
         match self {
             Definition::Struct(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'StructDefinition'"),
+        }
+    }
     pub(crate) fn as_struct_mut(&mut self) -> &mut 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(crate) fn as_enum(&self) -> &EnumDefinition {
         match self {
             Definition::Enum(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'EnumDefinition'"),
+        }
+    }
     pub(crate) fn as_enum_mut(&mut self) -> &mut EnumDefinition {
         match self {
             Definition::Enum(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'EnumDefinition'"),
+        }
+    }
     pub fn is_union(&self) -> bool {
         match self {
             Definition::Union(_) => true,
             _ => false,
+        }
+    }
     pub(crate) fn as_union(&self) -> &UnionDefinition {
         match self {
             Definition::Union(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'UnionDefinition'"),
+        }
+    }
     pub(crate) fn as_union_mut(&mut self) -> &mut UnionDefinition {
         match self {
             Definition::Union(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'UnionDefinition'"),
+        }
+    }
     pub fn is_component(&self) -> bool {
         match self {
             Definition::Component(_) => true,
             _ => false,
+        }
+    }
     pub(crate) fn as_component(&self) -> &ComponentDefinition {
         match self {
             Definition::Component(result) => result,
             _ => panic!("Unable to cast `Definition` to `Component`"),
+        }
+    }
     pub(crate) fn as_component_mut(&mut self) -> &mut ComponentDefinition {
         match self {
             Definition::Component(result) => result,
             _ => panic!("Unable to cast `Definition` to `Component`"),
+        }
+    }
     pub fn is_function(&self) -> bool {
         match self {
             Definition::Function(_) => true,
             _ => false,
+        }
+    }
     pub(crate) fn as_function(&self) -> &FunctionDefinition {
         match self {
             Definition::Function(result) => result,
             _ => panic!("Unable to cast `Definition` to `Function`"),
+        }
+    }
     pub(crate) fn as_function_mut(&mut self) -> &mut FunctionDefinition {
         match self {
             Definition::Function(result) => result,
             _ => panic!("Unable to cast `Definition` to `Function`"),
+        }
+    }
     pub fn parameters(&self) -> &Vec<VariableId> {
         match self {
             Definition::Component(def) => &def.parameters,
             Definition::Function(def) => &def.parameters,
             _ => panic!("Called parameters() on {:?}", self)
+        }
+    }
     pub fn defined_in(&self) -> RootId {
         match self {
             Definition::Struct(def) => def.defined_in,
             Definition::Enum(def) => def.defined_in,
             Definition::Union(def) => def.defined_in,
             Definition::Component(def) => def.defined_in,
             Definition::Function(def) => def.defined_in,
+        }
+    }
     pub fn identifier(&self) -> &Identifier {
         match self {
             Definition::Struct(def) => &def.identifier,
             Definition::Enum(def) => &def.identifier,
             Definition::Union(def) => &def.identifier,
             Definition::Component(def) => &def.identifier,
             Definition::Function(def) => &def.identifier,
+        }
+    }
     pub fn poly_vars(&self) -> &Vec<Identifier> {
         match self {
             Definition::Struct(def) => &def.poly_vars,
             Definition::Enum(def) => &def.poly_vars,
             Definition::Union(def) => &def.poly_vars,
             Definition::Component(def) => &def.poly_vars,
             Definition::Function(def) => &def.poly_vars,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct StructFieldDefinition {
     pub span: InputSpan,
     pub field: Identifier,
     pub parser_type: ParserType,
+}
 #[derive(Debug, Clone)]
 pub struct StructDefinition {
     pub this: StructDefinitionId,
     pub defined_in: RootId,
     // Phase 1: symbol scanning
     pub span: InputSpan,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Phase 2: parsing
     pub fields: Vec<StructFieldDefinition>
+}
 impl StructDefinition {
     pub(crate) fn new_empty(
         this: StructDefinitionId, defined_in: RootId, span: InputSpan,
         identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self{ this, defined_in, span, identifier, poly_vars, fields: Vec::new() }
+    }
+}
 #[derive(Debug, Clone)]
 pub enum EnumVariantValue {
     None,
     Integer(i64),
+}
 #[derive(Debug, Clone)]
 pub struct EnumVariantDefinition {
     pub identifier: Identifier,
     pub value: EnumVariantValue,
+}
 #[derive(Debug, Clone)]
 pub struct EnumDefinition {
     pub this: EnumDefinitionId,
     pub defined_in: RootId,
-    // Phase 1: symbol scanning
+    // Symbol scanning
     pub span: InputSpan,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
-    // Phase 2: parsing
+    // Parsing
     pub variants: Vec<EnumVariantDefinition>,
+}
 impl EnumDefinition {
     pub(crate) fn new_empty(
         this: EnumDefinitionId, defined_in: RootId, span: InputSpan,
         identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self{ this, defined_in, span, identifier, poly_vars, variants: Vec::new() }
+    }
+}
 #[derive(Debug, Clone)]
 pub enum UnionVariantValue {
     None,
     Embedded(Vec<ParserType>),
+}
 #[derive(Debug, Clone)]
 pub struct UnionVariantDefinition {
     pub span: InputSpan,
     pub identifier: Identifier,
     pub value: UnionVariantValue,
+}
 #[derive(Debug, Clone)]
 pub struct UnionDefinition {
     pub this: UnionDefinitionId,
     pub defined_in: RootId,
     // Phase 1: symbol scanning
     pub span: InputSpan,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Phase 2: parsing
     pub variants: Vec<UnionVariantDefinition>,
+}
 impl UnionDefinition {
     pub(crate) fn new_empty(
         this: UnionDefinitionId, defined_in: RootId, span: InputSpan,
         identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self{ this, defined_in, span, identifier, poly_vars, variants: Vec::new() }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum ComponentVariant {
     Primitive,
     Composite,
+}
 #[derive(Debug, Clone)]
 pub struct ComponentDefinition {
     pub this: ComponentDefinitionId,
     pub defined_in: RootId,
     // Symbol scanning
     pub span: InputSpan,
     pub variant: ComponentVariant,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Parsing
     pub parameters: Vec<VariableId>,
     pub body: BlockStatementId,
     // Validation/linking
     pub num_expressions_in_body: i32,
+}
 impl ComponentDefinition {
     // Used for preallocation during symbol scanning
     pub(crate) fn new_empty(
         this: ComponentDefinitionId, defined_in: RootId, span: InputSpan,
         variant: ComponentVariant, identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self{
             this, defined_in, span, variant, identifier, poly_vars,
             parameters: Vec::new(),
             body: BlockStatementId::new_invalid(),
             num_expressions_in_body: -1,
+        }
+    }
+}
 // Note that we will have function definitions for builtin functions as well. In
 // that case the span, the identifier span and the body are all invalid.
 #[derive(Debug, Clone)]
 pub struct FunctionDefinition {
     pub this: FunctionDefinitionId,
     pub defined_in: RootId,
     // Symbol scanning
     pub builtin: bool,
     pub span: InputSpan,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Parser
     pub return_types: Vec<ParserType>,
     pub parameters: Vec<VariableId>,
     pub body: BlockStatementId,
     // Validation/linking
     pub num_expressions_in_body: i32,
+}
 impl FunctionDefinition {
     pub(crate) fn new_empty(
         this: FunctionDefinitionId, defined_in: RootId, span: InputSpan,
         identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self {
             this, defined_in,
             builtin: false,
             span, identifier, poly_vars,
             return_types: Vec::new(),
             parameters: Vec::new(),
             body: BlockStatementId::new_invalid(),
             num_expressions_in_body: -1,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub enum Statement {
     Block(BlockStatement),
     EndBlock(EndBlockStatement),
     Local(LocalStatement),
     Labeled(LabeledStatement),
     If(IfStatement),
     EndIf(EndIfStatement),
     While(WhileStatement),
     EndWhile(EndWhileStatement),
     Break(BreakStatement),
     Continue(ContinueStatement),
     Synchronous(SynchronousStatement),
     EndSynchronous(EndSynchronousStatement),
     Return(ReturnStatement),
     Goto(GotoStatement),
     New(NewStatement),
     Expression(ExpressionStatement),
+}
 impl Statement {
     pub fn is_block(&self) -> bool {
         match self {
             Statement::Block(_) => true,
             _ => false,
+        }
+    }
     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_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_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_expression(&self) -> &ExpressionStatement {
         match self {
             Statement::Expression(result) => result,
             _ => panic!("Unable to cast `Statement` to `ExpressionStatement`"),
+        }
+    }
     pub fn span(&self) -> InputSpan {
         match self {
             Statement::Block(v) => v.span,
             Statement::Local(v) => v.span(),
             Statement::Labeled(v) => v.label.span,
             Statement::If(v) => v.span,
             Statement::While(v) => v.span,
             Statement::Break(v) => v.span,
             Statement::Continue(v) => v.span,
             Statement::Synchronous(v) => v.span,
             Statement::Return(v) => v.span,
             Statement::Goto(v) => v.span,
             Statement::New(v) => v.span,
             Statement::Expression(v) => v.span,
             Statement::EndBlock(_) | Statement::EndIf(_) | Statement::EndWhile(_) | Statement::EndSynchronous(_) => unreachable!(),
+        }
+    }
     pub fn link_next(&mut self, next: StatementId) {
         match self {
             Statement::Block(_) => todo!(),
             Statement::EndBlock(stmt) => stmt.next = next,
             Statement::Local(stmt) => match stmt {
                 LocalStatement::Channel(stmt) => stmt.next = next,
                 LocalStatement::Memory(stmt) => stmt.next = next,
             },
             Statement::EndIf(stmt) => stmt.next = next,
             Statement::EndWhile(stmt) => stmt.next = next,
             Statement::EndSynchronous(stmt) => stmt.next = next,
             Statement::New(stmt) => stmt.next = next,
             Statement::Expression(stmt) => stmt.next = next,
             Statement::Return(_)
             | Statement::Break(_)
             | Statement::Continue(_)
             | Statement::Synchronous(_)
             | Statement::Goto(_)
             | Statement::While(_)
             | Statement::Labeled(_)
             | Statement::If(_) => unreachable!(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct BlockStatement {
     pub this: BlockStatementId,
     // Phase 1: parser
     pub is_implicit: bool,
     pub span: InputSpan, // of the complete block
     pub statements: Vec<StatementId>,
     pub end_block: EndBlockStatementId,
     // Phase 2: linker
-    pub parent_scope: Scope,
+    pub scope_node: ScopeNode,
     pub first_unique_id_in_scope: i32, // Temporary fix until proper bytecode/asm is generated
     pub next_unique_id_in_scope: i32, // Temporary fix until proper bytecode/asm is generated
     pub relative_pos_in_parent: u32,
     pub locals: Vec<VariableId>,
     pub labels: Vec<LabeledStatementId>,
+}
 #[derive(Debug, Clone)]
 pub struct EndBlockStatement {
     pub this: EndBlockStatementId,
     // Parser
     pub start_block: BlockStatementId,
     // Validation/Linking
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub enum LocalStatement {
     Memory(MemoryStatement),
     Channel(ChannelStatement),
+}
 impl LocalStatement {
     pub fn this(&self) -> LocalStatementId {
         match self {
             LocalStatement::Memory(stmt) => stmt.this.upcast(),
             LocalStatement::Channel(stmt) => stmt.this.upcast(),
+        }
+    }
     pub fn as_memory(&self) -> &MemoryStatement {
         match self {
             LocalStatement::Memory(result) => result,
             _ => panic!("Unable to cast `LocalStatement` to `MemoryStatement`"),
+        }
+    }
     pub fn as_channel(&self) -> &ChannelStatement {
         match self {
             LocalStatement::Channel(result) => result,
             _ => panic!("Unable to cast `LocalStatement` to `ChannelStatement`"),
+        }
+    }
     pub fn span(&self) -> InputSpan {
         match self {
             LocalStatement::Channel(v) => v.span,
             LocalStatement::Memory(v) => v.span,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct MemoryStatement {
     pub this: MemoryStatementId,
     // Phase 1: parser
     pub span: InputSpan,
     pub variable: VariableId,
     // Phase 2: linker
     pub next: StatementId,
+}
 /// ChannelStatement is the declaration of an input and output port associated
 /// with the same channel. Note that the polarity of the ports are from the
 /// point of view of the component. So an output port is something that a
 /// component uses to send data over (i.e. it is the "input end" of the
 /// channel), and vice versa.
 #[derive(Debug, Clone)]
 pub struct ChannelStatement {
     pub this: ChannelStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "channel" keyword
     pub from: VariableId, // output
     pub to: VariableId,   // input
     // Phase 2: linker
     pub relative_pos_in_block: u32,
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct LabeledStatement {
     pub this: LabeledStatementId,
     // Phase 1: parser
     pub label: Identifier,
     pub body: StatementId,
     // Phase 2: linker
     pub relative_pos_in_block: u32,
-    pub in_sync: Option<SynchronousStatementId>,
+    pub in_sync: SynchronousStatementId, // may be invalid
+}
 #[derive(Debug, Clone)]
 pub struct IfStatement {
     pub this: IfStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "if" keyword
     pub test: ExpressionId,
     pub true_body: BlockStatementId,
     pub false_body: Option<BlockStatementId>,
     pub end_if: EndIfStatementId,
+}
 #[derive(Debug, Clone)]
 pub struct EndIfStatement {
     pub this: EndIfStatementId,
     pub start_if: IfStatementId,
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct WhileStatement {
     pub this: WhileStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "while" keyword
     pub test: ExpressionId,
     pub body: BlockStatementId,
     pub end_while: EndWhileStatementId,
-    pub in_sync: Option<SynchronousStatementId>,
+    pub in_sync: SynchronousStatementId, // may be invalid
+}
 #[derive(Debug, Clone)]
 pub struct EndWhileStatement {
     pub this: EndWhileStatementId,
     pub start_while: WhileStatementId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct BreakStatement {
     pub this: BreakStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "break" keyword
     pub label: Option<Identifier>,
     // Phase 2: linker
     pub target: Option<EndWhileStatementId>,
+}
 #[derive(Debug, Clone)]
 pub struct ContinueStatement {
     pub this: ContinueStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "continue" keyword
     pub label: Option<Identifier>,
     // Phase 2: linker
     pub target: Option<WhileStatementId>,
+}
 #[derive(Debug, Clone)]
 pub struct SynchronousStatement {
     pub this: SynchronousStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "sync" keyword
     pub body: BlockStatementId,
     // Phase 2: linker
     pub end_sync: EndSynchronousStatementId,
     pub parent_scope: Option<Scope>,
+}
 #[derive(Debug, Clone)]
 pub struct EndSynchronousStatement {
     pub this: EndSynchronousStatementId,
     pub start_sync: SynchronousStatementId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct ReturnStatement {
     pub this: ReturnStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "return" keyword
     pub expressions: Vec<ExpressionId>,
+}
 #[derive(Debug, Clone)]
 pub struct GotoStatement {
     pub this: GotoStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "goto" keyword
     pub label: Identifier,
     // Phase 2: linker
     pub target: Option<LabeledStatementId>,
+}
 #[derive(Debug, Clone)]
 pub struct NewStatement {
     pub this: NewStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "new" keyword
     pub expression: CallExpressionId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct ExpressionStatement {
     pub this: ExpressionStatementId,
     // Phase 1: parser
     pub span: InputSpan,
     pub expression: ExpressionId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum ExpressionParent {
     None, // only set during initial parsing
     If(IfStatementId),
     While(WhileStatementId),
     Return(ReturnStatementId),
     New(NewStatementId),
     ExpressionStmt(ExpressionStatementId),
     Expression(ExpressionId, u32) // index within expression (e.g LHS or RHS of expression)
+}
 impl ExpressionParent {
     pub fn is_new(&self) -> bool {
         match self {
             ExpressionParent::New(_) => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub enum Expression {
     Assignment(AssignmentExpression),
     Binding(BindingExpression),
     Conditional(ConditionalExpression),
     Binary(BinaryExpression),
     Unary(UnaryExpression),
     Indexing(IndexingExpression),
     Slicing(SlicingExpression),
     Select(SelectExpression),
     Literal(LiteralExpression),
     Cast(CastExpression),
     Call(CallExpression),
     Variable(VariableExpression),
+}
 impl Expression {
     pub fn as_assignment(&self) -> &AssignmentExpression {
         match self {
             Expression::Assignment(result) => result,
             _ => panic!("Unable to cast `Expression` to `AssignmentExpression`"),
+        }
+    }
     pub fn as_conditional(&self) -> &ConditionalExpression {
         match self {
             Expression::Conditional(result) => result,
             _ => panic!("Unable to cast `Expression` to `ConditionalExpression`"),
+        }
+    }
     pub fn as_binary(&self) -> &BinaryExpression {
         match self {
             Expression::Binary(result) => result,
             _ => panic!("Unable to cast `Expression` to `BinaryExpression`"),
+        }
+    }
     pub fn as_unary(&self) -> &UnaryExpression {
         match self {
             Expression::Unary(result) => result,
             _ => panic!("Unable to cast `Expression` to `UnaryExpression`"),
+        }
+    }
     pub fn as_indexing(&self) -> &IndexingExpression {
         match self {
             Expression::Indexing(result) => result,
             _ => panic!("Unable to cast `Expression` to `IndexingExpression`"),
+        }
+    }
     pub fn as_slicing(&self) -> &SlicingExpression {
         match self {
             Expression::Slicing(result) => result,
             _ => panic!("Unable to cast `Expression` to `SlicingExpression`"),
+        }
+    }
     pub fn as_select(&self) -> &SelectExpression {
         match self {
             Expression::Select(result) => result,
             _ => panic!("Unable to cast `Expression` to `SelectExpression`"),
+        }
+    }
     pub fn as_call(&self) -> &CallExpression {
         match self {
             Expression::Call(result) => result,
             _ => panic!("Unable to cast `Expression` to `CallExpression`"),
+        }
+    }
     pub fn as_call_mut(&mut self) -> &mut CallExpression {
         match self {
             Expression::Call(result) => result,
             _ => panic!("Unable to cast `Expression` to `CallExpression`"),
+        }
+    }
     pub fn as_variable(&self) -> &VariableExpression {
         match self {
             Expression::Variable(result) => result,
             _ => panic!("Unable to cast `Expression` to `VariableExpression`"),
+        }
+    }
     pub fn as_variable_mut(&mut self) -> &mut VariableExpression {
         match self {
             Expression::Variable(result) => result,
             _ => panic!("Unable to cast `Expression` to `VariableExpression`"),
+        }
+    }
     pub fn span(&self) -> InputSpan {
         match self {
             Expression::Assignment(expr) => expr.span,
             Expression::Binding(expr) => expr.span,
             Expression::Conditional(expr) => expr.span,
             Expression::Binary(expr) => expr.span,
             Expression::Unary(expr) => expr.span,
             Expression::Indexing(expr) => expr.span,
             Expression::Slicing(expr) => expr.span,
             Expression::Select(expr) => expr.span,
             Expression::Literal(expr) => expr.span,
             Expression::Cast(expr) => expr.span,
             Expression::Call(expr) => expr.span,
             Expression::Variable(expr) => expr.identifier.span,
+        }
+    }
     // TODO: @cleanup
     pub fn parent(&self) -> &ExpressionParent {
         match self {
             Expression::Assignment(expr) => &expr.parent,
             Expression::Binding(expr) => &expr.parent,
             Expression::Conditional(expr) => &expr.parent,
             Expression::Binary(expr) => &expr.parent,
             Expression::Unary(expr) => &expr.parent,
             Expression::Indexing(expr) => &expr.parent,
             Expression::Slicing(expr) => &expr.parent,
             Expression::Select(expr) => &expr.parent,
             Expression::Literal(expr) => &expr.parent,
             Expression::Cast(expr) => &expr.parent,
             Expression::Call(expr) => &expr.parent,
             Expression::Variable(expr) => &expr.parent,
+        }
+    }
     // TODO: @cleanup
     pub fn parent_expr_id(&self) -> Option<ExpressionId> {
         if let ExpressionParent::Expression(id, _) = self.parent() {
             Some(*id)
         } else {
             None
+        }
+    }
     // TODO: @cleanup
     pub fn set_parent(&mut self, parent: ExpressionParent) {
         match self {
             Expression::Assignment(expr) => expr.parent = parent,
             Expression::Binding(expr) => expr.parent = parent,
             Expression::Conditional(expr) => expr.parent = parent,
             Expression::Binary(expr) => expr.parent = parent,
             Expression::Unary(expr) => expr.parent = parent,
             Expression::Indexing(expr) => expr.parent = parent,
             Expression::Slicing(expr) => expr.parent = parent,
             Expression::Select(expr) => expr.parent = parent,
             Expression::Literal(expr) => expr.parent = parent,
             Expression::Cast(expr) => expr.parent = parent,
             Expression::Call(expr) => expr.parent = parent,
             Expression::Variable(expr) => expr.parent = parent,
+        }
+    }
     pub fn get_unique_id_in_definition(&self) -> i32 {
         match self {
             Expression::Assignment(expr) => expr.unique_id_in_definition,
             Expression::Binding(expr) => expr.unique_id_in_definition,
             Expression::Conditional(expr) => expr.unique_id_in_definition,
             Expression::Binary(expr) => expr.unique_id_in_definition,
             Expression::Unary(expr) => expr.unique_id_in_definition,
             Expression::Indexing(expr) => expr.unique_id_in_definition,
             Expression::Slicing(expr) => expr.unique_id_in_definition,
             Expression::Select(expr) => expr.unique_id_in_definition,
             Expression::Literal(expr) => expr.unique_id_in_definition,
             Expression::Cast(expr) => expr.unique_id_in_definition,
             Expression::Call(expr) => expr.unique_id_in_definition,
             Expression::Variable(expr) => expr.unique_id_in_definition,
+        }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum AssignmentOperator {
     Set,
     Multiplied,
     Divided,
     Remained,
     Added,
     Subtracted,
     ShiftedLeft,
     ShiftedRight,
     BitwiseAnded,
     BitwiseXored,
     BitwiseOred,
+}
 #[derive(Debug, Clone)]
 pub struct AssignmentExpression {
     pub this: AssignmentExpressionId,
     // Parsing
     pub span: InputSpan, // of the operator
     pub left: ExpressionId,
     pub operation: AssignmentOperator,
     pub right: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct BindingExpression {
     pub this: BindingExpressionId,
     // Parsing
     pub span: InputSpan,
     pub left: LiteralExpressionId,
     pub right: ExpressionId,
     pub span: InputSpan, // of the binding keyword
     pub bound_to: ExpressionId,
     pub bound_from: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct ConditionalExpression {
     pub this: ConditionalExpressionId,
     // Parsing
     pub span: InputSpan, // of question mark operator
     pub test: ExpressionId,
     pub true_expression: ExpressionId,
     pub false_expression: ExpressionId,
     // Validator/Linking
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum BinaryOperator {
     Concatenate,
     LogicalOr,
     LogicalAnd,
     BitwiseOr,
     BitwiseXor,
     BitwiseAnd,
     Equality,
     Inequality,
     LessThan,
     GreaterThan,
     LessThanEqual,
     GreaterThanEqual,
     ShiftLeft,
     ShiftRight,
     Add,
     Subtract,
     Multiply,
     Divide,
     Remainder,
+}
 #[derive(Debug, Clone)]
 pub struct BinaryExpression {
     pub this: BinaryExpressionId,
     // Parsing
     pub span: InputSpan, // of the operator
     pub left: ExpressionId,
     pub operation: BinaryOperator,
     pub right: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum UnaryOperator {
     Positive,
     Negative,
     BitwiseNot,
     LogicalNot,
     PreIncrement,
     PreDecrement,
     PostIncrement,
     PostDecrement,
+}
 #[derive(Debug, Clone)]
 pub struct UnaryExpression {
     pub this: UnaryExpressionId,
     // Parsing
     pub span: InputSpan, // of the operator
     pub operation: UnaryOperator,
     pub expression: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct IndexingExpression {
     pub this: IndexingExpressionId,
     // Parsing
     pub span: InputSpan,
     pub subject: ExpressionId,
     pub index: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct SlicingExpression {
     pub this: SlicingExpressionId,
     // Parsing
     pub span: InputSpan, // from '[' to ']';
     pub subject: ExpressionId,
     pub from_index: ExpressionId,
     pub to_index: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct SelectExpression {
     pub this: SelectExpressionId,
     // Parsing
     pub span: InputSpan, // of the '.'
     pub subject: ExpressionId,
     pub field_name: Identifier,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct CastExpression {
     pub this: CastExpressionId,
     // Parsing
     pub span: InputSpan, // of the "cast" keyword,
     pub to_type: ParserType,
     pub subject: ExpressionId,
     // Validator/linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct CallExpression {
     pub this: CallExpressionId,
     // Parsing
     pub span: InputSpan,
     pub parser_type: ParserType, // of the function call, not the return type
     pub method: Method,
     pub arguments: Vec<ExpressionId>,
     pub definition: DefinitionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Method {
     // Builtin
     Get,
     Put,
     Fires,
     Create,
     Length,
     Assert,
     UserFunction,
     UserComponent,
+}
 #[derive(Debug, Clone)]
 pub struct MethodSymbolic {
     pub(crate) parser_type: ParserType,
     pub(crate) definition: DefinitionId
+}
 #[derive(Debug, Clone)]
 pub struct LiteralExpression {
     pub this: LiteralExpressionId,
     // Parsing
     pub span: InputSpan,
     pub value: Literal,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub enum Literal {
     Null, // message
     True,
     False,
     Character(char),
     String(StringRef<'static>),
     Integer(LiteralInteger),
     Struct(LiteralStruct),
     Enum(LiteralEnum),
     Union(LiteralUnion),
     Array(Vec<ExpressionId>),
+}
 impl Literal {
     pub(crate) fn as_struct(&self) -> &LiteralStruct {
         if let Literal::Struct(literal) = self{
             literal
         } else {
             unreachable!("Attempted to obtain {:?} as Literal::Struct", self)
+        }

src/protocol/ast_printer.rs

➞

Show inline comments

@@ @@ -283,481 +283,481 @@ impl ASTWriter { @@
                 for poly_var_id in &def.poly_vars {
                     self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("Fields");
                 for field in &def.fields {
                     self.kv(indent3).with_s_key("Field");
                     self.kv(indent4).with_s_key("Name")
                         .with_identifier_val(&field.field);
                     self.kv(indent4).with_s_key("Type")
                         .with_custom_val(|s| write_parser_type(s, heap, &field.parser_type));
+                }
             },
             Definition::Enum(def) => {
                 self.kv(indent).with_id(PREFIX_ENUM_ID, def.this.0.index)
                     .with_s_key("DefinitionEnum");
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 for poly_var_id in &def.poly_vars {
                     self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("Variants");
                 for variant in &def.variants {
                     self.kv(indent3).with_s_key("Variant");
                     self.kv(indent4).with_s_key("Name")
                         .with_identifier_val(&variant.identifier);
                     let variant_value = self.kv(indent4).with_s_key("Value");
                     match &variant.value {
                         EnumVariantValue::None => variant_value.with_s_val("None"),
                         EnumVariantValue::Integer(value) => variant_value.with_disp_val(value),
                     };
+                }
             },
             Definition::Union(def) => {
                 self.kv(indent).with_id(PREFIX_UNION_ID, def.this.0.index)
                     .with_s_key("DefinitionUnion");
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 for poly_var_id in &def.poly_vars {
                     self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("Variants");
                 for variant in &def.variants {
                     self.kv(indent3).with_s_key("Variant");
                     self.kv(indent4).with_s_key("Name")
                         .with_identifier_val(&variant.identifier);
                     match &variant.value {
                         UnionVariantValue::None => {
                             self.kv(indent4).with_s_key("Value").with_s_val("None");
+                        }
                         UnionVariantValue::Embedded(embedded) => {
                             self.kv(indent4).with_s_key("Values");
                             for embedded in embedded {
                                 self.kv(indent4+1).with_s_key("Value")
                                     .with_custom_val(|v| write_parser_type(v, heap, embedded));
+                            }
+                        }
+                    }
+                }
+            }
             Definition::Function(def) => {
                 self.kv(indent).with_id(PREFIX_FUNCTION_ID, def.this.0.index)
                     .with_s_key("DefinitionFunction");
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 for poly_var_id in &def.poly_vars {
                     self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("ReturnParserTypes");
                 for return_type in &def.return_types {
                     self.kv(indent3).with_s_key("ReturnParserType")
                         .with_custom_val(|s| write_parser_type(s, heap, return_type));
+                }
                 self.kv(indent2).with_s_key("Parameters");
                 for variable_id in &def.parameters {
                     self.write_variable(heap, *variable_id, indent3);
+                }
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, def.body.upcast(), indent3);
             },
             Definition::Component(def) => {
                 self.kv(indent).with_id(PREFIX_COMPONENT_ID,def.this.0.index)
                     .with_s_key("DefinitionComponent");
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 self.kv(indent2).with_s_key("Variant").with_debug_val(&def.variant);
                 self.kv(indent2).with_s_key("PolymorphicVariables");
                 for poly_var_id in &def.poly_vars {
                     self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("Parameters");
                 for variable_id in &def.parameters {
                     self.write_variable(heap, *variable_id, indent3)
+                }
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, def.body.upcast(), 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.index)
                     .with_s_key("Block");
                 self.kv(indent2).with_s_key("EndBlockID").with_disp_val(&stmt.end_block.0.index);
                 self.kv(indent2).with_s_key("FirstUniqueScopeID").with_disp_val(&stmt.first_unique_id_in_scope);
                 self.kv(indent2).with_s_key("NextUniqueScopeID").with_disp_val(&stmt.next_unique_id_in_scope);
                 self.kv(indent2).with_s_key("RelativePos").with_disp_val(&stmt.relative_pos_in_parent);
                 self.kv(indent2).with_s_key("Statements");
                 for stmt_id in &stmt.statements {
                     self.write_stmt(heap, *stmt_id, indent3);
+                }
             },
             Statement::EndBlock(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDBLOCK_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndBlock");
                 self.kv(indent2).with_s_key("StartBlockID").with_disp_val(&stmt.start_block.0.index);
+            }
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Channel(stmt) => {
                         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_variable(heap, stmt.from, indent3);
                         self.kv(indent2).with_s_key("To");
                         self.write_variable(heap, stmt.to, indent3);
                         self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
                     },
                     LocalStatement::Memory(stmt) => {
                         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_variable(heap, stmt.variable, indent3);
                         self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
+                    }
+                }
             },
             Statement::Labeled(stmt) => {
                 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_identifier_val(&stmt.label);
                 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.index)
                     .with_s_key("If");
                 self.kv(indent2).with_s_key("EndIf").with_disp_val(&stmt.end_if.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.upcast(), indent3);
                 if let Some(false_body) = stmt.false_body {
                     self.kv(indent2).with_s_key("FalseBody");
                     self.write_stmt(heap, false_body.upcast(), indent3);
+                }
             },
             Statement::EndIf(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDIF_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndIf");
                 self.kv(indent2).with_s_key("StartIf").with_disp_val(&stmt.start_if.0.index);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
             },
             Statement::While(stmt) => {
                 self.kv(indent).with_id(PREFIX_WHILE_STMT_ID, stmt.this.0.index)
                     .with_s_key("While");
                 self.kv(indent2).with_s_key("EndWhile").with_disp_val(&stmt.end_while.0.index);
                 self.kv(indent2).with_s_key("InSync")
-                    .with_opt_disp_val(stmt.in_sync.as_ref().map(|v| &v.0.index));
+                    .with_disp_val(&stmt.in_sync.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.upcast(), indent3);
             },
             Statement::EndWhile(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDWHILE_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndWhile");
                 self.kv(indent2).with_s_key("StartWhile").with_disp_val(&stmt.start_while.0.index);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
             },
             Statement::Break(stmt) => {
                 self.kv(indent).with_id(PREFIX_BREAK_STMT_ID, stmt.this.0.index)
                     .with_s_key("Break");
                 self.kv(indent2).with_s_key("Label")
                     .with_opt_identifier_val(stmt.label.as_ref());
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.index));
             },
             Statement::Continue(stmt) => {
                 self.kv(indent).with_id(PREFIX_CONTINUE_STMT_ID, stmt.this.0.index)
                     .with_s_key("Continue");
                 self.kv(indent2).with_s_key("Label")
                     .with_opt_identifier_val(stmt.label.as_ref());
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.index));
             },
             Statement::Synchronous(stmt) => {
                 self.kv(indent).with_id(PREFIX_SYNC_STMT_ID, stmt.this.0.index)
                     .with_s_key("Synchronous");
                 self.kv(indent2).with_s_key("EndSync").with_disp_val(&stmt.end_sync.0.index);
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, stmt.body.upcast(), indent3);
             },
             Statement::EndSynchronous(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDSYNC_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndSynchronous");
                 self.kv(indent2).with_s_key("StartSync").with_disp_val(&stmt.start_sync.0.index);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
             },
             Statement::Return(stmt) => {
                 self.kv(indent).with_id(PREFIX_RETURN_STMT_ID, stmt.this.0.index)
                     .with_s_key("Return");
                 self.kv(indent2).with_s_key("Expressions");
                 for expr_id in &stmt.expressions {
                     self.write_expr(heap, *expr_id, indent3);
+                }
             },
             Statement::Goto(stmt) => {
                 self.kv(indent).with_id(PREFIX_GOTO_STMT_ID, stmt.this.0.index)
                     .with_s_key("Goto");
                 self.kv(indent2).with_s_key("Label").with_identifier_val(&stmt.label);
                 self.kv(indent2).with_s_key("Target")
                     .with_opt_disp_val(stmt.target.as_ref().map(|v| &v.0.index));
             },
             Statement::New(stmt) => {
                 self.kv(indent).with_id(PREFIX_NEW_STMT_ID, stmt.this.0.index)
                     .with_s_key("New");
                 self.kv(indent2).with_s_key("Expression");
                 self.write_expr(heap, stmt.expression.upcast(), indent3);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
             },
             Statement::Expression(stmt) => {
                 self.kv(indent).with_id(PREFIX_EXPR_STMT_ID, stmt.this.0.index)
                     .with_s_key("ExpressionStatement");
                 self.write_expr(heap, stmt.expression, indent2);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.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;
         let def_id = self.cur_definition.unwrap();
         match expr {
             Expression::Assignment(expr) => {
                 self.kv(indent).with_id(PREFIX_ASSIGNMENT_EXPR_ID, expr.this.0.index)
                     .with_s_key("AssignmentExpr");
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Left");
                 self.write_expr(heap, expr.left, indent3);
                 self.kv(indent2).with_s_key("Right");
                 self.write_expr(heap, expr.right, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Binding(expr) => {
                 self.kv(indent).with_id(PREFIX_BINARY_EXPR_ID, expr.this.0.index)
                     .with_s_key("BindingExpr");
                 self.kv(indent2).with_s_key("LeftExpression");
                 self.write_expr(heap, expr.left.upcast(), indent3);
                 self.kv(indent2).with_s_key("RightExpression");
                 self.write_expr(heap, expr.right, indent3);
                 self.kv(indent2).with_s_key("BindToExpression");
                 self.write_expr(heap, expr.bound_to, indent3);
                 self.kv(indent2).with_s_key("BindFromExpression");
                 self.write_expr(heap, expr.bound_from, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Conditional(expr) => {
                 self.kv(indent).with_id(PREFIX_CONDITIONAL_EXPR_ID, expr.this.0.index)
                     .with_s_key("ConditionalExpr");
                 self.kv(indent2).with_s_key("Condition");
                 self.write_expr(heap, expr.test, indent3);
                 self.kv(indent2).with_s_key("TrueExpression");
                 self.write_expr(heap, expr.true_expression, indent3);
                 self.kv(indent2).with_s_key("FalseExpression");
                 self.write_expr(heap, expr.false_expression, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Binary(expr) => {
                 self.kv(indent).with_id(PREFIX_BINARY_EXPR_ID, expr.this.0.index)
                     .with_s_key("BinaryExpr");
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Left");
                 self.write_expr(heap, expr.left, indent3);
                 self.kv(indent2).with_s_key("Right");
                 self.write_expr(heap, expr.right, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Unary(expr) => {
                 self.kv(indent).with_id(PREFIX_UNARY_EXPR_ID, expr.this.0.index)
                     .with_s_key("UnaryExpr");
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Argument");
                 self.write_expr(heap, expr.expression, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Indexing(expr) => {
                 self.kv(indent).with_id(PREFIX_INDEXING_EXPR_ID, expr.this.0.index)
                     .with_s_key("IndexingExpr");
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("Index");
                 self.write_expr(heap, expr.index, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Slicing(expr) => {
                 self.kv(indent).with_id(PREFIX_SLICING_EXPR_ID, expr.this.0.index)
                     .with_s_key("SlicingExpr");
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("FromIndex");
                 self.write_expr(heap, expr.from_index, indent3);
                 self.kv(indent2).with_s_key("ToIndex");
                 self.write_expr(heap, expr.to_index, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Select(expr) => {
                 self.kv(indent).with_id(PREFIX_SELECT_EXPR_ID, expr.this.0.index)
                     .with_s_key("SelectExpr");
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("Field").with_identifier_val(&expr.field_name);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Literal(expr) => {
                 self.kv(indent).with_id(PREFIX_LITERAL_EXPR_ID, expr.this.0.index)
                     .with_s_key("LiteralExpr");
                 let val = self.kv(indent2).with_s_key("Value");
                 match &expr.value {
                     Literal::Null => { val.with_s_val("null"); },
                     Literal::True => { val.with_s_val("true"); },
                     Literal::False => { val.with_s_val("false"); },
                     Literal::Character(data) => { val.with_disp_val(data); },
                     Literal::String(data) => {
                         // Stupid hack
                         let string = String::from(data.as_str());
                         val.with_disp_val(&string);
                     },
                     Literal::Integer(data) => { val.with_debug_val(data); },
                     Literal::Struct(data) => {
                         val.with_s_val("Struct");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("ParserType")
                             .with_custom_val(|t| write_parser_type(t, heap, &data.parser_type));
                         self.kv(indent3).with_s_key("Definition").with_disp_val(&data.definition.index);
                         for field in &data.fields {
                             self.kv(indent3).with_s_key("Field");
                             self.kv(indent4).with_s_key("Name").with_identifier_val(&field.identifier);
                             self.kv(indent4).with_s_key("Index").with_disp_val(&field.field_idx);
                             self.kv(indent4).with_s_key("ParserType");
                             self.write_expr(heap, field.value, indent4 + 1);
+                        }
                     },
                     Literal::Enum(data) => {
                         val.with_s_val("Enum");
                         self.kv(indent3).with_s_key("ParserType")
                             .with_custom_val(|t| write_parser_type(t, heap, &data.parser_type));
                         self.kv(indent3).with_s_key("Definition").with_disp_val(&data.definition.index);
                         self.kv(indent3).with_s_key("VariantIdx").with_disp_val(&data.variant_idx);
                     },
                     Literal::Union(data) => {
                         val.with_s_val("Union");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("ParserType")
                             .with_custom_val(|t| write_parser_type(t, heap, &data.parser_type));
                         self.kv(indent3).with_s_key("Definition").with_disp_val(&data.definition.index);
                         self.kv(indent3).with_s_key("VariantIdx").with_disp_val(&data.variant_idx);
                         for value in &data.values {
                             self.kv(indent3).with_s_key("Value");
                             self.write_expr(heap, *value, indent4);
+                        }
+                    }
                     Literal::Array(data) => {
                         val.with_s_val("Array");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("Elements");
                         for expr_id in data {
                             self.write_expr(heap, *expr_id, indent4);
+                        }
+                    }
+                }
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Cast(expr) => {
                 todo!("print casting expression")
+            }
             Expression::Call(expr) => {
                 self.kv(indent).with_id(PREFIX_CALL_EXPR_ID, expr.this.0.index)
                     .with_s_key("CallExpr");
                 let definition = &heap[expr.definition];
                 match definition {
                     Definition::Component(definition) => {
                         self.kv(indent2).with_s_key("BuiltIn").with_disp_val(&false);
                         self.kv(indent2).with_s_key("Variant").with_debug_val(&definition.variant);
                     },
                     Definition::Function(definition) => {
                         self.kv(indent2).with_s_key("BuiltIn").with_disp_val(&definition.builtin);
                         self.kv(indent2).with_s_key("Variant").with_s_val("Function");
                     },
                     _ => unreachable!()
+                }
                 self.kv(indent2).with_s_key("MethodName").with_identifier_val(definition.identifier());
                 self.kv(indent2).with_s_key("ParserType")
                     .with_custom_val(|t| write_parser_type(t, heap, &expr.parser_type));
                 // Arguments
                 self.kv(indent2).with_s_key("Arguments");
                 for arg_id in &expr.arguments {
                     self.write_expr(heap, *arg_id, indent3);
+                }
                 // Parent
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Variable(expr) => {
                 self.kv(indent).with_id(PREFIX_VARIABLE_EXPR_ID, expr.this.0.index)
                     .with_s_key("VariableExpr");
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&expr.identifier);
                 self.kv(indent2).with_s_key("Definition")
                     .with_opt_disp_val(expr.declaration.as_ref().map(|v| &v.index));
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
+            }
+        }
+    }
     fn write_variable(&mut self, heap: &Heap, variable_id: VariableId, indent: usize) {
         let var = &heap[variable_id];
         let indent2 = indent + 1;
         self.kv(indent).with_id(PREFIX_VARIABLE_ID, variable_id.index)
             .with_s_key("Variable");
         self.kv(indent2).with_s_key("Name").with_identifier_val(&var.identifier);
         self.kv(indent2).with_s_key("Kind").with_debug_val(&var.kind);
         self.kv(indent2).with_s_key("ParserType")
             .with_custom_val(|w| write_parser_type(w, heap, &var.parser_type));
         self.kv(indent2).with_s_key("RelativePos").with_disp_val(&var.relative_pos_in_block);

src/protocol/parser/depth_visitor.rs

➞

Show inline comments

@@ @@ -235,386 +235,386 @@ fn recursive_component_definition<T: Visitor>( @@
     this: &mut T,
     h: &mut Heap,
     def: ComponentDefinitionId,
 ) -> VisitorResult {
     let component_variant = h[def].variant;
     match component_variant {
         ComponentVariant::Primitive => this.visit_primitive_definition(h, def),
         ComponentVariant::Composite => this.visit_composite_definition(h, def),
+    }
+}
 fn recursive_composite_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: ComponentDefinitionId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
         this.visit_variable_declaration(h, param)?;
+    }
     this.visit_block_statement(h, h[def].body)
+}
 fn recursive_primitive_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: ComponentDefinitionId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
         this.visit_variable_declaration(h, param)?;
+    }
     this.visit_block_statement(h, h[def].body)
+}
 fn recursive_function_definition<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     def: FunctionDefinitionId,
 ) -> VisitorResult {
     for &param in h[def].parameters.clone().iter() {
         this.visit_variable_declaration(h, param)?;
+    }
     this.visit_block_statement(h, h[def].body)
+}
 fn recursive_statement<T: Visitor>(this: &mut T, h: &mut Heap, stmt: StatementId) -> VisitorResult {
     match h[stmt].clone() {
         Statement::Block(stmt) => this.visit_block_statement(h, stmt.this),
         Statement::EndBlock(stmt) => this.visit_end_block_statement(h, stmt.this),
         Statement::Local(stmt) => this.visit_local_statement(h, stmt.this()),
         Statement::Labeled(stmt) => this.visit_labeled_statement(h, stmt.this),
         Statement::If(stmt) => this.visit_if_statement(h, stmt.this),
         Statement::While(stmt) => this.visit_while_statement(h, stmt.this),
         Statement::Break(stmt) => this.visit_break_statement(h, stmt.this),
         Statement::Continue(stmt) => this.visit_continue_statement(h, stmt.this),
         Statement::Synchronous(stmt) => this.visit_synchronous_statement(h, stmt.this),
         Statement::Return(stmt) => this.visit_return_statement(h, stmt.this),
         Statement::Goto(stmt) => this.visit_goto_statement(h, stmt.this),
         Statement::New(stmt) => this.visit_new_statement(h, stmt.this),
         Statement::Expression(stmt) => this.visit_expression_statement(h, stmt.this),
         Statement::EndSynchronous(stmt) => this.visit_end_synchronous_statement(h, stmt.this),
         Statement::EndWhile(stmt) => this.visit_end_while_statement(h, stmt.this),
         Statement::EndIf(stmt) => this.visit_end_if_statement(h, stmt.this),
+    }
+}
 fn recursive_block_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     block: BlockStatementId,
 ) -> VisitorResult {
     for &local in h[block].locals.clone().iter() {
         this.visit_variable_declaration(h, local)?;
+    }
     for &stmt in h[block].statements.clone().iter() {
         this.visit_statement(h, stmt)?;
+    }
     Ok(())
+}
 fn recursive_local_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: LocalStatementId,
 ) -> VisitorResult {
     match h[stmt].clone() {
         LocalStatement::Channel(stmt) => this.visit_channel_statement(h, stmt.this),
         LocalStatement::Memory(stmt) => this.visit_memory_statement(h, stmt.this),
+    }
+}
 fn recursive_labeled_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: LabeledStatementId,
 ) -> VisitorResult {
     this.visit_statement(h, h[stmt].body)
+}
 fn recursive_if_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: IfStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].test)?;
     this.visit_block_statement(h, h[stmt].true_body)?;
     if let Some(false_body) = h[stmt].false_body {
         this.visit_block_statement(h, false_body)?;
+    }
     Ok(())
+}
 fn recursive_while_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: WhileStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].test)?;
     this.visit_block_statement(h, h[stmt].body)
+}
 fn recursive_synchronous_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: SynchronousStatementId,
 ) -> VisitorResult {
     // TODO: Check where this was used for
     // for &param in h[stmt].parameters.clone().iter() {
     //     recursive_parameter_as_variable(this, h, param)?;
     // }
     this.visit_block_statement(h, h[stmt].body)
+}
 fn recursive_return_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: ReturnStatementId,
 ) -> VisitorResult {
     debug_assert_eq!(h[stmt].expressions.len(), 1);
     this.visit_expression(h, h[stmt].expressions[0])
+}
 fn recursive_new_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: NewStatementId,
 ) -> VisitorResult {
     recursive_call_expression_as_expression(this, h, h[stmt].expression)
+}
 fn recursive_expression_statement<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     stmt: ExpressionStatementId,
 ) -> VisitorResult {
     this.visit_expression(h, h[stmt].expression)
+}
 fn recursive_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: ExpressionId,
 ) -> VisitorResult {
     match h[expr].clone() {
         Expression::Assignment(expr) => this.visit_assignment_expression(h, expr.this),
         Expression::Binding(expr) => this.visit_binding_expression(h, expr.this),
         Expression::Conditional(expr) => this.visit_conditional_expression(h, expr.this),
         Expression::Binary(expr) => this.visit_binary_expression(h, expr.this),
         Expression::Unary(expr) => this.visit_unary_expression(h, expr.this),
         Expression::Indexing(expr) => this.visit_indexing_expression(h, expr.this),
         Expression::Slicing(expr) => this.visit_slicing_expression(h, expr.this),
         Expression::Select(expr) => this.visit_select_expression(h, expr.this),
         Expression::Literal(expr) => this.visit_constant_expression(h, expr.this),
         Expression::Cast(expr) => this.visit_cast_expression(h, expr.this),
         Expression::Call(expr) => this.visit_call_expression(h, expr.this),
         Expression::Variable(expr) => this.visit_variable_expression(h, expr.this),
+    }
+}
 fn recursive_assignment_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: AssignmentExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].left)?;
     this.visit_expression(h, h[expr].right)
+}
 fn recursive_binding_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: BindingExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].left.upcast())?;
     this.visit_expression(h, h[expr].right)
     this.visit_expression(h, h[expr].bound_from)?;
     this.visit_expression(h, h[expr].bound_to)
+}
 fn recursive_conditional_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: ConditionalExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].test)?;
     this.visit_expression(h, h[expr].true_expression)?;
     this.visit_expression(h, h[expr].false_expression)
+}
 fn recursive_binary_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: BinaryExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].left)?;
     this.visit_expression(h, h[expr].right)
+}
 fn recursive_unary_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: UnaryExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].expression)
+}
 fn recursive_indexing_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: IndexingExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].subject)?;
     this.visit_expression(h, h[expr].index)
+}
 fn recursive_slicing_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: SlicingExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].subject)?;
     this.visit_expression(h, h[expr].from_index)?;
     this.visit_expression(h, h[expr].to_index)
+}
 fn recursive_select_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: SelectExpressionId,
 ) -> VisitorResult {
     this.visit_expression(h, h[expr].subject)
+}
 fn recursive_call_expression<T: Visitor>(
     this: &mut T,
     h: &mut Heap,
     expr: CallExpressionId,
 ) -> VisitorResult {
     for &expr in h[expr].arguments.clone().iter() {
         this.visit_expression(h, expr)?;
+    }
     Ok(())
+}
 // ====================
 // Grammar Rules
 // ====================
 pub(crate) struct UniqueStatementId(StatementId);
 pub(crate) struct LinkStatements {
     prev: Option<UniqueStatementId>,
+}
 impl LinkStatements {
     pub(crate) fn new() -> Self {
         LinkStatements { prev: None }
+    }
+}
 impl Visitor for LinkStatements {
     fn visit_symbol_definition(&mut self, h: &mut Heap, def: DefinitionId) -> VisitorResult {
         assert!(self.prev.is_none());
         recursive_symbol_definition(self, h, def)?;
         // Clear out last statement
         self.prev = None;
         Ok(())
+    }
     fn visit_statement(&mut self, h: &mut Heap, stmt: StatementId) -> VisitorResult {
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(stmt);
+        }
         recursive_statement(self, h, stmt)
+    }
     fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {
         if let Some(prev) = self.prev.take() {
             h[prev.0].link_next(stmt.upcast());
+        }
         let end_block = h[stmt].end_block;
         recursive_block_statement(self, h, stmt)?;
         if let Some(prev) = self.prev.take() {
             h[prev.0].link_next(end_block.upcast());
+        }
         self.prev = Some(UniqueStatementId(end_block.upcast()));
         Ok(())
+    }
     fn visit_local_statement(&mut self, _h: &mut Heap, stmt: LocalStatementId) -> VisitorResult {
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {
         recursive_labeled_statement(self, h, stmt)
+    }
     fn visit_if_statement(&mut self, h: &mut Heap, stmt: IfStatementId) -> VisitorResult {
         // Link the two branches to the corresponding EndIf pseudo-statement
         let end_if_id = h[stmt].end_if;
         assert!(!end_if_id.is_invalid());
         assert!(self.prev.is_none());
         self.visit_block_statement(h, h[stmt].true_body)?;
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(end_if_id.upcast());
+        }
         assert!(self.prev.is_none());
         if let Some(false_body) = h[stmt].false_body {
             self.visit_block_statement(h, false_body)?;
+        }
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(end_if_id.upcast());
+        }
         // Use the pseudo-statement as the statement where to update the next pointer
         // self.prev = Some(UniqueStatementId(end_if_id.upcast()));
         Ok(())
+    }
     fn visit_end_if_statement(&mut self, _h: &mut Heap, stmt: EndIfStatementId) -> VisitorResult {
         assert!(self.prev.is_none());
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {
         // We allocate a pseudo-statement, to which the break statement finds its target
         // Update the while's next statement to point to the pseudo-statement
         let end_while_id = h[stmt].end_while;
         assert!(!end_while_id.is_invalid());
         assert!(self.prev.is_none());
         self.visit_block_statement(h, h[stmt].body)?;
         // The body's next statement loops back to the while statement itself
         // Note: continue statements also loop back to the while statement itself
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(stmt.upcast());
+        }
         // Use the while statement as the statement where the next pointer is updated
         // self.prev = Some(UniqueStatementId(end_while_id.upcast()));
         Ok(())
+    }
     fn visit_end_while_statement(&mut self, _h: &mut Heap, stmt: EndWhileStatementId) -> VisitorResult {
         assert!(self.prev.is_none());
         self.prev = Some(UniqueStatementId(stmt.upcast()));
         Ok(())
+    }
     fn visit_break_statement(&mut self, _h: &mut Heap, _stmt: BreakStatementId) -> VisitorResult {
         Ok(())
+    }
     fn visit_continue_statement(
         &mut self,
         _h: &mut Heap,
         _stmt: ContinueStatementId,
     ) -> VisitorResult {
         Ok(())
+    }
     fn visit_synchronous_statement(
         &mut self,
         h: &mut Heap,
         stmt: SynchronousStatementId,
     ) -> VisitorResult {
         // Allocate a pseudo-statement, that is added for helping the evaluator to issue a command
         // that marks the end of the synchronous block. Every evaluation has to pause at this
         // point, only to resume later when the thread is selected as unique thread to continue.
         let end_sync_id = h[stmt].end_sync;
         assert!(!end_sync_id.is_invalid());
         assert!(self.prev.is_none());
         self.visit_block_statement(h, h[stmt].body)?;
         // The body's next statement points to the pseudo element
         if let Some(UniqueStatementId(prev)) = self.prev.take() {
             h[prev].link_next(end_sync_id.upcast());

src/protocol/parser/pass_definitions.rs

➞

Show inline comments

@@ @@ -169,794 +169,793 @@ impl PassDefinitions { @@
                 let identifier = consume_ident_interned(source, iter, ctx)?;
                 let value = if iter.next() == Some(TokenKind::Equal) {
                     iter.consume();
                     let (variant_number, _) = consume_integer_literal(source, iter, &mut self.buffer)?;
                     EnumVariantValue::Integer(variant_number as i64) // TODO: @int
                 } else {
                     EnumVariantValue::None
                 };
                 Ok(EnumVariantDefinition{ identifier, value })
             },
             &mut enum_section, "an enum variant", "a list of enum variants", None
         )?;
         // Transfer to definition
         let enum_def = ctx.heap[definition_id].as_enum_mut();
         enum_def.variants = enum_section.into_vec();
         Ok(())
+    }
     fn visit_union_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         consume_exact_ident(&module.source, iter, KW_UNION)?;
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated DefinitionId
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         // Parse union definition
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         let mut variants_section = self.union_variants.start_section();
         consume_comma_separated(
             TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
                 let identifier = consume_ident_interned(source, iter, ctx)?;
                 let mut close_pos = identifier.span.end;
                 let mut types_section = self.parser_types.start_section();
                 let has_embedded = maybe_consume_comma_separated(
                     TokenKind::OpenParen, TokenKind::CloseParen, source, iter, ctx,
                     |source, iter, ctx| {
                         let poly_vars = ctx.heap[definition_id].poly_vars(); // TODO: @Cleanup, this is really ugly. But rust...
                         consume_parser_type(
                             source, iter, &ctx.symbols, &ctx.heap, poly_vars,
                             module_scope, definition_id, false, 0
+                        )
                     },
                     &mut types_section, "an embedded type", Some(&mut close_pos)
                 )?;
                 let value = if has_embedded {
                     UnionVariantValue::Embedded(types_section.into_vec())
                 } else {
                     types_section.forget();
                     UnionVariantValue::None
                 };
                 Ok(UnionVariantDefinition{
                     span: InputSpan::from_positions(identifier.span.begin, close_pos),
                     identifier,
                     value
                 })
             },
             &mut variants_section, "a union variant", "a list of union variants", None
         )?;
         // Transfer to AST
         let union_def = ctx.heap[definition_id].as_union_mut();
         union_def.variants = variants_section.into_vec();
         Ok(())
+    }
     fn visit_function_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         // Retrieve function name
         consume_exact_ident(&module.source, iter, KW_FUNCTION)?;
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated DefinitionId
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         // Parse function's argument list
         let mut parameter_section = self.variables.start_section();
         consume_parameter_list(
             &module.source, iter, ctx, &mut parameter_section, module_scope, definition_id
         )?;
         let parameters = parameter_section.into_vec();
         // Consume return types
         consume_token(&module.source, iter, TokenKind::ArrowRight)?;
         let mut return_types = self.parser_types.start_section();
         let mut open_curly_pos = iter.last_valid_pos(); // bogus value
         consume_comma_separated_until(
             TokenKind::OpenCurly, &module.source, iter, ctx,
             |source, iter, ctx| {
                 let poly_vars = ctx.heap[definition_id].poly_vars(); // TODO: @Cleanup, this is really ugly. But rust...
                 consume_parser_type(source, iter, &ctx.symbols, &ctx.heap, poly_vars, module_scope, definition_id, false, 0)
             },
             &mut return_types, "a return type", Some(&mut open_curly_pos)
         )?;
         let return_types = return_types.into_vec();
         // TODO: @ReturnValues
         match return_types.len() {
 => return Err(ParseError::new_error_str_at_pos(&module.source, open_curly_pos, "expected a return type")),
 => {},
             _ => return Err(ParseError::new_error_str_at_pos(&module.source, open_curly_pos, "multiple return types are not (yet) allowed")),
+        }
         // Consume block
         let body = self.consume_block_statement_without_leading_curly(module, iter, ctx, open_curly_pos)?;
         // Assign everything in the preallocated AST node
         let function = ctx.heap[definition_id].as_function_mut();
         function.return_types = return_types;
         function.parameters = parameters;
         function.body = body;
         Ok(())
+    }
     fn visit_component_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         // Consume component variant and name
         let (_variant_text, _) = consume_any_ident(&module.source, iter)?;
         debug_assert!(_variant_text == KW_PRIMITIVE || _variant_text == KW_COMPOSITE);
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated definition
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         // Parse component's argument list
         let mut parameter_section = self.variables.start_section();
         consume_parameter_list(
             &module.source, iter, ctx, &mut parameter_section, module_scope, definition_id
         )?;
         let parameters = parameter_section.into_vec();
         // Consume block
         let body = self.consume_block_statement(module, iter, ctx)?;
         // Assign everything in the AST node
         let component = ctx.heap[definition_id].as_component_mut();
         component.parameters = parameters;
         component.body = body;
         Ok(())
+    }
     /// Consumes a block statement. If the resulting statement is not a block
     /// (e.g. for a shorthand "if (expr) single_statement") then it will be
     /// wrapped in one
     fn consume_block_or_wrapped_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<BlockStatementId, ParseError> {
         if Some(TokenKind::OpenCurly) == iter.next() {
             // This is a block statement
             self.consume_block_statement(module, iter, ctx)
         } else {
             // Not a block statement, so wrap it in one
             let mut statements = self.statements.start_section();
             let wrap_begin_pos = iter.last_valid_pos();
             self.consume_statement(module, iter, ctx, &mut statements)?;
             let wrap_end_pos = iter.last_valid_pos();
             debug_assert_eq!(statements.len(), 1);
             let statements = statements.into_vec();
             let id = ctx.heap.alloc_block_statement(|this| BlockStatement{
                 this,
                 is_implicit: true,
                 span: InputSpan::from_positions(wrap_begin_pos, wrap_end_pos), // TODO: @Span
                 statements,
                 end_block: EndBlockStatementId::new_invalid(),
-                parent_scope: Scope::Definition(DefinitionId::new_invalid()),
+                scope_node: ScopeNode::new_invalid(),
                 first_unique_id_in_scope: -1,
                 next_unique_id_in_scope: -1,
                 relative_pos_in_parent: 0,
                 locals: Vec::new(),
                 labels: Vec::new()
             });
             let end_block = ctx.heap.alloc_end_block_statement(|this| EndBlockStatement{
                 this, start_block: id, next: StatementId::new_invalid()
             });
             let block_stmt = &mut ctx.heap[id];
             block_stmt.end_block = end_block;
             Ok(id)
+        }
+    }
     /// Consumes a statement and returns a boolean indicating whether it was a
     /// block or not.
     fn consume_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, section: &mut ScopedSection<StatementId>
     ) -> Result<(), ParseError> {
         let next = iter.next().expect("consume_statement has a next token");
         if next == TokenKind::OpenCurly {
             let id = self.consume_block_statement(module, iter, ctx)?;
             section.push(id.upcast());
         } else if next == TokenKind::Ident {
             let ident = peek_ident(&module.source, iter).unwrap();
             if ident == KW_STMT_IF {
                 // Consume if statement and place end-if statement directly
                 // after it.
                 let id = self.consume_if_statement(module, iter, ctx)?;
                 section.push(id.upcast());
                 let end_if = ctx.heap.alloc_end_if_statement(|this| EndIfStatement{
                     this, start_if: id, next: StatementId::new_invalid()
                 });
                 section.push(end_if.upcast());
                 let if_stmt = &mut ctx.heap[id];
                 if_stmt.end_if = end_if;
             } else if ident == KW_STMT_WHILE {
                 let id = self.consume_while_statement(module, iter, ctx)?;
                 section.push(id.upcast());
                 let end_while = ctx.heap.alloc_end_while_statement(|this| EndWhileStatement{
                     this, start_while: id, next: StatementId::new_invalid()
                 });
                 section.push(end_while.upcast());
                 let while_stmt = &mut ctx.heap[id];
                 while_stmt.end_while = end_while;
             } else if ident == KW_STMT_BREAK {
                 let id = self.consume_break_statement(module, iter, ctx)?;
                 section.push(id.upcast());
             } else if ident == KW_STMT_CONTINUE {
                 let id = self.consume_continue_statement(module, iter, ctx)?;
                 section.push(id.upcast());
             } else if ident == KW_STMT_SYNC {
                 let id = self.consume_synchronous_statement(module, iter, ctx)?;
                 section.push(id.upcast());
                 let end_sync = ctx.heap.alloc_end_synchronous_statement(|this| EndSynchronousStatement{
                     this, start_sync: id, next: StatementId::new_invalid()
                 });
                 section.push(end_sync.upcast());
                 let sync_stmt = &mut ctx.heap[id];
                 sync_stmt.end_sync = end_sync;
             } else if ident == KW_STMT_RETURN {
                 let id = self.consume_return_statement(module, iter, ctx)?;
                 section.push(id.upcast());
             } else if ident == KW_STMT_GOTO {
                 let id = self.consume_goto_statement(module, iter, ctx)?;
                 section.push(id.upcast());
             } else if ident == KW_STMT_NEW {
                 let id = self.consume_new_statement(module, iter, ctx)?;
                 section.push(id.upcast());
             } else if ident == KW_STMT_CHANNEL {
                 let id = self.consume_channel_statement(module, iter, ctx)?;
                 section.push(id.upcast().upcast());
             } else if iter.peek() == Some(TokenKind::Colon) {
                 self.consume_labeled_statement(module, iter, ctx, section)?;
             } else {
                 // Two fallback possibilities: the first one is a memory
                 // declaration, the other one is to parse it as a regular
                 // expression. This is a bit ugly
                 if let Some((memory_stmt_id, assignment_stmt_id)) = self.maybe_consume_memory_statement(module, iter, ctx)? {
                     section.push(memory_stmt_id.upcast().upcast());
                     section.push(assignment_stmt_id.upcast());
                 } else {
                     let id = self.consume_expression_statement(module, iter, ctx)?;
                     section.push(id.upcast());
+                }
+            }
         } else {
             let id = self.consume_expression_statement(module, iter, ctx)?;
             section.push(id.upcast());
+        }
         return Ok(());
+    }
     fn consume_block_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<BlockStatementId, ParseError> {
         let open_span = consume_token(&module.source, iter, TokenKind::OpenCurly)?;
         self.consume_block_statement_without_leading_curly(module, iter, ctx, open_span.begin)
+    }
     fn consume_block_statement_without_leading_curly(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, open_curly_pos: InputPosition
     ) -> Result<BlockStatementId, ParseError> {
         let mut stmt_section = self.statements.start_section();
         let mut next = iter.next();
         while next != Some(TokenKind::CloseCurly) {
             if next.is_none() {
                 return Err(ParseError::new_error_str_at_pos(
                     &module.source, iter.last_valid_pos(), "expected a statement or '}'"
                 ));
+            }
             self.consume_statement(module, iter, ctx, &mut stmt_section)?;
             next = iter.next();
+        }
         let statements = stmt_section.into_vec();
         let mut block_span = consume_token(&module.source, iter, TokenKind::CloseCurly)?;
         block_span.begin = open_curly_pos;
         let id = ctx.heap.alloc_block_statement(|this| BlockStatement{
             this,
             is_implicit: false,
             span: block_span,
             statements,
             end_block: EndBlockStatementId::new_invalid(),
-            parent_scope: Scope::Definition(DefinitionId::new_invalid()),
+            scope_node: ScopeNode::new_invalid(),
             first_unique_id_in_scope: -1,
             next_unique_id_in_scope: -1,
             relative_pos_in_parent: 0,
             locals: Vec::new(),
             labels: Vec::new(),
         });
         let end_block = ctx.heap.alloc_end_block_statement(|this| EndBlockStatement{
             this, start_block: id, next: StatementId::new_invalid()
         });
         let block_stmt = &mut ctx.heap[id];
         block_stmt.end_block = end_block;
         Ok(id)
+    }
     fn consume_if_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<IfStatementId, ParseError> {
         let if_span = consume_exact_ident(&module.source, iter, KW_STMT_IF)?;
         consume_token(&module.source, iter, TokenKind::OpenParen)?;
         let test = self.consume_expression(module, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::CloseParen)?;
         let true_body = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
         let false_body = if has_ident(&module.source, iter, KW_STMT_ELSE) {
             iter.consume();
             let false_body = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
             Some(false_body)
         } else {
             None
         };
         Ok(ctx.heap.alloc_if_statement(|this| IfStatement{
             this,
             span: if_span,
             test,
             true_body,
             false_body,
             end_if: EndIfStatementId::new_invalid(),
         }))
+    }
     fn consume_while_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<WhileStatementId, ParseError> {
         let while_span = consume_exact_ident(&module.source, iter, KW_STMT_WHILE)?;
         consume_token(&module.source, iter, TokenKind::OpenParen)?;
         let test = self.consume_expression(module, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::CloseParen)?;
         let body = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
         Ok(ctx.heap.alloc_while_statement(|this| WhileStatement{
             this,
             span: while_span,
             test,
             body,
             end_while: EndWhileStatementId::new_invalid(),
-            in_sync: None,
+            in_sync: SynchronousStatementId::new_invalid(),
         }))
+    }
     fn consume_break_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<BreakStatementId, ParseError> {
         let break_span = consume_exact_ident(&module.source, iter, KW_STMT_BREAK)?;
         let label = if Some(TokenKind::Ident) == iter.next() {
             let label = consume_ident_interned(&module.source, iter, ctx)?;
             Some(label)
         } else {
             None
         };
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         Ok(ctx.heap.alloc_break_statement(|this| BreakStatement{
             this,
             span: break_span,
             label,
             target: None,
         }))
+    }
     fn consume_continue_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ContinueStatementId, ParseError> {
         let continue_span = consume_exact_ident(&module.source, iter, KW_STMT_CONTINUE)?;
         let label=  if Some(TokenKind::Ident) == iter.next() {
             let label = consume_ident_interned(&module.source, iter, ctx)?;
             Some(label)
         } else {
             None
         };
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         Ok(ctx.heap.alloc_continue_statement(|this| ContinueStatement{
             this,
             span: continue_span,
             label,
             target: None
         }))
+    }
     fn consume_synchronous_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<SynchronousStatementId, ParseError> {
         let synchronous_span = consume_exact_ident(&module.source, iter, KW_STMT_SYNC)?;
         let body = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
         Ok(ctx.heap.alloc_synchronous_statement(|this| SynchronousStatement{
             this,
             span: synchronous_span,
             body,
             end_sync: EndSynchronousStatementId::new_invalid(),
             parent_scope: None,
         }))
+    }
     fn consume_return_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ReturnStatementId, ParseError> {
         let return_span = consume_exact_ident(&module.source, iter, KW_STMT_RETURN)?;
         let mut scoped_section = self.expressions.start_section();
         consume_comma_separated_until(
             TokenKind::SemiColon, &module.source, iter, ctx,
             |_source, iter, ctx| self.consume_expression(module, iter, ctx),
             &mut scoped_section, "a return expression", None
         )?;
         let expressions = scoped_section.into_vec();
         if expressions.is_empty() {
             return Err(ParseError::new_error_str_at_span(&module.source, return_span, "expected at least one return value"));
         } else if expressions.len() > 1 {
             return Err(ParseError::new_error_str_at_span(&module.source, return_span, "multiple return values are not (yet) supported"))
+        }
         Ok(ctx.heap.alloc_return_statement(|this| ReturnStatement{
             this,
             span: return_span,
             expressions
         }))
+    }
     fn consume_goto_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<GotoStatementId, ParseError> {
         let goto_span = consume_exact_ident(&module.source, iter, KW_STMT_GOTO)?;
         let label = consume_ident_interned(&module.source, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         Ok(ctx.heap.alloc_goto_statement(|this| GotoStatement{
             this,
             span: goto_span,
             label,
             target: None
         }))
+    }
     fn consume_new_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<NewStatementId, ParseError> {
         let new_span = consume_exact_ident(&module.source, iter, KW_STMT_NEW)?;
         // TODO: @Cleanup, should just call something like consume_component_expression-ish
         let start_pos = iter.last_valid_pos();
         let expression_id = self.consume_primary_expression(module, iter, ctx)?;
         let expression = &ctx.heap[expression_id];
         let mut valid = false;
         let mut call_id = CallExpressionId::new_invalid();
         if let Expression::Call(expression) = expression {
             // Allow both components and functions, as it makes more sense to
             // check their correct use in the validation and linking pass
             if expression.method == Method::UserComponent || expression.method == Method::UserFunction {
                 call_id = expression.this;
                 valid = true;
+            }
+        }
         if !valid {
             return Err(ParseError::new_error_str_at_span(
                 &module.source, InputSpan::from_positions(start_pos, iter.last_valid_pos()), "expected a call expression"
             ));
+        }
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         debug_assert!(!call_id.is_invalid());
         Ok(ctx.heap.alloc_new_statement(|this| NewStatement{
             this,
             span: new_span,
             expression: call_id,
             next: StatementId::new_invalid(),
         }))
+    }
     fn consume_channel_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ChannelStatementId, ParseError> {
         // Consume channel specification
         let channel_span = consume_exact_ident(&module.source, iter, KW_STMT_CHANNEL)?;
         let channel_type = if Some(TokenKind::OpenAngle) == iter.next() {
             // Retrieve the type of the channel, we're cheating a bit here by
             // consuming the first '<' and setting the initial angle depth to 1
             // such that our final '>' will be consumed as well.
             iter.consume();
             let definition_id = self.cur_definition;
             let poly_vars = ctx.heap[definition_id].poly_vars();
             consume_parser_type(
                 &module.source, iter, &ctx.symbols, &ctx.heap,
                 poly_vars, SymbolScope::Module(module.root_id), definition_id,
                 true, 1
             )?
         } else {
             // Assume inferred
             ParserType{ elements: vec![ParserTypeElement{
                 full_span: channel_span, // TODO: @Span fix
                 variant: ParserTypeVariant::Inferred
             }]}
         };
         let from_identifier = consume_ident_interned(&module.source, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::ArrowRight)?;
         let to_identifier = consume_ident_interned(&module.source, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         // Construct ports
         let from = ctx.heap.alloc_variable(|this| Variable{
             this,
             kind: VariableKind::Local,
             identifier: from_identifier,
             parser_type: channel_type.clone(),
             relative_pos_in_block: 0,
             unique_id_in_scope: -1,
         });
         let to = ctx.heap.alloc_variable(|this|Variable{
             this,
             kind: VariableKind::Local,
             identifier: to_identifier,
             parser_type: channel_type,
             relative_pos_in_block: 0,
             unique_id_in_scope: -1,
         });
         // Construct the channel
         Ok(ctx.heap.alloc_channel_statement(|this| ChannelStatement{
             this,
             span: channel_span,
             from, to,
             relative_pos_in_block: 0,
             next: StatementId::new_invalid(),
         }))
+    }
     fn consume_labeled_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, section: &mut ScopedSection<StatementId>
     ) -> Result<(), ParseError> {
         let label = consume_ident_interned(&module.source, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::Colon)?;
         // Not pretty: consume_statement may produce more than one statement.
         // The values in the section need to be in the correct order if some
         // kind of outer block is consumed, so we take another section, push
         // the expressions in that one, and then allocate the labeled statement.
         let mut inner_section = self.statements.start_section();
         self.consume_statement(module, iter, ctx, &mut inner_section)?;
         debug_assert!(inner_section.len() >= 1);
         let stmt_id = ctx.heap.alloc_labeled_statement(|this| LabeledStatement {
             this,
             label,
             body: inner_section[0],
             relative_pos_in_block: 0,
-            in_sync: None,
+            in_sync: SynchronousStatementId::new_invalid(),
         });
         if inner_section.len() == 1 {
             // Produce the labeled statement pointing to the first statement.
             // This is by far the most common case.
             inner_section.forget();
             section.push(stmt_id.upcast());
         } else {
             // Produce the labeled statement using the first statement, and push
             // the remaining ones at the end.
             let inner_statements = inner_section.into_vec();
             section.push(stmt_id.upcast());
             for idx in 1..inner_statements.len() {
                 section.push(inner_statements[idx])
+            }
+        }
         Ok(())
+    }
     fn maybe_consume_memory_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<Option<(MemoryStatementId, ExpressionStatementId)>, ParseError> {
         // This is a bit ugly. It would be nicer if we could somehow
         // consume the expression with a type hint if we do get a valid
         // type, but we don't get an identifier following it
         let iter_state = iter.save();
         let definition_id = self.cur_definition;
         let poly_vars = ctx.heap[definition_id].poly_vars();
         let parser_type = consume_parser_type(
             &module.source, iter, &ctx.symbols, &ctx.heap, poly_vars,
             SymbolScope::Definition(definition_id), definition_id, true, 0
         );
         if let Ok(parser_type) = parser_type {
             if Some(TokenKind::Ident) == iter.next() {
                 // Assume this is a proper memory statement
                 let identifier = consume_ident_interned(&module.source, iter, ctx)?;
                 let memory_span = InputSpan::from_positions(parser_type.elements[0].full_span.begin, identifier.span.end);
                 let assign_span = consume_token(&module.source, iter, TokenKind::Equal)?;
                 let initial_expr_begin_pos = iter.last_valid_pos();
                 let initial_expr_id = self.consume_expression(module, iter, ctx)?;
                 let initial_expr_end_pos = iter.last_valid_pos();
                 consume_token(&module.source, iter, TokenKind::SemiColon)?;
                 // Allocate the memory statement with the variable
                 let local_id = ctx.heap.alloc_variable(|this| Variable{
                     this,
                     kind: VariableKind::Local,
                     identifier: identifier.clone(),
                     parser_type,
                     relative_pos_in_block: 0,
                     unique_id_in_scope: -1,
                 });
                 let memory_stmt_id = ctx.heap.alloc_memory_statement(|this| MemoryStatement{
                     this,
                     span: memory_span,
                     variable: local_id,
                     next: StatementId::new_invalid()
                 });
                 // Allocate the initial assignment
                 let variable_expr_id = ctx.heap.alloc_variable_expression(|this| VariableExpression{
                     this,
                     identifier,
                     declaration: None,
                     parent: ExpressionParent::None,
                     unique_id_in_definition: -1,
                 });
                 let assignment_expr_id = ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{
                     this,
                     span: assign_span,
                     left: variable_expr_id.upcast(),
                     operation: AssignmentOperator::Set,
                     right: initial_expr_id,
                     parent: ExpressionParent::None,
                     unique_id_in_definition: -1,
                 });
                 let assignment_stmt_id = ctx.heap.alloc_expression_statement(|this| ExpressionStatement{
                     this,
                     span: InputSpan::from_positions(initial_expr_begin_pos, initial_expr_end_pos),
                     expression: assignment_expr_id.upcast(),
                     next: StatementId::new_invalid(),
                 });
                 return Ok(Some((memory_stmt_id, assignment_stmt_id)))
+            }
+        }
         // If here then one of the preconditions for a memory statement was not
         // met. So recover the iterator and return
         iter.load(iter_state);
         Ok(None)
+    }
     fn consume_expression_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionStatementId, ParseError> {
         let start_pos = iter.last_valid_pos();
         let expression = self.consume_expression(module, iter, ctx)?;
         let end_pos = iter.last_valid_pos();
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         Ok(ctx.heap.alloc_expression_statement(|this| ExpressionStatement{
             this,
             span: InputSpan::from_positions(start_pos, end_pos),
             expression,
             next: StatementId::new_invalid(),
         }))
+    }
     //--------------------------------------------------------------------------
     // Expression Parsing
     //--------------------------------------------------------------------------
     // TODO: @Cleanup This is fine for now. But I prefer my stacktraces not to
     //  look like enterprise Java code...
     fn consume_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_assignment_expression(module, iter, ctx)
+    }
     fn consume_assignment_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         // Utility to convert token into assignment operator
         fn parse_assignment_operator(token: Option<TokenKind>) -> Option<AssignmentOperator> {
             use TokenKind as TK;
             use AssignmentOperator as AO;
             if token.is_none() {
                 return None
+            }
             match token.unwrap() {
                 TK::Equal               => Some(AO::Set),
                 TK::StarEquals          => Some(AO::Multiplied),
                 TK::SlashEquals         => Some(AO::Divided),
                 TK::PercentEquals       => Some(AO::Remained),
                 TK::PlusEquals          => Some(AO::Added),
                 TK::MinusEquals         => Some(AO::Subtracted),
                 TK::ShiftLeftEquals     => Some(AO::ShiftedLeft),
                 TK::ShiftRightEquals    => Some(AO::ShiftedRight),
                 TK::AndEquals           => Some(AO::BitwiseAnded),
                 TK::CaretEquals         => Some(AO::BitwiseXored),
                 TK::OrEquals            => Some(AO::BitwiseOred),
                 _                       => None
+            }
+        }
         let expr = self.consume_conditional_expression(module, iter, ctx)?;
         if let Some(operation) = parse_assignment_operator(iter.next()) {
             let span = iter.next_span();
             iter.consume();
             let left = expr;
             let right = self.consume_expression(module, iter, ctx)?;
             Ok(ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{
                 this, span, left, operation, right,
                 parent: ExpressionParent::None,
                 unique_id_in_definition: -1,
             }).upcast())
         } else {
             Ok(expr)
+        }
+    }
     fn consume_conditional_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         let result = self.consume_concat_expression(module, iter, ctx)?;
         if let Some(TokenKind::Question) = iter.next() {
             let span = iter.next_span();
             iter.consume();
             let test = result;
             let true_expression = self.consume_expression(module, iter, ctx)?;
             consume_token(&module.source, iter, TokenKind::Colon)?;
             let false_expression = self.consume_expression(module, iter, ctx)?;
             Ok(ctx.heap.alloc_conditional_expression(|this| ConditionalExpression{
                 this, span, test, true_expression, false_expression,
                 parent: ExpressionParent::None,
                 unique_id_in_definition: -1,
             }).upcast())
         } else {
             Ok(result)
+        }
+    }
@@ @@ -1269,384 +1268,401 @@ impl PassDefinitions { @@
                 parent: ExpressionParent::None,
                 unique_id_in_definition: -1,
             }).upcast()
         } else if next == Some(TokenKind::String) {
             let span = consume_string_literal(&module.source, iter, &mut self.buffer)?;
             let interned = ctx.pool.intern(self.buffer.as_bytes());
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this, span,
                 value: Literal::String(interned),
                 parent: ExpressionParent::None,
                 unique_id_in_definition: -1,
             }).upcast()
         } else if next == Some(TokenKind::Character) {
             let (character, span) = consume_character_literal(&module.source, iter)?;
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this, span,
                 value: Literal::Character(character),
                 parent: ExpressionParent::None,
                 unique_id_in_definition: -1,
             }).upcast()
         } else if next == Some(TokenKind::Ident) {
             // May be a variable, a type instantiation or a function call. If we
             // have a single identifier that we cannot find in the type table
             // then we're going to assume that we're dealing with a variable.
             let ident_span = iter.next_span();
             let ident_text = module.source.section_at_span(ident_span);
             let symbol = ctx.symbols.get_symbol_by_name(SymbolScope::Module(module.root_id), ident_text);
             if symbol.is_some() {
                 // The first bit looked like a symbol, so we're going to follow
                 // that all the way through, assume we arrive at some kind of
                 // function call or type instantiation
                 use ParserTypeVariant as PTV;
                 let symbol_scope = SymbolScope::Definition(self.cur_definition);
                 let poly_vars = ctx.heap[self.cur_definition].poly_vars();
                 let parser_type = consume_parser_type(
                     &module.source, iter, &ctx.symbols, &ctx.heap, poly_vars, symbol_scope,
                     self.cur_definition, true, 0
                 )?;
                 debug_assert!(!parser_type.elements.is_empty());
                 match parser_type.elements[0].variant {
                     PTV::Definition(target_definition_id, _) => {
                         let definition = &ctx.heap[target_definition_id];
                         match definition {
                             Definition::Struct(_) => {
                                 // Struct literal
                                 let mut last_token = iter.last_valid_pos();
                                 let mut struct_fields = Vec::new();
                                 consume_comma_separated(
                                     TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
                                     |source, iter, ctx| {
                                         let identifier = consume_ident_interned(source, iter, ctx)?;
                                         consume_token(source, iter, TokenKind::Colon)?;
                                         let value = self.consume_expression(module, iter, ctx)?;
                                         Ok(LiteralStructField{ identifier, value, field_idx: 0 })
                                     },
                                     &mut struct_fields, "a struct field", "a list of struct fields", Some(&mut last_token)
                                 )?;
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, last_token),
                                     value: Literal::Struct(LiteralStruct{
                                         parser_type,
                                         fields: struct_fields,
                                         definition: target_definition_id,
                                     }),
                                     parent: ExpressionParent::None,
                                     unique_id_in_definition: -1,
                                 }).upcast()
                             },
                             Definition::Enum(_) => {
                                 // Enum literal: consume the variant
                                 consume_token(&module.source, iter, TokenKind::ColonColon)?;
                                 let variant = consume_ident_interned(&module.source, iter, ctx)?;
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, variant.span.end),
                                     value: Literal::Enum(LiteralEnum{
                                         parser_type,
                                         variant,
                                         definition: target_definition_id,
                                         variant_idx: 0
                                     }),
                                     parent: ExpressionParent::None,
                                     unique_id_in_definition: -1,
                                 }).upcast()
                             },
                             Definition::Union(_) => {
                                 // Union literal: consume the variant
                                 consume_token(&module.source, iter, TokenKind::ColonColon)?;
                                 let variant = consume_ident_interned(&module.source, iter, ctx)?;
                                 // Consume any possible embedded values
                                 let mut end_pos = variant.span.end;
                                 let values = if Some(TokenKind::OpenParen) == iter.next() {
                                     self.consume_expression_list(module, iter, ctx, Some(&mut end_pos))?
                                 } else {
                                     Vec::new()
                                 };
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, end_pos),
                                     value: Literal::Union(LiteralUnion{
                                         parser_type, variant, values,
                                         definition: target_definition_id,
                                         variant_idx: 0,
                                     }),
                                     parent: ExpressionParent::None,
                                     unique_id_in_definition: -1,
                                 }).upcast()
                             },
                             Definition::Component(_) => {
                                 // Component instantiation
                                 let arguments = self.consume_expression_list(module, iter, ctx, None)?;
                                 ctx.heap.alloc_call_expression(|this| CallExpression{
                                     this,
                                     span: parser_type.elements[0].full_span, // TODO: @Span fix
                                     parser_type,
                                     method: Method::UserComponent,
                                     arguments,
                                     definition: target_definition_id,
                                     parent: ExpressionParent::None,
                                     unique_id_in_definition: -1,
                                 }).upcast()
                             },
                             Definition::Function(function_definition) => {
                                 // Check whether it is a builtin function
                                 let method = if function_definition.builtin {
                                     match function_definition.identifier.value.as_str() {
                                         "get" => Method::Get,
                                         "put" => Method::Put,
                                         "fires" => Method::Fires,
                                         "create" => Method::Create,
                                         "length" => Method::Length,
                                         "assert" => Method::Assert,
                                         _ => unreachable!(),
+                                    }
                                 } else {
                                     Method::UserFunction
                                 };
                                 // Function call: consume the arguments
                                 let arguments = self.consume_expression_list(module, iter, ctx, None)?;
                                 ctx.heap.alloc_call_expression(|this| CallExpression{
                                     this,
                                     span: parser_type.elements[0].full_span, // TODO: @Span fix
                                     parser_type,
                                     method,
                                     arguments,
                                     definition: target_definition_id,
                                     parent: ExpressionParent::None,
                                     unique_id_in_definition: -1,
                                 }).upcast()
+                            }
+                        }
                     },
                     _ => {
                         // TODO: Casting expressions
                         return Err(ParseError::new_error_str_at_span(
                             &module.source, parser_type.elements[0].full_span,
                             "unexpected type in expression, note that casting expressions are not yet implemented"
                         ))
+                    }
+                }
             } else {
                 // Check for builtin keywords or builtin functions
                 if ident_text == KW_LIT_NULL || ident_text == KW_LIT_TRUE || ident_text == KW_LIT_FALSE {
                     iter.consume();
                     // Parse builtin literal
                     let value = match ident_text {
                         KW_LIT_NULL => Literal::Null,
                         KW_LIT_TRUE => Literal::True,
                         KW_LIT_FALSE => Literal::False,
                         _ => unreachable!(),
                     };
                     ctx.heap.alloc_literal_expression(|this| LiteralExpression {
                         this,
                         span: ident_span,
                         value,
                         parent: ExpressionParent::None,
                         unique_id_in_definition: -1,
                     }).upcast()
                 } else if ident_text == KW_LET {
                     // Binding expression
                     let keyword_span = iter.next_span();
                     iter.consume();
                     let bound_to = self.consume_expression(module, iter, ctx)?;
                     consume_token(&module.source, iter, TokenKind::Equal)?;
                     let bound_from = self.consume_expression(module, iter, ctx)?;
                     ctx.heap.alloc_binding_expression(|this| BindingExpression{
                         this,
                         span: keyword_span,
                         bound_to,
                         bound_from,
                         parent: ExpressionParent::None,
                         unique_id_in_definition: -1,
                     }).upcast()
                 } else if ident_text == KW_CAST {
                     // Casting expression
                     iter.consume();
                     let to_type = if Some(TokenKind::OpenAngle) == iter.next() {
                         iter.consume();
                         let definition_id = self.cur_definition;
                         let poly_vars = ctx.heap[definition_id].poly_vars();
                         consume_parser_type(
                             &module.source, iter, &ctx.symbols, &ctx.heap,
                             poly_vars, SymbolScope::Module(module.root_id), definition_id,
                             true, 1
                         )?
                     } else {
                         // Automatic casting with inferred target type
                         ParserType{ elements: vec![ParserTypeElement{
                             full_span: ident_span, // TODO: @Span fix
                             variant: ParserTypeVariant::Inferred,
                         }]}
                     };
                     consume_token(&module.source, iter, TokenKind::OpenParen)?;
                     let subject = self.consume_expression(module, iter, ctx)?;
                     consume_token(&module.source, iter, TokenKind::CloseParen)?;
                     ctx.heap.alloc_cast_expression(|this| CastExpression{
                         this,
                         span: ident_span,
                         to_type,
                         subject,
                         parent: ExpressionParent::None,
                         unique_id_in_definition: -1,
                     }).upcast()
                 } else {
                     // Not a builtin literal, but also not a known type. So we
                     // assume it is a variable expression. Although if we do,
                     // then if a programmer mistyped a struct/function name the
                     // error messages will be rather cryptic. For polymorphic
                     // arguments we can't really do anything at all (because it
                     // uses the '<' token). In the other cases we try to provide
                     // a better error message.
                     iter.consume();
                     let next = iter.next();
                     if Some(TokenKind::ColonColon) == next {
                         return Err(ParseError::new_error_str_at_span(&module.source, ident_span, "unknown identifier"));
                     } else if Some(TokenKind::OpenParen) == next {
                         return Err(ParseError::new_error_str_at_span(
                             &module.source, ident_span,
                             "unknown identifier, did you mistype a union variant's or a function's name?"
                         ));
                     } else if Some(TokenKind::OpenCurly) == next {
                         return Err(ParseError::new_error_str_at_span(
                             &module.source, ident_span,
                             "unknown identifier, did you mistype a struct type's name?"
                         ))
+                    }
                     let ident_text = ctx.pool.intern(ident_text);
                     let identifier = Identifier { span: ident_span, value: ident_text };
                     ctx.heap.alloc_variable_expression(|this| VariableExpression {
                         this,
                         identifier,
                         declaration: None,
                         parent: ExpressionParent::None,
                         unique_id_in_definition: -1,
                     }).upcast()
+                }
+            }
         } else {
             return Err(ParseError::new_error_str_at_pos(
                 &module.source, iter.last_valid_pos(), "expected an expression"
             ));
         };
         Ok(result)
+    }
     //--------------------------------------------------------------------------
     // Expression Utilities
     //--------------------------------------------------------------------------
     #[inline]
     fn consume_generic_binary_expression<
         M: Fn(Option<TokenKind>) -> Option<BinaryOperator>,
         F: Fn(&mut PassDefinitions, &Module, &mut TokenIter, &mut PassCtx) -> Result<ExpressionId, ParseError>
     >(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, match_fn: M, higher_precedence_fn: F
     ) -> Result<ExpressionId, ParseError> {
         let mut result = higher_precedence_fn(self, module, iter, ctx)?;
         while let Some(operation) = match_fn(iter.next()) {
             let span = iter.next_span();
             iter.consume();
             let left = result;
             let right = higher_precedence_fn(self, module, iter, ctx)?;
             result = ctx.heap.alloc_binary_expression(|this| BinaryExpression{
                 this, span, left, operation, right,
                 parent: ExpressionParent::None,
                 unique_id_in_definition: -1,
             }).upcast();
+        }
         Ok(result)
+    }
     #[inline]
     fn consume_expression_list(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, end_pos: Option<&mut InputPosition>
     ) -> Result<Vec<ExpressionId>, ParseError> {
         let mut section = self.expressions.start_section();
         consume_comma_separated(
             TokenKind::OpenParen, TokenKind::CloseParen, &module.source, iter, ctx,
             |_source, iter, ctx| self.consume_expression(module, iter, ctx),
             &mut section, "an expression", "a list of expressions", end_pos
         )?;
         Ok(section.into_vec())
+    }
+}
 /// Consumes a type. A type always starts with an identifier which may indicate
 /// a builtin type or a user-defined type. The fact that it may contain
 /// polymorphic arguments makes it a tree-like structure. Because we cannot rely
 /// on knowing the exact number of polymorphic arguments we do not check for
 /// these.
 ///
 /// Note that the first depth index is used as a hack.
 // TODO: @Optimize, @Span fix, @Cleanup
 fn consume_parser_type(
     source: &InputSource, iter: &mut TokenIter, symbols: &SymbolTable, heap: &Heap, poly_vars: &[Identifier],
     cur_scope: SymbolScope, wrapping_definition: DefinitionId, allow_inference: bool, first_angle_depth: i32,
 ) -> Result<ParserType, ParseError> {
     struct Entry{
         element: ParserTypeElement,
         depth: i32,
+    }
     // After parsing the array modified "[]", we need to insert an array type
     // before the most recently parsed type.
     fn insert_array_before(elements: &mut Vec<Entry>, depth: i32, span: InputSpan) {
         let index = elements.iter().rposition(|e| e.depth == depth).unwrap();
         elements.insert(index, Entry{
             element: ParserTypeElement{ full_span: span, variant: ParserTypeVariant::Array },
             depth,
         });
+    }
     // Most common case we just have one type, perhaps with some array
     // annotations. This is both the hot-path, and simplifies the state machine
     // that follows and is responsible for parsing more complicated types.
     let element = consume_parser_type_ident(source, iter, symbols, heap, poly_vars, cur_scope, wrapping_definition, allow_inference)?;
     if iter.next() != Some(TokenKind::OpenAngle) {
         let num_embedded = element.variant.num_embedded();
         let mut num_array = 0;
         while iter.next() == Some(TokenKind::OpenSquare) {
             iter.consume();
             consume_token(source, iter, TokenKind::CloseSquare)?;
             num_array += 1;
+        }
         let array_span = element.full_span;
         let mut elements = Vec::with_capacity(num_array + num_embedded + 1);
         for _ in 0..num_array {
             elements.push(ParserTypeElement{ full_span: array_span, variant: ParserTypeVariant::Array });
+        }
         elements.push(element);
         if num_embedded != 0 {
             if !allow_inference {
                 return Err(ParseError::new_error_str_at_span(source, array_span, "type inference is not allowed here"));
+            }
             for _ in 0..num_embedded {
                 elements.push(ParserTypeElement { full_span: array_span, variant: ParserTypeVariant::Inferred });
+            }
+        }
         for _ in 0..first_angle_depth {
             consume_token(source, iter, TokenKind::CloseAngle);
+        }
         return Ok(ParserType{ elements });
     };
     // We have a polymorphic specification. So we start by pushing the item onto
     // our stack, then start adding entries together with the angle-brace depth
     // at which they're found.
     let mut elements = Vec::new();
     elements.push(Entry{ element, depth: 0 });
     // Start out with the first '<' consumed.
     iter.consume();

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -981,825 +981,844 @@ impl PassTyping { @@
         self.expr_buffer.clear();
         self.var_types.clear();
         self.expr_types.clear();
         self.extra_data.clear();
         self.expr_queued.clear();
+    }
+}
 impl Visitor2 for PassTyping {
     // Definitions
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {
         self.definition_type = DefinitionType::Component(id);
         let comp_def = &ctx.heap[id];
         debug_assert_eq!(comp_def.poly_vars.len(), self.poly_vars.len(), "component polyvars do not match imposed polyvars");
         debug_log!("{}", "-".repeat(50));
         debug_log!("Visiting component '{}': {}", comp_def.identifier.value.as_str(), id.0.index);
         debug_log!("{}", "-".repeat(50));
         // Reserve data for expression types
         debug_assert!(self.expr_types.is_empty());
         self.expr_types.resize(comp_def.num_expressions_in_body as usize, Default::default());
         // Visit parameters
         for param_id in comp_def.parameters.clone() {
             let param = &ctx.heap[param_id];
             let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);
             debug_assert!(var_type.is_done, "expected component arguments to be concrete types");
             self.var_types.insert(param_id, VarData::new_local(var_type));
+        }
         // Visit the body and all of its expressions
         let body_stmt_id = ctx.heap[id].body;
         self.visit_block_stmt(ctx, body_stmt_id)
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionDefinitionId) -> VisitorResult {
         self.definition_type = DefinitionType::Function(id);
         let func_def = &ctx.heap[id];
         debug_assert_eq!(func_def.poly_vars.len(), self.poly_vars.len(), "function polyvars do not match imposed polyvars");
         debug_log!("{}", "-".repeat(50));
         debug_log!("Visiting function '{}': {}", func_def.identifier.value.as_str(), id.0.index);
         if debug_log_enabled!() {
             debug_log!("Polymorphic variables:");
             for (idx, poly_var) in self.poly_vars.iter().enumerate() {
                 let mut infer_type_parts = Vec::new();
                 for concrete_part in &poly_var.parts {
                     infer_type_parts.push(InferenceTypePart::from(*concrete_part));
+                }
                 let infer_type = InferenceType::new(false, true, infer_type_parts);
                 debug_log!(" - [{:03}] {:?}", idx, infer_type.display_name(&ctx.heap));
+            }
+        }
         debug_log!("{}", "-".repeat(50));
         // Reserve data for expression types
         debug_assert!(self.expr_types.is_empty());
         self.expr_types.resize(func_def.num_expressions_in_body as usize, Default::default());
         // Visit parameters
         for param_id in func_def.parameters.clone() {
             let param = &ctx.heap[param_id];
             let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);
             debug_assert!(var_type.is_done, "expected function arguments to be concrete types");
             self.var_types.insert(param_id, VarData::new_local(var_type));
+        }
         // Visit all of the expressions within the body
         let body_stmt_id = ctx.heap[id].body;
         self.visit_block_stmt(ctx, body_stmt_id)
+    }
     // Statements
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         // Transfer statements for traversal
         let block = &ctx.heap[id];
         for stmt_id in block.statements.clone() {
             self.visit_stmt(ctx, stmt_id)?;
+        }
         Ok(())
+    }
     fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {
         let memory_stmt = &ctx.heap[id];
         let local = &ctx.heap[memory_stmt.variable];
         let var_type = self.determine_inference_type_from_parser_type_elements(&local.parser_type.elements, true);
         self.var_types.insert(memory_stmt.variable, VarData::new_local(var_type));
         Ok(())
+    }
     fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {
         let channel_stmt = &ctx.heap[id];
         let from_local = &ctx.heap[channel_stmt.from];
         let from_var_type = self.determine_inference_type_from_parser_type_elements(&from_local.parser_type.elements, true);
         self.var_types.insert(from_local.this, VarData::new_channel(from_var_type, channel_stmt.to));
         let to_local = &ctx.heap[channel_stmt.to];
         let to_var_type = self.determine_inference_type_from_parser_type_elements(&to_local.parser_type.elements, true);
         self.var_types.insert(to_local.this, VarData::new_channel(to_var_type, channel_stmt.from));
         Ok(())
+    }
     fn visit_labeled_stmt(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> VisitorResult {
         let labeled_stmt = &ctx.heap[id];
         let substmt_id = labeled_stmt.body;
         self.visit_stmt(ctx, substmt_id)
+    }
     fn visit_if_stmt(&mut self, ctx: &mut Ctx, id: IfStatementId) -> VisitorResult {
         let if_stmt = &ctx.heap[id];
         let true_body_id = if_stmt.true_body;
         let false_body_id = if_stmt.false_body;
         let test_expr_id = if_stmt.test;
         self.visit_expr(ctx, test_expr_id)?;
         self.visit_block_stmt(ctx, true_body_id)?;
         if let Some(false_body_id) = false_body_id {
             self.visit_block_stmt(ctx, false_body_id)?;
+        }
         Ok(())
+    }
     fn visit_while_stmt(&mut self, ctx: &mut Ctx, id: WhileStatementId) -> VisitorResult {
         let while_stmt = &ctx.heap[id];
         let body_id = while_stmt.body;
         let test_expr_id = while_stmt.test;
         self.visit_expr(ctx, test_expr_id)?;
         self.visit_block_stmt(ctx, body_id)?;
         Ok(())
+    }
     fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {
         let sync_stmt = &ctx.heap[id];
         let body_id = sync_stmt.body;
         self.visit_block_stmt(ctx, body_id)
+    }
     fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {
         let return_stmt = &ctx.heap[id];
         debug_assert_eq!(return_stmt.expressions.len(), 1);
         let expr_id = return_stmt.expressions[0];
         self.visit_expr(ctx, expr_id)
+    }
     fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {
         let new_stmt = &ctx.heap[id];
         let call_expr_id = new_stmt.expression;
         self.visit_call_expr(ctx, call_expr_id)
+    }
     fn visit_expr_stmt(&mut self, ctx: &mut Ctx, id: ExpressionStatementId) -> VisitorResult {
         let expr_stmt = &ctx.heap[id];
         let subexpr_id = expr_stmt.expression;
         self.visit_expr(ctx, subexpr_id)
+    }
     // Expressions
     fn visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let assign_expr = &ctx.heap[id];
         let left_expr_id = assign_expr.left;
         let right_expr_id = assign_expr.right;
         self.visit_expr(ctx, left_expr_id)?;
         self.visit_expr(ctx, right_expr_id)?;
         self.progress_assignment_expr(ctx, id)
+    }
     fn visit_binding_expr(&mut self, ctx: &mut Ctx, id: BindingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let binding_expr = &ctx.heap[id];
         let bound_to_id = binding_expr.bound_to;
         let bound_from_id = binding_expr.bound_from;
         self.visit_expr(ctx, bound_to_id)?;
         self.visit_expr(ctx, bound_from_id)?;
         self.progress_binding_expr(ctx, id)
+    }
     fn visit_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let conditional_expr = &ctx.heap[id];
         let test_expr_id = conditional_expr.test;
         let true_expr_id = conditional_expr.true_expression;
         let false_expr_id = conditional_expr.false_expression;
         self.visit_expr(ctx, test_expr_id)?;
         self.visit_expr(ctx, true_expr_id)?;
         self.visit_expr(ctx, false_expr_id)?;
         self.progress_conditional_expr(ctx, id)
+    }
     fn visit_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let binary_expr = &ctx.heap[id];
         let lhs_expr_id = binary_expr.left;
         let rhs_expr_id = binary_expr.right;
         self.visit_expr(ctx, lhs_expr_id)?;
         self.visit_expr(ctx, rhs_expr_id)?;
         self.progress_binary_expr(ctx, id)
+    }
     fn visit_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let unary_expr = &ctx.heap[id];
         let arg_expr_id = unary_expr.expression;
         self.visit_expr(ctx, arg_expr_id)?;
         self.progress_unary_expr(ctx, id)
+    }
     fn visit_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let indexing_expr = &ctx.heap[id];
         let subject_expr_id = indexing_expr.subject;
         let index_expr_id = indexing_expr.index;
         self.visit_expr(ctx, subject_expr_id)?;
         self.visit_expr(ctx, index_expr_id)?;
         self.progress_indexing_expr(ctx, id)
+    }
     fn visit_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let slicing_expr = &ctx.heap[id];
         let subject_expr_id = slicing_expr.subject;
         let from_expr_id = slicing_expr.from_index;
         let to_expr_id = slicing_expr.to_index;
         self.visit_expr(ctx, subject_expr_id)?;
         self.visit_expr(ctx, from_expr_id)?;
         self.visit_expr(ctx, to_expr_id)?;
         self.progress_slicing_expr(ctx, id)
+    }
     fn visit_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let select_expr = &ctx.heap[id];
         let subject_expr_id = select_expr.subject;
         self.visit_expr(ctx, subject_expr_id)?;
         self.progress_select_expr(ctx, id)
+    }
     fn visit_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let literal_expr = &ctx.heap[id];
         match &literal_expr.value {
             Literal::Null | Literal::False | Literal::True |
             Literal::Integer(_) | Literal::Character(_) | Literal::String(_) => {
                 // No subexpressions
             },
             Literal::Struct(literal) => {
                 // TODO: @performance
                 let expr_ids: Vec<_> = literal.fields
                     .iter()
                     .map(|f| f.value)
                     .collect();
                 self.insert_initial_struct_polymorph_data(ctx, id);
                 for expr_id in expr_ids {
                     self.visit_expr(ctx, expr_id)?;
+                }
             },
             Literal::Enum(_) => {
                 // Enumerations do not carry any subexpressions, but may still
                 // have a user-defined polymorphic marker variable. For this
                 // reason we may still have to apply inference to this
                 // polymorphic variable
                 self.insert_initial_enum_polymorph_data(ctx, id);
             },
             Literal::Union(literal) => {
                 // May carry subexpressions and polymorphic arguments
                 // TODO: @performance
                 let expr_ids = literal.values.clone();
                 self.insert_initial_union_polymorph_data(ctx, id);
                 for expr_id in expr_ids {
                     self.visit_expr(ctx, expr_id)?;
+                }
             },
             Literal::Array(expressions) => {
                 // TODO: @performance
                 let expr_ids = expressions.clone();
                 for expr_id in expr_ids {
                     self.visit_expr(ctx, expr_id)?;
+                }
+            }
+        }
         self.progress_literal_expr(ctx, id)
+    }
     fn visit_cast_expr(&mut self, ctx: &mut Ctx, id: CastExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let cast_expr = &ctx.heap[id];
         let subject_expr_id = cast_expr.subject;
         self.visit_expr(ctx, subject_expr_id)?;
         self.progress_cast_expr(ctx, id)
+    }
     fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         self.insert_initial_call_polymorph_data(ctx, id);
         // By default we set the polymorph idx for calls to 0. If the call ends
         // up not being a polymorphic one, then we will select the default
         // expression types in the type table
         let call_expr = &ctx.heap[id];
         self.expr_types[call_expr.unique_id_in_definition as usize].field_or_monomorph_idx = 0;
         // Visit all arguments
         for arg_expr_id in call_expr.arguments.clone() { // TODO: @Performance
             self.visit_expr(ctx, arg_expr_id)?;
+        }
         self.progress_call_expr(ctx, id)
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let var_expr = &ctx.heap[id];
         debug_assert!(var_expr.declaration.is_some());
         let var_data = self.var_types.get_mut(var_expr.declaration.as_ref().unwrap()).unwrap();
         var_data.used_at.push(upcast_id);
         self.progress_variable_expr(ctx, id)
+    }
+}
 impl PassTyping {
     fn temp_get_display_name(&self, ctx: &Ctx, expr_id: ExpressionId) -> String {
         let expr_idx = ctx.heap[expr_id].get_unique_id_in_definition();
         let expr_type = &self.expr_types[expr_idx as usize].expr_type;
         expr_type.display_name(&ctx.heap)
+    }
     fn resolve_types(&mut self, ctx: &mut Ctx, queue: &mut ResolveQueue) -> Result<(), ParseError> {
         // Keep inferring until we can no longer make any progress
         while !self.expr_queued.is_empty() {
             let next_expr_idx = self.expr_queued.pop_front().unwrap();
             self.progress_expr(ctx, next_expr_idx)?;
+        }
         // Helper for transferring polymorphic variables to concrete types and
         // checking if they're completely specified
         fn poly_inference_to_concrete_type(
             ctx: &Ctx, expr_id: ExpressionId, inference: &Vec<InferenceType>
         ) -> Result<Vec<ConcreteType>, ParseError> {
             let mut concrete = Vec::with_capacity(inference.len());
             for (poly_idx, poly_type) in inference.iter().enumerate() {
                 if !poly_type.is_done {
                     let expr = &ctx.heap[expr_id];
                     let definition = match expr {
                         Expression::Call(expr) => expr.definition,
                         Expression::Literal(expr) => match &expr.value {
                             Literal::Enum(lit) => lit.definition,
                             Literal::Union(lit) => lit.definition,
                             Literal::Struct(lit) => lit.definition,
                             _ => unreachable!()
                         },
                         _ => unreachable!(),
                     };
                     let poly_vars = ctx.heap[definition].poly_vars();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, expr.span(), format!(
                             "could not fully infer the type of polymorphic variable '{}' of this expression (got '{}')",
                             poly_vars[poly_idx].value.as_str(), poly_type.display_name(&ctx.heap)
+                        )
                     ));
+                }
                 let mut concrete_type = ConcreteType::default();
                 poly_type.write_concrete_type(&mut concrete_type);
                 concrete.push(concrete_type);
+            }
             Ok(concrete)
+        }
         // Inference is now done. But we may still have uninferred types. So we
         // check for these.
         for (infer_expr_idx, infer_expr) in self.expr_types.iter_mut().enumerate() {
             let expr_type = &mut infer_expr.expr_type;
             if !expr_type.is_done {
                 // Auto-infer numberlike/integerlike types to a regular int
                 if expr_type.parts.len() == 1 && expr_type.parts[0] == InferenceTypePart::IntegerLike {
                     expr_type.parts[0] = InferenceTypePart::SInt32;
                     self.expr_queued.push_back(infer_expr_idx as i32);
                 } else {
                     let expr = &ctx.heap[infer_expr.expr_id];
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, expr.span(), format!(
                             "could not fully infer the type of this expression (got '{}')",
                             expr_type.display_name(&ctx.heap)
+                        )
                     ));
+                }
+            }
             // Expression is fine, check if any extra data is attached
             if infer_expr.extra_data_idx < 0 { continue; }
             // Extra data is attached, perform typechecking and transfer
             // resolved information to the expression
             let extra_data = &self.extra_data[infer_expr.extra_data_idx as usize];
             if extra_data.poly_vars.is_empty() { continue; }
             // Note that only call and literal expressions need full inference.
             // Select expressions also use `extra_data`, but only for temporary
             // storage of the struct type whose field it is selecting.
             match &ctx.heap[extra_data.expr_id] {
                 Expression::Call(expr) => {
                     if expr.method != Method::UserFunction && expr.method != Method::UserComponent {
                         // Builtin function
                         continue;
+                    }
                     let definition_id = expr.definition;
                     let poly_types = poly_inference_to_concrete_type(ctx, extra_data.expr_id, &extra_data.poly_vars)?;
                     match ctx.types.get_procedure_monomorph_index(&definition_id, &poly_types) {
                         Some(reserved_idx) => {
                             // Already typechecked, or already put into the resolve queue
                             infer_expr.field_or_monomorph_idx = reserved_idx;
                         },
                         None => {
                             // Not typechecked yet, so add an entry in the queue
                             let reserved_idx = ctx.types.reserve_procedure_monomorph_index(&definition_id, Some(poly_types.clone()));
                             infer_expr.field_or_monomorph_idx = reserved_idx;
                             queue.push(ResolveQueueElement{
                                 root_id: ctx.heap[definition_id].defined_in(),
                                 definition_id,
                                 monomorph_types: poly_types,
                                 reserved_monomorph_idx: reserved_idx,
                             });
+                        }
+                    }
                 },
                 Expression::Literal(expr) => {
                     let definition_id = match &expr.value {
                         Literal::Enum(lit) => lit.definition,
                         Literal::Union(lit) => lit.definition,
                         Literal::Struct(lit) => lit.definition,
                         _ => unreachable!(),
                     };
                     let poly_types = poly_inference_to_concrete_type(ctx, extra_data.expr_id, &extra_data.poly_vars)?;
                     let mono_index = ctx.types.add_data_monomorph(&definition_id, poly_types);
                     infer_expr.field_or_monomorph_idx = mono_index;
                 },
                 Expression::Select(_) => {
                     debug_assert!(infer_expr.field_or_monomorph_idx >= 0);
                 },
                 _ => {
                     unreachable!("handling extra data for expression {:?}", &ctx.heap[extra_data.expr_id]);
+                }
+            }
+        }
         // If we did any implicit type forcing, then our queue isn't empty
         // anymore
         while !self.expr_queued.is_empty() {
             let expr_idx = self.expr_queued.pop_back().unwrap();
             self.progress_expr(ctx, expr_idx)?;
+        }
         // Every expression checked, and new monomorphs are queued. Transfer the
         // expression information to the type table.
         let definition_id = match &self.definition_type {
             DefinitionType::Component(id) => id.upcast(),
             DefinitionType::Function(id) => id.upcast(),
         };
         let target = ctx.types.get_procedure_expression_data_mut(&definition_id, self.reserved_idx);
         debug_assert!(target.poly_args == self.poly_vars);
         debug_assert!(target.expr_data.is_empty()); // makes sure we never queue something twice
         target.expr_data.reserve(self.expr_types.len());
         for infer_expr in self.expr_types.iter() {
             let mut concrete = ConcreteType::default();
             infer_expr.expr_type.write_concrete_type(&mut concrete);
             target.expr_data.push(MonomorphExpression{
                 expr_type: concrete,
                 field_or_monomorph_idx: infer_expr.field_or_monomorph_idx
             });
+        }
         Ok(())
+    }
     fn progress_expr(&mut self, ctx: &mut Ctx, idx: i32) -> Result<(), ParseError> {
         let id = self.expr_types[idx as usize].expr_id; // TODO: @Temp
         match &ctx.heap[id] {
             Expression::Assignment(expr) => {
                 let id = expr.this;
                 self.progress_assignment_expr(ctx, id)
             },
             Expression::Binding(_expr) => {
                 unimplemented!("progress binding expression");
             Expression::Binding(expr) => {
                 let id = expr.this;
                 self.progress_binding_expr(ctx, id)
             },
             Expression::Conditional(expr) => {
                 let id = expr.this;
                 self.progress_conditional_expr(ctx, id)
             },
             Expression::Binary(expr) => {
                 let id = expr.this;
                 self.progress_binary_expr(ctx, id)
             },
             Expression::Unary(expr) => {
                 let id = expr.this;
                 self.progress_unary_expr(ctx, id)
             },
             Expression::Indexing(expr) => {
                 let id = expr.this;
                 self.progress_indexing_expr(ctx, id)
             },
             Expression::Slicing(expr) => {
                 let id = expr.this;
                 self.progress_slicing_expr(ctx, id)
             },
             Expression::Select(expr) => {
                 let id = expr.this;
                 self.progress_select_expr(ctx, id)
             },
             Expression::Literal(expr) => {
                 let id = expr.this;
                 self.progress_literal_expr(ctx, id)
             },
             Expression::Cast(expr) => {
                 let id = expr.this;
                 self.progress_cast_expr(ctx, id)
             },
             Expression::Call(expr) => {
                 let id = expr.this;
                 self.progress_call_expr(ctx, id)
             },
             Expression::Variable(expr) => {
                 let id = expr.this;
                 self.progress_variable_expr(ctx, id)
+            }
+        }
+    }
     fn progress_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> Result<(), ParseError> {
         use AssignmentOperator as AO;
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_expr_id = expr.left;
         let arg2_expr_id = expr.right;
         debug_log!("Assignment expr '{:?}': {}", expr.operation, upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Arg1 type: {}", self.temp_get_display_name(ctx, arg1_expr_id));
         debug_log!("   - Arg2 type: {}", self.temp_get_display_name(ctx, arg2_expr_id));
         debug_log!("   - Expr type: {}", self.temp_get_display_name(ctx, upcast_id));
         // Assignment does not return anything (it operates like a statement)
         let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &VOID_TEMPLATE)?;
         // Apply forced constraint to LHS value
         let progress_forced = match expr.operation {
             AO::Set =>
                 false,
             AO::Multiplied | AO::Divided | AO::Added | AO::Subtracted =>
                 self.apply_forced_constraint(ctx, arg1_expr_id, &NUMBERLIKE_TEMPLATE)?,
             AO::Remained | AO::ShiftedLeft | AO::ShiftedRight |
             AO::BitwiseAnded | AO::BitwiseXored | AO::BitwiseOred =>
                 self.apply_forced_constraint(ctx, arg1_expr_id, &INTEGERLIKE_TEMPLATE)?,
         };
         let (progress_arg1, progress_arg2) = self.apply_equal2_constraint(
             ctx, upcast_id, arg1_expr_id, 0, arg2_expr_id, 0
         )?;
         debug_assert!(if progress_forced { progress_arg2 } else { true });
         debug_log!(" * After:");
         debug_log!("   - Arg1 type [{}]: {}", progress_forced || progress_arg1, self.temp_get_display_name(ctx, arg1_expr_id));
         debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.temp_get_display_name(ctx, arg2_expr_id));
         debug_log!("   - Expr type [{}]: {}", progress_expr, self.temp_get_display_name(ctx, upcast_id));
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_forced || progress_arg1 { self.queue_expr(ctx, arg1_expr_id); }
         if progress_arg2 { self.queue_expr(ctx, arg2_expr_id); }
         Ok(())
+    }
     fn progress_binding_expr(&mut self, ctx: &mut Ctx, id: BindingExpressionId) -> Result<(), ParseError> {
+    }
     fn progress_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> Result<(), ParseError> {
         // Note: test expression type is already enforced
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_expr_id = expr.true_expression;
         let arg2_expr_id = expr.false_expression;
         debug_log!("Conditional expr: {}", upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Arg1 type: {}", self.temp_get_display_name(ctx, arg1_expr_id));
         debug_log!("   - Arg2 type: {}", self.temp_get_display_name(ctx, arg2_expr_id));
         debug_log!("   - Expr type: {}", self.temp_get_display_name(ctx, upcast_id));
         let (progress_expr, progress_arg1, progress_arg2) = self.apply_equal3_constraint(
             ctx, upcast_id, arg1_expr_id, arg2_expr_id, 0
         )?;
         debug_log!(" * After:");
         debug_log!("   - Arg1 type [{}]: {}", progress_arg1, self.temp_get_display_name(ctx, arg1_expr_id));
         debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.temp_get_display_name(ctx, arg2_expr_id));
         debug_log!("   - Expr type [{}]: {}", progress_expr, self.temp_get_display_name(ctx, upcast_id));
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg1 { self.queue_expr(ctx, arg1_expr_id); }
         if progress_arg2 { self.queue_expr(ctx, arg2_expr_id); }
         Ok(())
+    }
     fn progress_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> Result<(), ParseError> {
         // Note: our expression type might be fixed by our parent, but we still
         // need to make sure it matches the type associated with our operation.
         use BinaryOperator as BO;
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_id = expr.left;
         let arg2_id = expr.right;
         debug_log!("Binary expr '{:?}': {}", expr.operation, upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Arg1 type: {}", self.temp_get_display_name(ctx, arg1_id));
         debug_log!("   - Arg2 type: {}", self.temp_get_display_name(ctx, arg2_id));
         debug_log!("   - Expr type: {}", self.temp_get_display_name(ctx, upcast_id));
         let (progress_expr, progress_arg1, progress_arg2) = match expr.operation {
             BO::Concatenate => {
                 // Arguments may be arrays/slices, output is always an array
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &ARRAY_TEMPLATE)?;
                 let progress_arg1 = self.apply_forced_constraint(ctx, arg1_id, &ARRAYLIKE_TEMPLATE)?;
                 let progress_arg2 = self.apply_forced_constraint(ctx, arg2_id, &ARRAYLIKE_TEMPLATE)?;
                 // If they're all arraylike, then we want the subtype to match
                 let (subtype_expr, subtype_arg1, subtype_arg2) =
                     self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 1)?;
                 (progress_expr || subtype_expr, progress_arg1 || subtype_arg1, progress_arg2 || subtype_arg2)
             },
             BO::LogicalOr | BO::LogicalAnd => {
                 // Forced boolean on all
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg1 = self.apply_forced_constraint(ctx, arg1_id, &BOOL_TEMPLATE)?;
                 let progress_arg2 = self.apply_forced_constraint(ctx, arg2_id, &BOOL_TEMPLATE)?;
                 (progress_expr, progress_arg1, progress_arg2)
             },
             BO::BitwiseOr | BO::BitwiseXor | BO::BitwiseAnd | BO::Remainder | BO::ShiftLeft | BO::ShiftRight => {
                 // All equal of integer type
                 let progress_base = self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg1, progress_arg2) =
                     self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg1, progress_base || progress_arg2)
             },
             BO::Equality | BO::Inequality => {
                 // Equal2 on args, forced boolean output
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let (progress_arg1, progress_arg2) =
                     self.apply_equal2_constraint(ctx, upcast_id, arg1_id, 0, arg2_id, 0)?;
                 (progress_expr, progress_arg1, progress_arg2)
             },
             BO::LessThan | BO::GreaterThan | BO::LessThanEqual | BO::GreaterThanEqual => {
                 // Equal2 on args with numberlike type, forced boolean output
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg_base = self.apply_forced_constraint(ctx, arg1_id, &NUMBERLIKE_TEMPLATE)?;
                 let (progress_arg1, progress_arg2) =
                     self.apply_equal2_constraint(ctx, upcast_id, arg1_id, 0, arg2_id, 0)?;
                 (progress_expr, progress_arg_base || progress_arg1, progress_arg_base || progress_arg2)
             },
             BO::Add | BO::Subtract | BO::Multiply | BO::Divide => {
                 // All equal of number type
                 let progress_base = self.apply_forced_constraint(ctx, upcast_id, &NUMBERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg1, progress_arg2) =
                     self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg1, progress_base || progress_arg2)
             },
         };
         debug_log!(" * After:");
         debug_log!("   - Arg1 type [{}]: {}", progress_arg1, self.temp_get_display_name(ctx, arg1_id));
         debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.temp_get_display_name(ctx, arg2_id));
         debug_log!("   - Expr type [{}]: {}", progress_expr, self.temp_get_display_name(ctx, upcast_id));
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg1 { self.queue_expr(ctx, arg1_id); }
         if progress_arg2 { self.queue_expr(ctx, arg2_id); }
         Ok(())
+    }
     fn progress_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> Result<(), ParseError> {
         use UnaryOperator as UO;
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg_id = expr.expression;
         debug_log!("Unary expr '{:?}': {}", expr.operation, upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Arg  type: {}", self.temp_get_display_name(ctx, arg_id));
         debug_log!("   - Expr type: {}", self.temp_get_display_name(ctx, upcast_id));
         let (progress_expr, progress_arg) = match expr.operation {
             UO::Positive | UO::Negative => {
                 // Equal types of numeric class
                 let progress_base = self.apply_forced_constraint(ctx, upcast_id, &NUMBERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg) =
                     self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, arg_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg)
             },
             UO::BitwiseNot | UO::PreIncrement | UO::PreDecrement | UO::PostIncrement | UO::PostDecrement => {
                 // Equal types of integer class
                 let progress_base = self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg) =
                     self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, arg_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg)
             },
             UO::LogicalNot => {
                 // Both booleans
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 (progress_expr, progress_arg)
+            }
         };
         debug_log!(" * After:");
         debug_log!("   - Arg  type [{}]: {}", progress_arg, self.temp_get_display_name(ctx, arg_id));
         debug_log!("   - Expr type [{}]: {}", progress_expr, self.temp_get_display_name(ctx, upcast_id));
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg { self.queue_expr(ctx, arg_id); }
         Ok(())
+    }
     fn progress_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> Result<(), ParseError> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let subject_id = expr.subject;
         let index_id = expr.index;
         debug_log!("Indexing expr: {}", upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Subject type: {}", self.temp_get_display_name(ctx, subject_id));
         debug_log!("   - Index   type: {}", self.temp_get_display_name(ctx, index_id));
         debug_log!("   - Expr    type: {}", self.temp_get_display_name(ctx, upcast_id));
         // Make sure subject is arraylike and index is integerlike
         let progress_subject_base = self.apply_forced_constraint(ctx, subject_id, &ARRAYLIKE_TEMPLATE)?;
         let progress_index = self.apply_forced_constraint(ctx, index_id, &INTEGERLIKE_TEMPLATE)?;
         // Make sure if output is of T then subject is Array<T>
         let (progress_expr, progress_subject) =
             self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, subject_id, 1)?;
         debug_log!(" * After:");
         debug_log!("   - Subject type [{}]: {}", progress_subject_base || progress_subject, self.temp_get_display_name(ctx, subject_id));
         debug_log!("   - Index   type [{}]: {}", progress_index, self.temp_get_display_name(ctx, index_id));
         debug_log!("   - Expr    type [{}]: {}", progress_expr, self.temp_get_display_name(ctx, upcast_id));
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_subject_base || progress_subject { self.queue_expr(ctx, subject_id); }
         if progress_index { self.queue_expr(ctx, index_id); }
         Ok(())
+    }

Changeset was too big and was cut off... Show full diff anyway

0 comments (0 inline, 0 general)