CSY/reowolf Changeset - 28005c6bf69b · Centrum Wiskunde & Informatica (CWI)

Changeset - 28005c6bf69b

Parent rev.

Child rev.

[Not reviewed]

Merge

2 13 2

Max Henger - 4 years ago 2021-12-21 16:01:52
henger@cwi.nl

Merge branch 'feat-select-statement' into 'master'

feat: select statement

See merge request nl-cwi-csy/reowolf!1

16 files changed with 1088 insertions and 464 deletions:

src/protocol/ast.rs

src/protocol/ast_printer.rs

src/protocol/eval/executor.rs

src/protocol/parser/pass_definitions.rs

src/protocol/parser/pass_typing.rs

src/protocol/parser/pass_validation_linking.rs

437

303

src/protocol/parser/token_parsing.rs

src/protocol/parser/visitor.rs

src/protocol/tests/lexer.rs

109

src/protocol/tests/mod.rs

src/protocol/tests/parser_binding.rs

src/protocol/tests/parser_inference.rs

src/protocol/tests/parser_type_declaration.rs

src/protocol/tests/parser_type_layout.rs

rename

src/protocol/tests/parser_validation.rs

252

src/protocol/tests/utils.rs

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -128,24 +128,26 @@ define_new_ast_id!(MemoryStatementId, LocalStatementId); @@
 define_new_ast_id!(ChannelStatementId, LocalStatementId);
 define_new_ast_id!(LabeledStatementId, StatementId, index(LabeledStatement, Statement::Labeled, statements), alloc(alloc_labeled_statement));
 define_new_ast_id!(IfStatementId, StatementId, index(IfStatement, Statement::If, statements), alloc(alloc_if_statement));
 define_new_ast_id!(EndIfStatementId, StatementId, index(EndIfStatement, Statement::EndIf, statements), alloc(alloc_end_if_statement));
 define_new_ast_id!(WhileStatementId, StatementId, index(WhileStatement, Statement::While, statements), alloc(alloc_while_statement));
 define_new_ast_id!(EndWhileStatementId, StatementId, index(EndWhileStatement, Statement::EndWhile, statements), alloc(alloc_end_while_statement));
 define_new_ast_id!(BreakStatementId, StatementId, index(BreakStatement, Statement::Break, statements), alloc(alloc_break_statement));
 define_new_ast_id!(ContinueStatementId, StatementId, index(ContinueStatement, Statement::Continue, statements), alloc(alloc_continue_statement));
 define_new_ast_id!(SynchronousStatementId, StatementId, index(SynchronousStatement, Statement::Synchronous, statements), alloc(alloc_synchronous_statement));
 define_new_ast_id!(EndSynchronousStatementId, StatementId, index(EndSynchronousStatement, Statement::EndSynchronous, statements), alloc(alloc_end_synchronous_statement));
 define_new_ast_id!(ForkStatementId, StatementId, index(ForkStatement, Statement::Fork, statements), alloc(alloc_fork_statement));
 define_new_ast_id!(EndForkStatementId, StatementId, index(EndForkStatement, Statement::EndFork, statements), alloc(alloc_end_fork_statement));
 define_new_ast_id!(SelectStatementId, StatementId, index(SelectStatement, Statement::Select, statements), alloc(alloc_select_statement));
 define_new_ast_id!(EndSelectStatementId, StatementId, index(EndSelectStatement, Statement::EndSelect, statements), alloc(alloc_end_select_statement));
 define_new_ast_id!(ReturnStatementId, StatementId, index(ReturnStatement, Statement::Return, statements), alloc(alloc_return_statement));
 define_new_ast_id!(GotoStatementId, StatementId, index(GotoStatement, Statement::Goto, statements), alloc(alloc_goto_statement));
 define_new_ast_id!(NewStatementId, StatementId, index(NewStatement, Statement::New, statements), alloc(alloc_new_statement));
 define_new_ast_id!(ExpressionStatementId, StatementId, index(ExpressionStatement, Statement::Expression, statements), alloc(alloc_expression_statement));
 define_aliased_ast_id!(ExpressionId, Id<Expression>, index(Expression, expressions));
 define_new_ast_id!(AssignmentExpressionId, ExpressionId, index(AssignmentExpression, Expression::Assignment, expressions), alloc(alloc_assignment_expression));
 define_new_ast_id!(BindingExpressionId, ExpressionId, index(BindingExpression, Expression::Binding, expressions), alloc(alloc_binding_expression));
 define_new_ast_id!(ConditionalExpressionId, ExpressionId, index(ConditionalExpression, Expression::Conditional, expressions), alloc(alloc_conditional_expression));
 define_new_ast_id!(BinaryExpressionId, ExpressionId, index(BinaryExpression, Expression::Binary, expressions), alloc(alloc_binary_expression));
 define_new_ast_id!(UnaryExpressionId, ExpressionId, index(UnaryExpression, Expression::Unary, expressions), alloc(alloc_unary_expression));
 define_new_ast_id!(IndexingExpressionId, ExpressionId, index(IndexingExpression, Expression::Indexing, expressions), alloc(alloc_indexing_expression));
@@ @@ -688,78 +690,91 @@ impl<'a> Iterator for ConcreteTypeIter<'a> { @@
         self.idx_embedded += 1;
         self.part_idx = end_idx;
         return Some(&self.parts[start_idx..end_idx]);
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum Scope {
     Definition(DefinitionId),
     Regular(BlockStatementId),
-    Synchronous((SynchronousStatementId, BlockStatementId)),
     Synchronous(SynchronousStatementId, BlockStatementId),
+}
 impl Scope {
     pub(crate) fn new_invalid() -> Scope {
         return Scope::Definition(DefinitionId::new_invalid());
+    }
     pub(crate) fn is_invalid(&self) -> bool {
         match self {
             Scope::Definition(id) => id.is_invalid(),
             _ => false,
+        }
+    }
     pub fn is_block(&self) -> bool {
         match &self {
             Scope::Definition(_) => false,
             Scope::Regular(_) => true,
             Scope::Synchronous(_) => true,
+            Scope::Synchronous(_, _) => true,
+        }
+    }
     pub fn to_block(&self) -> BlockStatementId {
         match &self {
             Scope::Regular(id) => *id,
-            Scope::Synchronous((_, 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>,
     pub relative_pos_in_parent: i32,
+}
 impl ScopeNode {
     pub(crate) fn new_invalid() -> Self {
         ScopeNode{
-            parent: Scope::Definition(DefinitionId::new_invalid()),
             parent: Scope::new_invalid(),
             nested: Vec::new(),
             relative_pos_in_parent: -1,
+        }
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum VariableKind {
     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 relative_pos_in_block: i32,
     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),
+}
@@ @@ -1059,24 +1074,26 @@ pub enum Statement { @@
     Local(LocalStatement),
     Labeled(LabeledStatement),
     If(IfStatement),
     EndIf(EndIfStatement),
     While(WhileStatement),
     EndWhile(EndWhileStatement),
     Break(BreakStatement),
     Continue(ContinueStatement),
     Synchronous(SynchronousStatement),
     EndSynchronous(EndSynchronousStatement),
     Fork(ForkStatement),
     EndFork(EndForkStatement),
     Select(SelectStatement),
     EndSelect(EndSelectStatement),
     Return(ReturnStatement),
     Goto(GotoStatement),
     New(NewStatement),
     Expression(ExpressionStatement),
+}
 impl Statement {
     pub fn as_block(&self) -> &BlockStatement {
         match self {
             Statement::Block(result) => result,
             _ => panic!("Unable to cast `Statement` to `BlockStatement`"),
+        }
@@ @@ -1103,71 +1120,78 @@ impl Statement { @@
     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::Fork(v) => v.span,
             Statement::Select(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(_) | Statement::EndFork(_) => unreachable!(),
             Statement::EndBlock(_)
             | Statement::EndIf(_)
             | Statement::EndWhile(_)
             | Statement::EndSynchronous(_)
             | Statement::EndFork(_)
             | Statement::EndSelect(_) => unreachable!(),
+        }
+    }
     pub fn link_next(&mut self, next: StatementId) {
         match self {
             Statement::Block(stmt) => stmt.next = next,
             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::EndFork(stmt) => stmt.next = next,
             Statement::EndSelect(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::Fork(_)
             | Statement::Select(_)
             | 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 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>,
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct EndBlockStatement {
     pub this: EndBlockStatementId,
     // Parser
     pub start_block: BlockStatementId,
     // Validation/Linking
     pub next: StatementId,
@@ @@ -1203,53 +1227,54 @@ impl LocalStatement { @@
             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,
     pub initial_expr: AssignmentExpressionId,
     // 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 relative_pos_in_block: i32,
     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 relative_pos_in_block: i32,
     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,
@@ @@ -1279,35 +1304,35 @@ pub struct EndWhileStatement { @@
     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>,
+    pub target: EndWhileStatementId, // invalid if not yet set
+}
 #[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>,
+    pub target: WhileStatementId, // invalid if not yet set
+}
 #[derive(Debug, Clone)]
 pub struct SynchronousStatement {
     pub this: SynchronousStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "sync" keyword
     pub body: BlockStatementId,
     pub end_sync: EndSynchronousStatementId,
+}
 #[derive(Debug, Clone)]
@@ @@ -1326,40 +1351,65 @@ pub struct ForkStatement { @@
     pub left_body: BlockStatementId,
     pub right_body: Option<BlockStatementId>,
     pub end_fork: EndForkStatementId,
+}
 #[derive(Debug, Clone)]
 pub struct EndForkStatement {
     pub this: EndForkStatementId,
     pub start_fork: ForkStatementId,
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct SelectStatement {
     pub this: SelectStatementId,
     pub span: InputSpan, // of the "select" keyword
     pub cases: Vec<SelectCase>,
     pub end_select: EndSelectStatementId,
+}
 #[derive(Debug, Clone)]
 pub struct SelectCase {
     // The guard statement of a `select` is either a MemoryStatement or an
     // ExpressionStatement. Nothing else is allowed by the initial parsing
     pub guard: StatementId,
     pub block: BlockStatementId,
     // Phase 2: Validation and Linking
     pub involved_ports: Vec<(CallExpressionId, ExpressionId)>, // call to `get` and its port argument
+}
 #[derive(Debug, Clone)]
 pub struct EndSelectStatement {
     pub this: EndSelectStatementId,
     pub start_select: SelectStatementId,
     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>,
+    pub target: LabeledStatementId, // invalid if not yet set
+}
 #[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,
+}
@@ @@ -1367,24 +1417,25 @@ pub struct NewStatement { @@
 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
     Memory(MemoryStatementId),
     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,

src/protocol/ast_printer.rs

➞

Show inline comments

@@ @@ -29,24 +29,26 @@ const PREFIX_CHANNEL_STMT_ID: &'static str = "SCha"; @@
 const PREFIX_SKIP_STMT_ID: &'static str = "SSki";
 const PREFIX_LABELED_STMT_ID: &'static str = "SLab";
 const PREFIX_IF_STMT_ID: &'static str = "SIf ";
 const PREFIX_ENDIF_STMT_ID: &'static str = "SEIf";
 const PREFIX_WHILE_STMT_ID: &'static str = "SWhi";
 const PREFIX_ENDWHILE_STMT_ID: &'static str = "SEWh";
 const PREFIX_BREAK_STMT_ID: &'static str = "SBre";
 const PREFIX_CONTINUE_STMT_ID: &'static str = "SCon";
 const PREFIX_SYNC_STMT_ID: &'static str = "SSyn";
 const PREFIX_ENDSYNC_STMT_ID: &'static str = "SESy";
 const PREFIX_FORK_STMT_ID: &'static str = "SFrk";
 const PREFIX_END_FORK_STMT_ID: &'static str = "SEFk";
 const PREFIX_SELECT_STMT_ID: &'static str = "SSel";
 const PREFIX_END_SELECT_STMT_ID: &'static str = "SESl";
 const PREFIX_RETURN_STMT_ID: &'static str = "SRet";
 const PREFIX_ASSERT_STMT_ID: &'static str = "SAsr";
 const PREFIX_GOTO_STMT_ID: &'static str = "SGot";
 const PREFIX_NEW_STMT_ID: &'static str = "SNew";
 const PREFIX_PUT_STMT_ID: &'static str = "SPut";
 const PREFIX_EXPR_STMT_ID: &'static str = "SExp";
 const PREFIX_ASSIGNMENT_EXPR_ID: &'static str = "EAsi";
 const PREFIX_BINDING_EXPR_ID: &'static str = "EBnd";
 const PREFIX_CONDITIONAL_EXPR_ID: &'static str = "ECnd";
 const PREFIX_BINARY_EXPR_ID: &'static str = "EBin";
 const PREFIX_UNARY_EXPR_ID: &'static str = "EUna";
 const PREFIX_INDEXING_EXPR_ID: &'static str = "EIdx";
@@ @@ -392,25 +394,25 @@ impl ASTWriter { @@
     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("RelativePos").with_disp_val(&stmt.scope_node.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) => {
@@ @@ -422,24 +424,26 @@ impl ASTWriter { @@
                         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("InitialValue");
                         self.write_expr(heap, stmt.initial_expr.upcast(), 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);
             },
@@ @@ -481,33 +485,33 @@ impl ASTWriter { @@
             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));
+                    .with_disp_val(&stmt.target.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));
+                    .with_disp_val(&stmt.target.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);
@@ @@ -521,39 +525,60 @@ impl ASTWriter { @@
                 self.write_stmt(heap, stmt.left_body.upcast(), indent3);
                 if let Some(right_body_id) = stmt.right_body {
                     self.kv(indent2).with_s_key("RightBody");
                     self.write_stmt(heap, right_body_id.upcast(), indent3);
+                }
             },
             Statement::EndFork(stmt) => {
                 self.kv(indent).with_id(PREFIX_END_FORK_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndFork");
                 self.kv(indent2).with_s_key("StartFork").with_disp_val(&stmt.start_fork.0.index);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
             },
             Statement::Select(stmt) => {
                 self.kv(indent).with_id(PREFIX_SELECT_STMT_ID, stmt.this.0.index)
                     .with_s_key("Select");
                 self.kv(indent2).with_s_key("EndSelect").with_disp_val(&stmt.end_select.0.index);
                 self.kv(indent2).with_s_key("Cases");
                 let indent3 = indent2 + 1;
                 let indent4 = indent3 + 1;
                 for case in &stmt.cases {
                     self.kv(indent3).with_s_key("Guard");
                     self.write_stmt(heap, case.guard, indent4);
                     self.kv(indent3).with_s_key("Block");
                     self.write_stmt(heap, case.block.upcast(), indent4);
+                }
             },
             Statement::EndSelect(stmt) => {
                 self.kv(indent).with_id(PREFIX_END_SELECT_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndSelect");
                 self.kv(indent2).with_s_key("StartSelect").with_disp_val(&stmt.start_select.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));
+                    .with_disp_val(&stmt.target.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);
         idx + 1
+    }
     write_concrete_part(target, heap, def_id, t, 0);
+}
 fn write_expression_parent(target: &mut String, parent: &ExpressionParent) {
     use ExpressionParent as EP;
     *target = match parent {
         EP::None => String::from("None"),
         EP::Memory(id) => format!("MemStmt({})", id.0.0.index),
         EP::If(id) => format!("IfStmt({})", id.0.index),
         EP::While(id) => format!("WhileStmt({})", id.0.index),
         EP::Return(id) => format!("ReturnStmt({})", id.0.index),
         EP::New(id) => format!("NewStmt({})", id.0.index),
         EP::ExpressionStmt(id) => format!("ExprStmt({})", id.0.index),
         EP::Expression(id, idx) => format!("Expr({}, {})", id.index, idx)
     };
+}
@@ \ No newline at end of file @@

src/protocol/eval/executor.rs

➞

Show inline comments

@@ @@ -816,26 +816,31 @@ impl Prompt { @@
                 Ok(EvalContinuation::Stepping)
             },
             Statement::EndBlock(stmt) => {
                 let block = &heap[stmt.start_block];
                 self.store.clear_stack(block.first_unique_id_in_scope as usize);
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Memory(stmt) => {
                         let variable = &heap[stmt.variable];
                         self.store.write(ValueId::Stack(variable.unique_id_in_scope as u32), Value::Unassigned);
                         if cfg!(debug_assertions) {
                             let variable = &heap[stmt.variable];
                             debug_assert!(match self.store.read_ref(ValueId::Stack(variable.unique_id_in_scope as u32)) {
                                 Value::Unassigned => false,
                                 _ => true,
                             });
+                        }
                         cur_frame.position = stmt.next;
                         Ok(EvalContinuation::Stepping)
                     },
                     LocalStatement::Channel(stmt) => {
                         // Need to create a new channel by requesting it from
                         // the runtime.
                         match ctx.created_channel() {
                             None => {
                                 // No channel is pending. So request one
                                 Ok(EvalContinuation::NewChannel)
                             },
@@ @@ -882,30 +887,30 @@ impl Prompt { @@
                 } else {
                     cur_frame.position = stmt.end_while.upcast();
+                }
                 Ok(EvalContinuation::Stepping)
             },
             Statement::EndWhile(stmt) => {
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Break(stmt) => {
-                cur_frame.position = stmt.target.unwrap().upcast();
                 cur_frame.position = stmt.target.upcast();
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Continue(stmt) => {
-                cur_frame.position = stmt.target.unwrap().upcast();
                 cur_frame.position = stmt.target.upcast();
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Synchronous(stmt) => {
                 cur_frame.position = stmt.body.upcast();
                 Ok(EvalContinuation::SyncBlockStart)
             },
             Statement::EndSynchronous(stmt) => {
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::SyncBlockEnd)
@@ @@ -927,25 +932,33 @@ impl Prompt { @@
                         // Request the runtime to create a fork of the current
                         // branch
                         return Ok(EvalContinuation::NewFork);
+                    }
+                }
                 Ok(EvalContinuation::Stepping)
             },
             Statement::EndFork(stmt) => {
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
+            }
             },
             Statement::Select(_stmt) => {
                 todo!("implement select evaluation")
             },
             Statement::EndSelect(stmt) => {
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Return(_stmt) => {
                 debug_assert!(heap[cur_frame.definition].is_function());
                 debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for return statement");
                 // The preceding frame has executed a call, so is expecting the
                 // return expression on its expression value stack. Note that
                 // we may be returning a reference to something on our stack,
                 // so we need to read that value and clone it.
                 let return_value = cur_frame.expr_values.pop_back().unwrap();
                 let return_value = match return_value {
                     Value::Ref(value_id) => self.store.read_copy(value_id),
                     _ => return_value,
@@ @@ -970,25 +983,25 @@ impl Prompt { @@
                 debug_assert!(prev_stack_idx >= 0);
                 // Return to original state of stack frame
                 self.store.cur_stack_boundary = prev_stack_idx as usize;
                 let cur_frame = self.frames.last_mut().unwrap();
                 cur_frame.expr_values.push_back(return_value);
                 // We just returned to the previous frame, which might be in
                 // the middle of evaluating expressions for a particular
                 // statement. So we don't want to enter the code below.
                 return Ok(EvalContinuation::Stepping);
             },
             Statement::Goto(stmt) => {
-                cur_frame.position = stmt.target.unwrap().upcast();
                 cur_frame.position = stmt.target.upcast();
                 Ok(EvalContinuation::Stepping)
             },
             Statement::New(stmt) => {
                 let call_expr = &heap[stmt.expression];
                 debug_assert!(heap[call_expr.definition].is_component());
                 debug_assert_eq!(
                     cur_frame.expr_values.len(), heap[call_expr.definition].parameters().len(),
                     "mismatch in expr stack size and number of arguments for new statement"
                 );
                 let mono_data = types.get_procedure_monomorph(cur_frame.monomorph_idx);
@@ @@ -1032,24 +1045,34 @@ impl Prompt { @@
             replaced by something that clears the expression values if needed, but I'll keep this \
             in for now for debugging purposes."
         );
         // If the next statement requires evaluating expressions then we push
         // these onto the expression stack. This way we will evaluate this
         // stack in the next loop, then evaluate the statement using the result
         // from the expression evaluation.
         if !cur_frame.position.is_invalid() {
             let stmt = &heap[cur_frame.position];
             match stmt {
                 Statement::Local(stmt) => {
                     if let LocalStatement::Memory(stmt) = stmt {
                         // Setup as unassigned, when we execute the memory
                         // statement (after evaluating expression), it should no
                         // longer be `Unassigned`.
                         let variable = &heap[stmt.variable];
                         self.store.write(ValueId::Stack(variable.unique_id_in_scope as u32), Value::Unassigned);
                         cur_frame.prepare_single_expression(heap, stmt.initial_expr.upcast());
+                    }
                 },
                 Statement::If(stmt) => cur_frame.prepare_single_expression(heap, stmt.test),
                 Statement::While(stmt) => cur_frame.prepare_single_expression(heap, stmt.test),
                 Statement::Return(stmt) => {
                     debug_assert_eq!(stmt.expressions.len(), 1); // TODO: @ReturnValues
                     cur_frame.prepare_single_expression(heap, stmt.expressions[0]);
                 },
                 Statement::New(stmt) => {
                     // Note that we will end up not evaluating the call itself.
                     // Rather we will evaluate its expressions and then
                     // instantiate the component upon reaching the "new" stmt.
                     let call_expr = &heap[stmt.expression];
                     cur_frame.prepare_multiple_expressions(heap, &call_expr.arguments);

src/protocol/parser/pass_definitions.rs

➞

Show inline comments

@@ @@ -358,25 +358,24 @@ impl PassDefinitions { @@
             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),
                 statements,
                 end_block: EndBlockStatementId::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(),
                 next: StatementId::new_invalid(),
             });
             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;
@@ @@ -447,55 +446,68 @@ impl PassDefinitions { @@
                 let id = self.consume_fork_statement(module, iter, ctx)?;
                 section.push(id.upcast());
                 let end_fork = ctx.heap.alloc_end_fork_statement(|this| EndForkStatement {
                     this,
                     start_fork: id,
                     next: StatementId::new_invalid(),
                 });
                 section.push(end_fork.upcast());
                 let fork_stmt = &mut ctx.heap[id];
                 fork_stmt.end_fork = end_fork;
             } else if ident == KW_STMT_SELECT {
                 let id = self.consume_select_statement(module, iter, ctx)?;
                 section.push(id.upcast());
                 let end_select = ctx.heap.alloc_end_select_statement(|this| EndSelectStatement{
                     this,
                     start_select: id,
                     next: StatementId::new_invalid(),
                 });
                 section.push(end_select.upcast());
                 let select_stmt = &mut ctx.heap[id];
                 select_stmt.end_select = end_select;
             } 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 normal
                 // expression. This is a bit ugly.
                 if let Some((memory_stmt_id, assignment_stmt_id)) = self.maybe_consume_memory_statement(module, iter, ctx)? {
                 if let Some(memory_stmt_id) = self.maybe_consume_memory_statement_without_semicolon(module, iter, ctx)? {
                     consume_token(&module.source, iter, TokenKind::SemiColon)?;
                     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 if next == TokenKind::OpenParen {
             // Same as above: memory statement or normal expression
             if let Some((memory_stmt_id, assignment_stmt_id)) = self.maybe_consume_memory_statement(module, iter, ctx)? {
             if let Some(memory_stmt_id) = self.maybe_consume_memory_statement_without_semicolon(module, iter, ctx)? {
                 consume_token(&module.source, iter, TokenKind::SemiColon)?;
                 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(());
+    }
@@ @@ -525,25 +537,24 @@ impl PassDefinitions { @@
         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(),
             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(),
             next: StatementId::new_invalid(),
         });
         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;
@@ @@ -602,44 +613,44 @@ impl PassDefinitions { @@
         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,
+            target: EndWhileStatementId::new_invalid(),
         }))
+    }
     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
+            target: WhileStatementId::new_invalid(),
         }))
+    }
     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,
@@ @@ -662,24 +673,71 @@ impl PassDefinitions { @@
             None
         };
         Ok(ctx.heap.alloc_fork_statement(|this| ForkStatement{
             this,
             span: fork_span,
             left_body,
             right_body,
             end_fork: EndForkStatementId::new_invalid(),
         }))
+    }
     fn consume_select_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<SelectStatementId, ParseError> {
         let select_span = consume_exact_ident(&module.source, iter, KW_STMT_SELECT)?;
         consume_token(&module.source, iter, TokenKind::OpenCurly)?;
         let mut cases = Vec::new();
         let mut next = iter.next();
         while Some(TokenKind::CloseCurly) != next {
             let guard = match self.maybe_consume_memory_statement_without_semicolon(module, iter, ctx)? {
                 Some(guard_mem_stmt) => guard_mem_stmt.upcast().upcast(),
                 None => {
                     let start_pos = iter.last_valid_pos();
                     let expr = self.consume_expression(module, iter, ctx)?;
                     let end_pos = iter.last_valid_pos();
                     let guard_expr_stmt = ctx.heap.alloc_expression_statement(|this| ExpressionStatement{
                         this,
                         span: InputSpan::from_positions(start_pos, end_pos),
                         expression: expr,
                         next: StatementId::new_invalid(),
                     });
                     guard_expr_stmt.upcast()
                 },
             };
             consume_token(&module.source, iter, TokenKind::ArrowRight)?;
             let block = self.consume_block_or_wrapped_statement(module, iter, ctx)?;
             cases.push(SelectCase{
                 guard, block,
                 involved_ports: Vec::with_capacity(1)
             });
             next = iter.next();
+        }
         consume_token(&module.source, iter, TokenKind::CloseCurly)?;
         Ok(ctx.heap.alloc_select_statement(|this| SelectStatement{
             this,
             span: select_span,
             cases,
             end_select: EndSelectStatementId::new_invalid(),
         }))
+    }
     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, "an expression", None
         )?;
         let expressions = scoped_section.into_vec();
@@ @@ -698,25 +756,25 @@ impl PassDefinitions { @@
+    }
     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
+            target: LabeledStatementId::new_invalid(),
         }))
+    }
     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)?;
         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;
@@ @@ -857,94 +915,95 @@ impl PassDefinitions { @@
             // 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(
     /// Attempts to consume a memory statement (a statement along the lines of
     /// `type var_name = initial_expr`). Will return `Ok(None)` if it didn't
     /// seem like there was a memory statement, `Ok(Some(...))` if there was
     /// one, and `Err(...)` if its reasonable to assume that there was a memory
     /// statement, but we failed to parse it.
     fn maybe_consume_memory_statement_without_semicolon(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
-    ) -> Result<Option<(MemoryStatementId, ExpressionStatementId)>, ParseError> {
     ) -> Result<Option<MemoryStatementId>, 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 = self.type_parser.consume_parser_type(
             iter, &ctx.heap, &module.source, &ctx.symbols, poly_vars,
             definition_id, SymbolScope::Definition(definition_id), true, None
         );
         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.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
+                // Create the AST 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
                 // Create the initial assignment expression
                 // Note: we set the initial variable declaration here
                 let variable_expr_id = ctx.heap.alloc_variable_expression(|this| VariableExpression{
                     this,
                     identifier,
-                    declaration: None,
+                    declaration: Some(local_id),
                     used_as_binding_target: false,
                     parent: ExpressionParent::None,
                     unique_id_in_definition: -1,
                 });
                 let assignment_expr_id = ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{
                     this,
                     operator_span: assign_span,
                     full_span: InputSpan::from_positions(memory_span.begin, initial_expr_end_pos),
                     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{
                 // Put both together in the memory statement
                 let memory_stmt_id = ctx.heap.alloc_memory_statement(|this| MemoryStatement{
                     this,
                     span: InputSpan::from_positions(initial_expr_begin_pos, initial_expr_end_pos),
                     expression: assignment_expr_id.upcast(),
                     next: StatementId::new_invalid(),
                     span: memory_span,
                     variable: local_id,
                     initial_expr: assignment_expr_id,
                     next: StatementId::new_invalid()
                 });
-                return Ok(Some((memory_stmt_id, assignment_stmt_id)))
+                return Ok(Some(memory_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> {

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -1085,29 +1085,34 @@ impl Visitor for PassTyping { @@
         let section = self.stmt_buffer.start_section_initialized(block.statements.as_slice());
         for stmt_id in section.iter_copied() {
             self.visit_stmt(ctx, stmt_id)?;
+        }
         section.forget();
         Ok(())
+    }
     fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {
         let memory_stmt = &ctx.heap[id];
         let initial_expr_id = memory_stmt.initial_expr;
         // Setup memory statement inference
         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));
         // Process the initial value
         self.visit_assignment_expr(ctx, initial_expr_id)?;
         Ok(())
+    }
     fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {
         let channel_stmt = &ctx.heap[id];
         let from_local = &ctx.heap[channel_stmt.from];
         let from_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);
@@ @@ -1161,24 +1166,48 @@ impl Visitor for PassTyping { @@
         let fork_stmt = &ctx.heap[id];
         let left_body_id = fork_stmt.left_body;
         let right_body_id = fork_stmt.right_body;
         self.visit_block_stmt(ctx, left_body_id)?;
         if let Some(right_body_id) = right_body_id {
             self.visit_block_stmt(ctx, right_body_id)?;
+        }
         Ok(())
+    }
     fn visit_select_stmt(&mut self, ctx: &mut Ctx, id: SelectStatementId) -> VisitorResult {
         let select_stmt = &ctx.heap[id];
         let mut section = self.stmt_buffer.start_section();
         let num_cases = select_stmt.cases.len();
         for case in &select_stmt.cases {
             section.push(case.guard);
             section.push(case.block.upcast());
+        }
         for case_index in 0..num_cases {
             let base_index = 2 * case_index;
             let guard_stmt_id = section[base_index    ];
             let block_stmt_id = section[base_index + 1];
             self.visit_stmt(ctx, guard_stmt_id)?;
             self.visit_stmt(ctx, block_stmt_id)?;
+        }
         section.forget();
         Ok(())
+    }
     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;
@@ @@ -3267,25 +3296,25 @@ impl PassTyping { @@
     /// of subexpressions before they have a chance to call this function.
     fn insert_initial_expr_inference_type(
         &mut self, ctx: &mut Ctx, expr_id: ExpressionId
     ) -> Result<(), ParseError> {
         use ExpressionParent as EP;
         use InferenceTypePart as ITP;
         let expr = &ctx.heap[expr_id];
         let inference_type = match expr.parent() {
             EP::None =>
                 // Should have been set by linker
                 unreachable!(),
             EP::ExpressionStmt(_) =>
+            EP::Memory(_) | EP::ExpressionStmt(_) =>
                 // Determined during type inference
                 InferenceType::new(false, false, vec![ITP::Unknown]),
             EP::Expression(parent_id, idx_in_parent) => {
                 // If we are the test expression of a conditional expression,
                 // then we must resolve to a boolean
                 let is_conditional = if let Expression::Conditional(_) = &ctx.heap[*parent_id] {
                     true
                 } else {
                     false
                 };
                 if is_conditional && *idx_in_parent == 0 {

src/protocol/parser/pass_validation_linking.rs

➞

Show inline comments

@@ @@ -60,100 +60,119 @@ impl DefinitionType { @@
     fn is_primitive(&self) -> bool { if let Self::Primitive(_) = self { true } else { false } }
     fn is_composite(&self) -> bool { if let Self::Composite(_) = self { true } else { false } }
     fn is_function(&self) -> bool { if let Self::Function(_) = self { true } else { false } }
     fn definition_id(&self) -> DefinitionId {
         match self {
             DefinitionType::Primitive(v) => v.upcast(),
             DefinitionType::Composite(v) => v.upcast(),
             DefinitionType::Function(v) => v.upcast(),
+        }
+    }
+}
 struct ControlFlowStatement {
     in_sync: SynchronousStatementId,
     in_while: WhileStatementId,
     in_scope: Scope,
     statement: StatementId, // of 'break', 'continue' or 'goto'
+}
 /// This particular visitor will go through the entire AST in a recursive manner
 /// and check if all statements and expressions are legal (e.g. no "return"
 /// statements in component definitions), and will link certain AST nodes to
 /// their appropriate targets (e.g. goto statements, or function calls).
 ///
 /// This visitor will not perform control-flow analysis (e.g. making sure that
 /// each function actually returns) and will also not perform type checking. So
 /// the linking of function calls and component instantiations will be checked
 /// and linked to the appropriate definitions, but the return types and/or
 /// arguments will not be checked for validity.
 ///
 /// The main idea is, because we're visiting nodes in a tree, to do as much as
 /// we can while we have the memory in cache.
 pub(crate) struct PassValidationLinking {
     // Traversal state, all valid IDs if inside a certain AST element. Otherwise
     // `id.is_invalid()` returns true.
     in_sync: SynchronousStatementId,
     in_while: WhileStatementId, // to resolve labeled continue/break
     in_select_guard: SelectStatementId, // for detection/rejection of builtin calls
     in_select_arm: u32,
     in_test_expr: StatementId, // wrapping if/while stmt id
     in_binding_expr: BindingExpressionId, // to resolve variable expressions
     in_binding_expr_lhs: bool,
     // Traversal state, current scope (which can be used to find the parent
     // scope) and the definition variant we are considering.
     cur_scope: Scope,
     def_type: DefinitionType,
     // "Trailing" traversal state, set be child/prev stmt/expr used by next one
     prev_stmt: StatementId,
     expr_parent: ExpressionParent,
     // Set by parent to indicate that child expression must be assignable. The
     // child will throw an error if it is not assignable. The stored span is
     // used for the error's position
     must_be_assignable: Option<InputSpan>,
     // Keeping track of relative positions and unique IDs.
-    relative_pos_in_block: u32, // of statements: to determine when variables are visible
+    relative_pos_in_block: i32, // of statements: to determine when variables are visible
     next_expr_index: i32, // to arrive at a unique ID for all expressions within a definition
     // Control flow statements that require label resolving
     control_flow_stmts: Vec<ControlFlowStatement>,
     // Various temporary buffers for traversal. Essentially working around
     // Rust's borrowing rules since it cannot understand we're modifying AST
     // members but not the AST container.
     variable_buffer: ScopedBuffer<VariableId>,
     definition_buffer: ScopedBuffer<DefinitionId>,
     statement_buffer: ScopedBuffer<StatementId>,
     expression_buffer: ScopedBuffer<ExpressionId>,
+}
 impl PassValidationLinking {
     pub(crate) fn new() -> Self {
         Self{
             in_sync: SynchronousStatementId::new_invalid(),
             in_while: WhileStatementId::new_invalid(),
             in_select_guard: SelectStatementId::new_invalid(),
             in_select_arm: 0,
             in_test_expr: StatementId::new_invalid(),
             in_binding_expr: BindingExpressionId::new_invalid(),
             in_binding_expr_lhs: false,
-            cur_scope: Scope::Definition(DefinitionId::new_invalid()),
             cur_scope: Scope::new_invalid(),
             prev_stmt: StatementId::new_invalid(),
             expr_parent: ExpressionParent::None,
             def_type: DefinitionType::Function(FunctionDefinitionId::new_invalid()),
             must_be_assignable: None,
             relative_pos_in_block: 0,
             next_expr_index: 0,
             control_flow_stmts: Vec::with_capacity(32),
             variable_buffer: ScopedBuffer::with_capacity(128),
             definition_buffer: ScopedBuffer::with_capacity(128),
             statement_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAPACITY),
             expression_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAPACITY),
+        }
+    }
     fn reset_state(&mut self) {
         self.in_sync = SynchronousStatementId::new_invalid();
         self.in_while = WhileStatementId::new_invalid();
         self.in_select_guard = SelectStatementId::new_invalid();
         self.in_test_expr = StatementId::new_invalid();
         self.in_binding_expr = BindingExpressionId::new_invalid();
         self.in_binding_expr_lhs = false;
-        self.cur_scope = Scope::Definition(DefinitionId::new_invalid());
         self.cur_scope = Scope::new_invalid();
         self.def_type = DefinitionType::Function(FunctionDefinitionId::new_invalid());
         self.prev_stmt = StatementId::new_invalid();
         self.expr_parent = ExpressionParent::None;
         self.must_be_assignable = None;
         self.relative_pos_in_block = 0;
         self.next_expr_index = 0
         self.next_expr_index = 0;
         self.control_flow_stmts.clear();
+    }
+}
 macro_rules! assign_then_erase_next_stmt {
     ($self:ident, $ctx:ident, $stmt_id:expr) => {
         if !$self.prev_stmt.is_invalid() {
             $ctx.heap[$self.prev_stmt].link_next($stmt_id);
             $self.prev_stmt = StatementId::new_invalid();
+        }
+    }
+}
@@ @@ -203,24 +222,25 @@ impl Visitor for PassValidationLinking { @@
             let variable = &mut ctx.heap[variable_id];
             variable.unique_id_in_scope = variable_idx as i32;
+        }
         section.forget();
         // Visit statements in component body
         self.visit_block_stmt(ctx, body_id)?;
         // Assign total number of expressions and assign an in-block unique ID
         // to each of the locals in the procedure.
         ctx.heap[id].num_expressions_in_body = self.next_expr_index;
         self.visit_definition_and_assign_local_ids(ctx, id.upcast());
         self.resolve_pending_control_flow_targets(ctx)?;
         Ok(())
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionDefinitionId) -> VisitorResult {
         self.reset_state();
         // Set internal statement indices
         self.def_type = DefinitionType::Function(id);
         self.cur_scope = Scope::Definition(id.upcast());
         self.expr_parent = ExpressionParent::None;
@@ @@ -233,50 +253,93 @@ impl Visitor for PassValidationLinking { @@
             let variable = &mut ctx.heap[variable_id];
             variable.unique_id_in_scope = variable_idx as i32;
+        }
         section.forget();
         // Visit statements in function body
         self.visit_block_stmt(ctx, body_id)?;
         // Assign total number of expressions and assign an in-block unique ID
         // to each of the locals in the procedure.
         ctx.heap[id].num_expressions_in_body = self.next_expr_index;
         self.visit_definition_and_assign_local_ids(ctx, id.upcast());
         self.resolve_pending_control_flow_targets(ctx)?;
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Statement visitors
     //--------------------------------------------------------------------------
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         self.visit_block_stmt_with_hint(ctx, id, None)
         let old_scope = self.push_statement_scope(ctx, Scope::Regular(id));
         // Set end of block
         let block_stmt = &ctx.heap[id];
         let end_block_id = block_stmt.end_block;
         // Copy statement IDs into buffer
         // Traverse statements in block
         let statement_section = self.statement_buffer.start_section_initialized(&block_stmt.statements);
         assign_and_replace_next_stmt!(self, ctx, id.upcast());
         for stmt_idx in 0..statement_section.len() {
             self.relative_pos_in_block = stmt_idx as i32;
             self.visit_stmt(ctx, statement_section[stmt_idx])?;
+        }
         statement_section.forget();
         assign_and_replace_next_stmt!(self, ctx, end_block_id.upcast());
         self.pop_statement_scope(old_scope);
         Ok(())
+    }
     fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {
         let stmt = &ctx.heap[id];
         let expr_id = stmt.initial_expr;
         let variable_id = stmt.variable;
         self.checked_add_local(ctx, self.cur_scope, self.relative_pos_in_block, variable_id)?;
         assign_and_replace_next_stmt!(self, ctx, id.upcast().upcast());
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         self.expr_parent = ExpressionParent::Memory(id);
         self.visit_assignment_expr(ctx, expr_id)?;
         self.expr_parent = ExpressionParent::None;
         Ok(())
+    }
     fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {
         let stmt = &ctx.heap[id];
         let from_id = stmt.from;
         let to_id = stmt.to;
         self.checked_add_local(ctx, self.cur_scope, self.relative_pos_in_block, from_id)?;
         self.checked_add_local(ctx, self.cur_scope, self.relative_pos_in_block, to_id)?;
         assign_and_replace_next_stmt!(self, ctx, id.upcast().upcast());
         Ok(())
+    }
     fn visit_labeled_stmt(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> VisitorResult {
         let body_id = ctx.heap[id].body;
         self.visit_stmt(ctx, body_id)?;
         let stmt = &ctx.heap[id];
         let body_id = stmt.body;
         self.checked_add_label(ctx, self.relative_pos_in_block, self.in_sync, id)?;
         self.visit_stmt(ctx, body_id)?;
         Ok(())
+    }
     fn visit_if_stmt(&mut self, ctx: &mut Ctx, id: IfStatementId) -> VisitorResult {
         let if_stmt = &ctx.heap[id];
         let end_if_id = if_stmt.end_if;
         let test_expr_id = if_stmt.test;
         let true_stmt_id = if_stmt.true_body;
         let false_stmt_id = if_stmt.false_body;
         // Visit test expression
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
@@ @@ -330,51 +393,43 @@ impl Visitor for PassValidationLinking { @@
         self.in_while = old_while;
         // Link final entry in while's block statement back to the while. The
         // executor will go to the end-while statement if the test expression
         // is false, so put that in as the new previous stmt
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         self.prev_stmt = end_while_id.upcast();
         Ok(())
+    }
     fn visit_break_stmt(&mut self, ctx: &mut Ctx, id: BreakStatementId) -> VisitorResult {
         // Resolve break target
         let target_end_while = {
             let stmt = &ctx.heap[id];
             let target_while_id = self.resolve_break_or_continue_target(ctx, stmt.span, &stmt.label)?;
             let target_while = &ctx.heap[target_while_id];
             debug_assert!(!target_while.end_while.is_invalid());
             target_while.end_while
         };
         self.control_flow_stmts.push(ControlFlowStatement{
             in_sync: self.in_sync,
             in_while: self.in_while,
             in_scope: self.cur_scope,
             statement: id.upcast()
         });
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         let stmt = &mut ctx.heap[id];
         stmt.target = Some(target_end_while);
         Ok(())
+    }
     fn visit_continue_stmt(&mut self, ctx: &mut Ctx, id: ContinueStatementId) -> VisitorResult {
         // Resolve continue target
         let target_while_id = {
             let stmt = &ctx.heap[id];
             self.resolve_break_or_continue_target(ctx, stmt.span, &stmt.label)?
         };
         self.control_flow_stmts.push(ControlFlowStatement{
             in_sync: self.in_sync,
             in_while: self.in_while,
             in_scope: self.cur_scope,
             statement: id.upcast()
         });
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         let stmt = &mut ctx.heap[id];
         stmt.target = Some(target_while_id);
         Ok(())
+    }
     fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {
         // Check for validity of synchronous statement
         let sync_stmt = &ctx.heap[id];
         let end_sync_id = sync_stmt.end_sync;
         let cur_sync_span = sync_stmt.span;
         if !self.in_sync.is_invalid() {
             // Nested synchronous statement
             let old_sync_span = ctx.heap[self.in_sync].span;
@@ @@ -386,28 +441,33 @@ impl Visitor for PassValidationLinking { @@
+        }
         if !self.def_type.is_primitive() {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, cur_sync_span,
                 "synchronous statements may only be used in primitive components"
             ));
+        }
         // Synchronous statement implicitly moves to its block
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         // Visit block statement. Note that we explicitly push the scope here
         // (and the `visit_block_stmt` will also push, but without effect) to
         // ensure the scope contains the sync ID.
         let sync_body = ctx.heap[id].body;
         debug_assert!(self.in_sync.is_invalid());
         self.in_sync = id;
         self.visit_block_stmt_with_hint(ctx, sync_body, Some(id))?;
         let old_scope = self.push_statement_scope(ctx, Scope::Synchronous(id, sync_body));
         self.visit_block_stmt(ctx, sync_body)?;
         self.pop_statement_scope(old_scope);
         assign_and_replace_next_stmt!(self, ctx, end_sync_id.upcast());
         self.in_sync = SynchronousStatementId::new_invalid();
         Ok(())
+    }
     fn visit_fork_stmt(&mut self, ctx: &mut Ctx, id: ForkStatementId) -> VisitorResult {
         let fork_stmt = &ctx.heap[id];
         let end_fork_id = fork_stmt.end_fork;
         let left_body_id = fork_stmt.left_body;
         let right_body_id = fork_stmt.right_body;
@@ @@ -427,64 +487,115 @@ impl Visitor for PassValidationLinking { @@
         self.visit_block_stmt(ctx, left_body_id)?;
         assign_then_erase_next_stmt!(self, ctx, end_fork_id.upcast());
         if let Some(right_body_id) = right_body_id {
             self.visit_block_stmt(ctx, right_body_id)?;
             assign_then_erase_next_stmt!(self, ctx, end_fork_id.upcast());
+        }
         self.prev_stmt = end_fork_id.upcast();
         Ok(())
+    }
     fn visit_select_stmt(&mut self, ctx: &mut Ctx, id: SelectStatementId) -> VisitorResult {
         let select_stmt = &ctx.heap[id];
         let end_select_id = select_stmt.end_select;
         // Select statements may only occur inside sync blocks
         if self.in_sync.is_invalid() {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, select_stmt.span,
                 "select statements may only occur inside sync blocks"
             ));
+        }
         if !self.def_type.is_primitive() {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, select_stmt.span,
                 "select statements may only be used in primitive components"
             ));
+        }
         // Visit the various arms in the select block
         let mut case_stmt_ids = self.statement_buffer.start_section();
         let num_cases = select_stmt.cases.len();
         for case in &select_stmt.cases {
             // Note: we add both to the buffer, retrieve them later in indexed
             // fashion
             case_stmt_ids.push(case.guard);
             case_stmt_ids.push(case.block.upcast());
+        }
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         for idx in 0..num_cases {
             let base_idx = 2 * idx;
             let guard_id     = case_stmt_ids[base_idx    ];
             let arm_block_id = case_stmt_ids[base_idx + 1];
             debug_assert_eq!(ctx.heap[arm_block_id].as_block().this.upcast(), arm_block_id); // backwards way of saying arm_block_id is a BlockStatementId
             let arm_block_id = BlockStatementId(arm_block_id);
             // The guard statement ends up belonging to the block statement
             // following the arm. The reason we parse it separately is to
             // extract all of the "get" calls.
             let old_scope = self.push_statement_scope(ctx, Scope::Regular(arm_block_id));
             // Visit the guard of this arm
             debug_assert!(self.in_select_guard.is_invalid());
             self.in_select_guard = id;
             self.in_select_arm = idx as u32;
             self.visit_stmt(ctx, guard_id)?;
             self.in_select_guard = SelectStatementId::new_invalid();
             // Visit the code associated with the guard
             self.visit_block_stmt(ctx, arm_block_id)?;
             self.pop_statement_scope(old_scope);
             // Link up last statement in block to EndSelect
             assign_then_erase_next_stmt!(self, ctx, end_select_id.upcast());
+        }
         self.in_select_guard = SelectStatementId::new_invalid();
         self.prev_stmt = end_select_id.upcast();
         Ok(())
+    }
     fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {
         // Check if "return" occurs within a function
         let stmt = &ctx.heap[id];
         if !self.def_type.is_function() {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, stmt.span,
                 "return statements may only appear in function bodies"
             ));
+        }
         // If here then we are within a function
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         debug_assert_eq!(ctx.heap[id].expressions.len(), 1);
         self.expr_parent = ExpressionParent::Return(id);
         self.visit_expr(ctx, ctx.heap[id].expressions[0])?;
         self.expr_parent = ExpressionParent::None;
         Ok(())
+    }
     fn visit_goto_stmt(&mut self, ctx: &mut Ctx, id: GotoStatementId) -> VisitorResult {
         let target_id = self.find_label(ctx, &ctx.heap[id].label)?;
         ctx.heap[id].target = Some(target_id);
         let target = &ctx.heap[target_id];
         if self.in_sync != target.in_sync {
             // We can only goto the current scope or outer scopes. Because
             // nested sync statements are not allowed we must be inside a sync
             // statement.
             debug_assert!(!self.in_sync.is_invalid());
             let goto_stmt = &ctx.heap[id];
             let sync_stmt = &ctx.heap[self.in_sync];
             return Err(
                 ParseError::new_error_str_at_span(&ctx.module().source, goto_stmt.span, "goto may not escape the surrounding synchronous block")
                 .with_info_str_at_span(&ctx.module().source, target.label.span, "this is the target of the goto statement")
                 .with_info_str_at_span(&ctx.module().source, sync_stmt.span, "which will jump past this statement")
             );
+        }
         self.control_flow_stmts.push(ControlFlowStatement{
             in_sync: self.in_sync,
             in_while: self.in_while,
             in_scope: self.cur_scope,
             statement: id.upcast(),
         });
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         Ok(())
+    }
     fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {
         // Make sure the new statement occurs inside a composite component
         if !self.def_type.is_composite() {
             let new_stmt = &ctx.heap[id];
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, new_stmt.span,
                 "instantiating components may only be done in composite components"
@@ @@ -521,24 +632,25 @@ impl Visitor for PassValidationLinking { @@
     // Expression visitors
     //--------------------------------------------------------------------------
     fn visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let assignment_expr = &mut ctx.heap[id];
         // Although we call assignment an expression to simplify the compiler's
         // code (mainly typechecking), we disallow nested use in expressions
         match self.expr_parent {
             // Look at us: lying through our teeth while providing error messages.
             ExpressionParent::Memory(_) => {},
             ExpressionParent::ExpressionStmt(_) => {},
             _ => {
                 let assignment_span = assignment_expr.full_span;
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, assignment_span,
                     "assignments are statements, and cannot be used in expressions"
                 ))
             },
+        }
         let left_expr_id = assignment_expr.left;
         let right_expr_id = assignment_expr.right;
@@ @@ -1035,110 +1147,125 @@ impl Visitor for PassValidationLinking { @@
         self.next_expr_index += 1;
         // Recurse into the thing that we're casting
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         let subject_id = cast_expr.subject;
         self.visit_expr(ctx, subject_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {
-        let call_expr = &mut ctx.heap[id];
         let call_expr = &ctx.heap[id];
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, span, "cannot assign to the result from a call expression"
             ))
+        }
         // Check whether the method is allowed to be called within the code's
         // context (in sync, definition type, etc.)
         let mut expected_wrapping_new_stmt = false;
         match &mut call_expr.method {
         let mut expecting_wrapping_new_stmt = false;
         let mut expecting_primitive_def = false;
         let mut expecting_wrapping_sync_stmt = false;
         let mut expecting_no_select_stmt = false;
         match call_expr.method {
             Method::Get => {
                 if !self.def_type.is_primitive() {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module().source, call_span,
                         "a call to 'get' may only occur in primitive component definitions"
                     ));
+                }
                 if self.in_sync.is_invalid() {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module().source, call_span,
                         "a call to 'get' may only occur inside synchronous blocks"
                     ));
                 expecting_primitive_def = true;
                 expecting_wrapping_sync_stmt = true;
                 if !self.in_select_guard.is_invalid() {
                     // In a select guard. Take the argument (i.e. the port we're
                     // retrieving from) and add it to the list of involved ports
                     // of the guard
                     if call_expr.arguments.len() == 1 {
                         // We're checking the number of arguments later, for now
                         // assume it is correct.
                         let argument = call_expr.arguments[0];
                         let select_stmt = &mut ctx.heap[self.in_select_guard];
                         let select_case = &mut select_stmt.cases[self.in_select_arm as usize];
                         select_case.involved_ports.push((id, argument));
+                    }
+                }
             },
             Method::Put => {
                 if !self.def_type.is_primitive() {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module().source, call_span,
                         "a call to 'put' may only occur in primitive component definitions"
                     ));
+                }
                 if self.in_sync.is_invalid() {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module().source, call_span,
                         "a call to 'put' may only occur inside synchronous blocks"
                     ));
+                }
                 expecting_primitive_def = true;
                 expecting_wrapping_sync_stmt = true;
                 expecting_no_select_stmt = true;
             },
             Method::Fires => {
                 if !self.def_type.is_primitive() {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module().source, call_span,
                         "a call to 'fires' may only occur in primitive component definitions"
                     ));
+                }
                 if self.in_sync.is_invalid() {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module().source, call_span,
                         "a call to 'fires' may only occur inside synchronous blocks"
                     ));
+                }
                 expecting_primitive_def = true;
                 expecting_wrapping_sync_stmt = true;
             },
             Method::Create => {},
             Method::Length => {},
             Method::Assert => {
                 expecting_wrapping_sync_stmt = true;
                 expecting_no_select_stmt = true;
                 if self.def_type.is_function() {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module().source, call_span,
                         "assert statement may only occur in components"
                     ));
+                }
                 if self.in_sync.is_invalid() {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module().source, call_span,
                         "assert statements may only occur inside synchronous blocks"
                     ));
+                }
             },
             Method::Print => {},
             Method::UserFunction => {},
             Method::UserComponent => {
-                expected_wrapping_new_stmt = true;
+                expecting_wrapping_new_stmt = true;
             },
+        }
         if expected_wrapping_new_stmt {
         let call_expr = &mut ctx.heap[id];
         fn get_span_and_name<'a>(ctx: &'a Ctx, id: CallExpressionId) -> (InputSpan, String) {
             let call = &ctx.heap[id];
             let span = call.func_span;
             let name = String::from_utf8_lossy(ctx.module().source.section_at_span(span)).to_string();
             return (span, name);
+        }
         if expecting_primitive_def {
             if !self.def_type.is_primitive() {
                 let (call_span, func_name) = get_span_and_name(ctx, id);
                 return Err(ParseError::new_error_at_span(
                     &ctx.module().source, call_span,
                     format!("a call to '{}' may only occur in primitive component definitions", func_name)
                 ));
+            }
+        }
         if expecting_wrapping_sync_stmt {
             if self.in_sync.is_invalid() {
                 let (call_span, func_name) = get_span_and_name(ctx, id);
                 return Err(ParseError::new_error_at_span(
                     &ctx.module().source, call_span,
                     format!("a call to '{}' may only occur inside synchronous blocks", func_name)
                 ))
+            }
+        }
         if expecting_no_select_stmt {
             if !self.in_select_guard.is_invalid() {
                 let (call_span, func_name) = get_span_and_name(ctx, id);
                 return Err(ParseError::new_error_at_span(
                     &ctx.module().source, call_span,
                     format!("a call to '{}' may not occur in a select statement's guard", func_name)
                 ));
+            }
+        }
         if expecting_wrapping_new_stmt {
             if !self.expr_parent.is_new() {
                 let call_span = call_expr.func_span;
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, call_span,
                     "cannot call a component, it can only be instantiated by using 'new'"
                 ));
+            }
         } else {
             if self.expr_parent.is_new() {
                 let call_span = call_expr.func_span;
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, call_span,
@@ @@ -1182,225 +1309,181 @@ impl Visitor for PassValidationLinking { @@
             self.visit_expr(ctx, arg_expr_id)?;
+        }
         section.forget();
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {
         let var_expr = &ctx.heap[id];
         let (variable_id, is_binding_target) = match self.find_variable(ctx, self.relative_pos_in_block, &var_expr.identifier) {
             Ok(variable_id) => {
                 // Regular variable
                 (variable_id, false)
             },
             Err(()) => {
                 // Couldn't find variable, but if we're in a binding expression,
                 // then this may be the thing we're binding to.
                 if self.in_binding_expr.is_invalid() || !self.in_binding_expr_lhs {
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module().source, var_expr.identifier.span, "unresolved variable"
                     ));
+                }
         // Check if declaration was already resolved (this occurs for the
         // variable expr that is on the LHS of the assignment expr that is
         // associated with a variable declaration)
         let mut variable_id = var_expr.declaration;
         let mut is_binding_target = false;
                 // This is a binding variable, but it may only appear in very
                 // specific locations.
                 let is_valid_binding = match self.expr_parent {
                     ExpressionParent::Expression(expr_id, idx) => {
                         match &ctx.heap[expr_id] {
                             Expression::Binding(_binding_expr) => {
                                 // Nested binding is disallowed, and because of
                                 // the check above we know we're directly at the
                                 // LHS of the binding expression
                                 debug_assert_eq!(_binding_expr.this, self.in_binding_expr);
                                 debug_assert_eq!(idx, 0);
                                 true
+                            }
                             Expression::Literal(lit_expr) => {
                                 // Only struct, unions and arrays can have
                                 // subexpressions, so we're always fine
                                 if cfg!(debug_assertions) {
                                     match lit_expr.value {
                                         Literal::Struct(_) | Literal::Union(_) | Literal::Array(_) | Literal::Tuple(_) => {},
                                         _ => unreachable!(),
+                                    }
+                                }
         // Otherwise try to find it
         if variable_id.is_none() {
             variable_id = self.find_variable(ctx, self.relative_pos_in_block, &var_expr.identifier);
+        }
                                 true
                             },
                             _ => false,
         // Otherwise try to see if is a variable introduced by a binding expr
         let variable_id = if let Some(variable_id) = variable_id {
             variable_id
         } else {
             if self.in_binding_expr.is_invalid() || !self.in_binding_expr_lhs {
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, var_expr.identifier.span, "unresolved variable"
                 ));
+            }
             // This is a binding variable, but it may only appear in very
             // specific locations.
             let is_valid_binding = match self.expr_parent {
                 ExpressionParent::Expression(expr_id, idx) => {
                     match &ctx.heap[expr_id] {
                         Expression::Binding(_binding_expr) => {
                             // Nested binding is disallowed, and because of
                             // the check above we know we're directly at the
                             // LHS of the binding expression
                             debug_assert_eq!(_binding_expr.this, self.in_binding_expr);
                             debug_assert_eq!(idx, 0);
                             true
+                        }
                     },
                     _ => {
                         false
+                    }
                 };
                         Expression::Literal(lit_expr) => {
                             // Only struct, unions, tuples and arrays can
                             // have subexpressions, so we're always fine
                             if cfg!(debug_assertions) {
                                 match lit_expr.value {
                                     Literal::Struct(_) | Literal::Union(_) | Literal::Array(_) | Literal::Tuple(_) => {},
                                     _ => unreachable!(),
+                                }
+                            }
                 if !is_valid_binding {
                     let binding_expr = &ctx.heap[self.in_binding_expr];
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module().source, var_expr.identifier.span,
                         "illegal location for binding variable: binding variables may only be nested under a binding expression, or a struct, union or array literal"
                     ).with_info_at_span(
                         &ctx.module().source, binding_expr.operator_span, format!(
                             "'{}' was interpreted as a binding variable because the variable is not declared and it is nested under this binding expression",
                             var_expr.identifier.value.as_str()
+                        )
                     ));
                             true
                         },
                         _ => false,
+                    }
                 },
                 _ => {
                     false
+                }
             };
                 // By now we know that this is a valid binding expression. Given
                 // that a binding expression must be nested under an if/while
                 // statement, we now add the variable to the (implicit) block
                 // statement following the if/while statement.
                 let bound_identifier = var_expr.identifier.clone();
                 let bound_variable_id = ctx.heap.alloc_variable(|this| Variable{
                     this,
                     kind: VariableKind::Binding,
                     parser_type: ParserType{
                         elements: vec![ParserTypeElement{
                             element_span: bound_identifier.span,
                             variant: ParserTypeVariant::Inferred
                         }],
                         full_span: bound_identifier.span
                     },
                     identifier: bound_identifier,
                     relative_pos_in_block: 0,
                     unique_id_in_scope: -1,
                 });
             if !is_valid_binding {
                 let binding_expr = &ctx.heap[self.in_binding_expr];
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, var_expr.identifier.span,
                     "illegal location for binding variable: binding variables may only be nested under a binding expression, or a struct, union or array literal"
                 ).with_info_at_span(
                     &ctx.module().source, binding_expr.operator_span, format!(
                         "'{}' was interpreted as a binding variable because the variable is not declared and it is nested under this binding expression",
                         var_expr.identifier.value.as_str()
+                    )
                 ));
+            }
                 let body_stmt_id = match &ctx.heap[self.in_test_expr] {
                     Statement::If(stmt) => stmt.true_body,
                     Statement::While(stmt) => stmt.body,
                     _ => unreachable!(),
                 };
                 let body_scope = Scope::Regular(body_stmt_id);
                 self.checked_at_single_scope_add_local(ctx, body_scope, 0, bound_variable_id)?;
             // By now we know that this is a valid binding expression. Given
             // that a binding expression must be nested under an if/while
             // statement, we now add the variable to the (implicit) block
             // statement following the if/while statement.
             let bound_identifier = var_expr.identifier.clone();
             let bound_variable_id = ctx.heap.alloc_variable(|this| Variable {
                 this,
                 kind: VariableKind::Binding,
                 parser_type: ParserType {
                     elements: vec![ParserTypeElement {
                         element_span: bound_identifier.span,
                         variant: ParserTypeVariant::Inferred
                     }],
                     full_span: bound_identifier.span
                 },
                 identifier: bound_identifier,
                 relative_pos_in_block: 0,
                 unique_id_in_scope: -1,
             });
             let body_stmt_id = match &ctx.heap[self.in_test_expr] {
                 Statement::If(stmt) => stmt.true_body,
                 Statement::While(stmt) => stmt.body,
                 _ => unreachable!(),
             };
             let body_scope = Scope::Regular(body_stmt_id);
             self.checked_at_single_scope_add_local(ctx, body_scope, -1, bound_variable_id)?; // add at -1 such that first statement can access
                 (bound_variable_id, true)
+            }
             is_binding_target = true;
             bound_variable_id
         };
         let var_expr = &mut ctx.heap[id];
         var_expr.declaration = Some(variable_id);
         var_expr.used_as_binding_target = is_binding_target;
         var_expr.parent = self.expr_parent;
         var_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         Ok(())
+    }
+}
 impl PassValidationLinking {
     //--------------------------------------------------------------------------
     // Special traversal
     //--------------------------------------------------------------------------
     fn visit_block_stmt_with_hint(&mut self, ctx: &mut Ctx, id: BlockStatementId, hint: Option<SynchronousStatementId>) -> VisitorResult {
         // Set parent scope and relative position in the parent scope. Remember
         // these values to set them back to the old values when we're done with
         // the traversal of the block's statements.
     /// Pushes a new scope associated with a particular statement. If that
     /// statement already has an associated scope (i.e. scope associated with
     /// sync statement or select statement's arm) then we won't do anything.
     /// In all cases the caller must call `pop_statement_scope` with the scope
     /// and relative scope position returned by this function.
     fn push_statement_scope(&mut self, ctx: &mut Ctx, new_scope: Scope) -> (Scope, i32) {
         let old_scope = self.cur_scope.clone();
         let new_scope = match hint {
             Some(sync_id) => Scope::Synchronous((sync_id, id)),
             None => Scope::Regular(id),
         debug_assert!(new_scope.is_block()); // never call for Definition scope
         let is_new_block = if old_scope.is_block() {
             old_scope.to_block() != new_scope.to_block()
         } else {
             true
         };
         match old_scope {
             Scope::Definition(_def_id) => {
                 // Don't do anything. Block is implicitly a child of a
                 // definition scope.
                 if cfg!(debug_assertions) {
                     match &ctx.heap[_def_id] {
                         Definition::Function(proc_def) => debug_assert_eq!(proc_def.body, id),
                         Definition::Component(proc_def) => debug_assert_eq!(proc_def.body, id),
                         _ => unreachable!(),
+                    }
+                }
             },
             Scope::Regular(block_id) | Scope::Synchronous((_, block_id)) => {
                 let parent_block = &mut ctx.heap[block_id];
                 parent_block.scope_node.nested.push(new_scope);
+            }
         if !is_new_block {
             // No need to push, but still return old scope, we pretend like we
             // replaced it.
             debug_assert!(!ctx.heap[new_scope.to_block()].scope_node.parent.is_invalid());
             return (old_scope, self.relative_pos_in_block);
+        }
         // This is a new block, so link it up
         if old_scope.is_block() {
             let parent_block = &mut ctx.heap[old_scope.to_block()];
             parent_block.scope_node.nested.push(new_scope);
+        }
         self.cur_scope = new_scope;
         let body = &mut ctx.heap[id];
         body.scope_node.parent = old_scope;
         body.relative_pos_in_parent = self.relative_pos_in_block;
         let end_block_id = body.end_block;
         let cur_block = &mut ctx.heap[new_scope.to_block()];
         cur_block.scope_node.parent = old_scope;
         cur_block.scope_node.relative_pos_in_parent = self.relative_pos_in_block;
         let old_relative_pos = self.relative_pos_in_block;
         self.relative_pos_in_block = -1;
         // Copy statement IDs into buffer
         let statement_section = self.statement_buffer.start_section_initialized(&body.statements);
         // Perform the breadth-first pass. Its main purpose is to find labeled
         // statements such that we can find the `goto`-targets immediately when
         // performing the depth pass
         for stmt_idx in 0..statement_section.len() {
             self.relative_pos_in_block = stmt_idx as u32;
             self.visit_statement_for_locals_labels_and_in_sync(ctx, self.relative_pos_in_block, statement_section[stmt_idx])?;
+        }
         // Perform the depth-first traversal
         assign_and_replace_next_stmt!(self, ctx, id.upcast());
         for stmt_idx in 0..statement_section.len() {
             self.relative_pos_in_block = stmt_idx as u32;
             self.visit_stmt(ctx, statement_section[stmt_idx])?;
+        }
         assign_and_replace_next_stmt!(self, ctx, end_block_id.upcast());
         self.cur_scope = old_scope;
         self.relative_pos_in_block = old_relative_pos;
         statement_section.forget();
         Ok(())
         return (old_scope, old_relative_pos)
+    }
     fn visit_statement_for_locals_labels_and_in_sync(&mut self, ctx: &mut Ctx, relative_pos: u32, id: StatementId) -> VisitorResult {
         let statement = &mut ctx.heap[id];
         match statement {
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Memory(local) => {
                         let variable_id = local.variable;
                         self.checked_add_local(ctx, relative_pos, variable_id)?;
                     },
                     LocalStatement::Channel(local) => {
                         let from_id = local.from;
                         let to_id = local.to;
                         self.checked_add_local(ctx, relative_pos, from_id)?;
                         self.checked_add_local(ctx, relative_pos, to_id)?;
+                    }
+                }
+            }
             Statement::Labeled(stmt) => {
                 let stmt_id = stmt.this;
                 let body_id = stmt.body;
                 self.checked_add_label(ctx, relative_pos, self.in_sync, stmt_id)?;
                 self.visit_statement_for_locals_labels_and_in_sync(ctx, relative_pos, body_id)?;
             },
             Statement::While(stmt) => {
                 stmt.in_sync = self.in_sync;
             },
             _ => {},
+        }
         return Ok(())
     fn pop_statement_scope(&mut self, scope_to_restore: (Scope, i32)) {
         self.cur_scope = scope_to_restore.0;
         self.relative_pos_in_block = scope_to_restore.1;
+    }
     fn visit_definition_and_assign_local_ids(&mut self, ctx: &mut Ctx, definition_id: DefinitionId) {
         let mut var_counter = 0;
         // Set IDs on parameters
         let (param_section, body_id) = match &ctx.heap[definition_id] {
             Definition::Function(func_def) => (
                 self.variable_buffer.start_section_initialized(&func_def.parameters),
                 func_def.body
             ),
             Definition::Component(comp_def) => (
@@ @@ -1430,34 +1513,34 @@ impl PassValidationLinking { @@
         let mut scope_section = self.statement_buffer.start_section();
         for child_scope in &block_stmt.scope_node.nested {
             debug_assert!(child_scope.is_block(), "found a child scope that is not a block statement");
             scope_section.push(child_scope.to_block().upcast());
+        }
         let mut var_idx = 0;
         let mut scope_idx = 0;
         while var_idx < var_section.len() || scope_idx < scope_section.len() {
             let relative_var_pos = if var_idx < var_section.len() {
                 ctx.heap[var_section[var_idx]].relative_pos_in_block
             } else {
-                u32::MAX
+                i32::MAX
             };
             let relative_scope_pos = if scope_idx < scope_section.len() {
                 ctx.heap[scope_section[scope_idx]].as_block().relative_pos_in_parent
+                ctx.heap[scope_section[scope_idx]].as_block().scope_node.relative_pos_in_parent
             } else {
-                u32::MAX
+                i32::MAX
             };
-            debug_assert!(!(relative_var_pos == u32::MAX && relative_scope_pos == u32::MAX));
+            debug_assert!(!(relative_var_pos == i32::MAX && relative_scope_pos == i32::MAX));
             // In certain cases the relative variable position is the same as
             // the scope position (insertion of binding variables). In that case
             // the variable should be treated first
             if relative_var_pos <= relative_scope_pos {
                 let var = &mut ctx.heap[var_section[var_idx]];
                 var.unique_id_in_scope = var_counter;
                 var_counter += 1;
                 var_idx += 1;
             } else {
                 // Boy oh boy
                 let block_id = ctx.heap[scope_section[scope_idx]].as_block().this;
@@ @@ -1465,185 +1548,238 @@ impl PassValidationLinking { @@
                 scope_idx += 1;
+            }
+        }
         var_section.forget();
         scope_section.forget();
         // Done assigning all IDs, assign the last ID to the block statement scope
         let block_stmt = &mut ctx.heap[block_id];
         block_stmt.next_unique_id_in_scope = var_counter;
+    }
     fn resolve_pending_control_flow_targets(&mut self, ctx: &mut Ctx) -> Result<(), ParseError> {
         for entry in &self.control_flow_stmts {
             let stmt = &ctx.heap[entry.statement];
             match stmt {
                 Statement::Break(stmt) => {
                     let stmt_id = stmt.this;
                     let target_while_id = Self::resolve_break_or_continue_target(ctx, entry, stmt.span, &stmt.label)?;
                     let target_while_stmt = &ctx.heap[target_while_id];
                     let target_end_while_id = target_while_stmt.end_while;
                     debug_assert!(!target_end_while_id.is_invalid());
                     let break_stmt = &mut ctx.heap[stmt_id];
                     break_stmt.target = target_end_while_id;
                 },
                 Statement::Continue(stmt) => {
                     let stmt_id = stmt.this;
                     let target_while_id = Self::resolve_break_or_continue_target(ctx, entry, stmt.span, &stmt.label)?;
                     let continue_stmt = &mut ctx.heap[stmt_id];
                     continue_stmt.target = target_while_id;
                 },
                 Statement::Goto(stmt) => {
                     let stmt_id = stmt.this;
                     let target_id = Self::find_label(entry.in_scope, ctx, &stmt.label)?;
                     let target_stmt = &ctx.heap[target_id];
                     if entry.in_sync != target_stmt.in_sync {
                         // Nested sync not allowed. And goto can only go to
                         // outer scopes, so we must be escaping from a sync.
                         debug_assert!(target_stmt.in_sync.is_invalid());    // target not in sync
                         debug_assert!(!entry.in_sync.is_invalid()); // but the goto is in sync
                         let goto_stmt = &ctx.heap[stmt_id];
                         let sync_stmt = &ctx.heap[entry.in_sync];
                         return Err(
                             ParseError::new_error_str_at_span(&ctx.module().source, goto_stmt.span, "goto may not escape the surrounding synchronous block")
                             .with_info_str_at_span(&ctx.module().source, target_stmt.label.span, "this is the target of the goto statement")
                             .with_info_str_at_span(&ctx.module().source, sync_stmt.span, "which will jump past this statement")
                         );
+                    }
                     let goto_stmt = &mut ctx.heap[stmt_id];
                     goto_stmt.target = target_id;
                 },
                 _ => unreachable!("cannot resolve control flow target for {:?}", stmt),
+            }
+        }
         return Ok(())
+    }
     //--------------------------------------------------------------------------
     // Utilities
     //--------------------------------------------------------------------------
     /// Adds a local variable to the current scope. It will also annotate the
     /// `Local` in the AST with its relative position in the block.
     fn checked_add_local(&mut self, ctx: &mut Ctx, relative_pos: u32, id: VariableId) -> Result<(), ParseError> {
         debug_assert!(self.cur_scope.is_block());
     fn checked_add_local(&mut self, ctx: &mut Ctx, target_scope: Scope, target_relative_pos: i32, id: VariableId) -> Result<(), ParseError> {
         debug_assert!(target_scope.is_block());
         let local = &ctx.heap[id];
         let mut scope = &self.cur_scope;
         // We immediately go to the parent scope. We check the target scope
         // in the call at the end. That is also where we check for collisions
         // with symbols.
         let block = &ctx.heap[target_scope.to_block()];
         let mut scope = block.scope_node.parent;
         let mut cur_relative_pos = block.scope_node.relative_pos_in_parent;
         loop {
             // We immediately go to the parent scope. We check the current scope
             // in the call at the end. Likewise for checking the symbol table.
             let block = &ctx.heap[scope.to_block()];
             scope = &block.scope_node.parent;
             if let Scope::Definition(definition_id) = scope {
                 // At outer scope, check parameters of function/component
-                for parameter_id in ctx.heap[*definition_id].parameters() {
                 for parameter_id in ctx.heap[definition_id].parameters() {
                     let parameter = &ctx.heap[*parameter_id];
                     if local.identifier == parameter.identifier {
                         return Err(
                             ParseError::new_error_str_at_span(
                                 &ctx.module().source, local.identifier.span, "Local variable name conflicts with parameter"
                             ).with_info_str_at_span(
                                 &ctx.module().source, parameter.identifier.span, "Parameter definition is found here"
+                            )
                         );
+                    }
+                }
                 // No collisions
                 break;
+            }
             // If here then the parent scope is a block scope
-            let local_relative_pos = ctx.heap[scope.to_block()].relative_pos_in_parent;
+            let block = &ctx.heap[scope.to_block()];
             for other_local_id in &block.locals {
                 let other_local = &ctx.heap[*other_local_id];
                 // Position check in case another variable with the same name
                 // is defined in a higher-level scope, but later than the scope
                 // in which the current variable resides.
                 if local.this != *other_local_id &&
-                    local_relative_pos >= other_local.relative_pos_in_block &&
+                    cur_relative_pos >= other_local.relative_pos_in_block &&
                     local.identifier == other_local.identifier {
                     // Collision within this scope
                     return Err(
                         ParseError::new_error_str_at_span(
                             &ctx.module().source, local.identifier.span, "Local variable name conflicts with another variable"
                         ).with_info_str_at_span(
                             &ctx.module().source, other_local.identifier.span, "Previous variable is found here"
+                        )
                     );
+                }
+            }
             scope = block.scope_node.parent;
             cur_relative_pos = block.scope_node.relative_pos_in_parent;
+        }
         // No collisions in any of the parent scope, attempt to add to scope
-        self.checked_at_single_scope_add_local(ctx, self.cur_scope, relative_pos, id)
+        self.checked_at_single_scope_add_local(ctx, target_scope, target_relative_pos, id)
+    }
     /// Adds a local variable to the specified scope. Will check the specified
     /// scope for variable conflicts and the symbol table for global conflicts.
     /// Will NOT check parent scopes of the specified scope.
     fn checked_at_single_scope_add_local(
-        &mut self, ctx: &mut Ctx, scope: Scope, relative_pos: u32, id: VariableId
+        &mut self, ctx: &mut Ctx, scope: Scope, relative_pos: i32, id: VariableId
     ) -> Result<(), ParseError> {
         // Check the symbol table for conflicts
+        {
             let cur_scope = SymbolScope::Definition(self.def_type.definition_id());
             let ident = &ctx.heap[id].identifier;
             if let Some(symbol) = ctx.symbols.get_symbol_by_name(cur_scope, &ident.value.as_bytes()) {
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, ident.span,
                     "local variable declaration conflicts with symbol"
                 ).with_info_str_at_span(
                     &ctx.module().source, symbol.variant.span_of_introduction(&ctx.heap), "the conflicting symbol is introduced here"
                 ));
+            }
+        }
         // Check the specified scope for conflicts
         let local = &ctx.heap[id];
         debug_assert!(scope.is_block());
         let block = &ctx.heap[scope.to_block()];
         for other_local_id in &block.locals {
             let other_local = &ctx.heap[*other_local_id];
             if local.this != other_local.this &&
                 relative_pos >= other_local.relative_pos_in_block &&
+                // relative_pos >= other_local.relative_pos_in_block &&
                 local.identifier == other_local.identifier {
                 // Collision
                 return Err(
                     ParseError::new_error_str_at_span(
                         &ctx.module().source, local.identifier.span, "Local variable name conflicts with another variable"
                     ).with_info_str_at_span(
                         &ctx.module().source, other_local.identifier.span, "Previous variable is found here"
+                    )
                 );
+            }
+        }
         // No collisions
         let block = &mut ctx.heap[scope.to_block()];
         block.locals.push(id);
         let local = &mut ctx.heap[id];
         local.relative_pos_in_block = relative_pos;
         Ok(())
+    }
     /// Finds a variable in the visitor's scope that must appear before the
     /// specified relative position within that block.
-    fn find_variable(&self, ctx: &Ctx, mut relative_pos: u32, identifier: &Identifier) -> Result<VariableId, ()> {
+    fn find_variable(&self, ctx: &Ctx, mut relative_pos: i32, identifier: &Identifier) -> Option<VariableId> {
         debug_assert!(self.cur_scope.is_block());
         // No need to use iterator over namespaces if here
         let mut scope = &self.cur_scope;
         loop {
             debug_assert!(scope.is_block());
             let block = &ctx.heap[scope.to_block()];
             for local_id in &block.locals {
                 let local = &ctx.heap[*local_id];
                 if local.relative_pos_in_block <= relative_pos && identifier == &local.identifier {
                     return Ok(*local_id);
                 if local.relative_pos_in_block < relative_pos && identifier == &local.identifier {
                     return Some(*local_id);
+                }
+            }
             scope = &block.scope_node.parent;
             if !scope.is_block() {
                 // Definition scope, need to check arguments to definition
                 match scope {
                     Scope::Definition(definition_id) => {
                         let definition = &ctx.heap[*definition_id];
                         for parameter_id in definition.parameters() {
                             let parameter = &ctx.heap[*parameter_id];
                             if identifier == &parameter.identifier {
-                                return Ok(*parameter_id);
+                                return Some(*parameter_id);
+                            }
+                        }
                     },
                     _ => unreachable!(),
+                }
                 // Variable could not be found
-                return Err(())
+                return None
             } else {
                 relative_pos = block.relative_pos_in_parent;
+                relative_pos = block.scope_node.relative_pos_in_parent;
+            }
+        }
+    }
     /// Adds a particular label to the current scope. Will return an error if
     /// there is another label with the same name visible in the current scope.
-    fn checked_add_label(&mut self, ctx: &mut Ctx, relative_pos: u32, in_sync: SynchronousStatementId, id: LabeledStatementId) -> Result<(), ParseError> {
+    fn checked_add_label(&mut self, ctx: &mut Ctx, relative_pos: i32, in_sync: SynchronousStatementId, id: LabeledStatementId) -> Result<(), ParseError> {
         debug_assert!(self.cur_scope.is_block());
         // Make sure label is not defined within the current scope or any of the
         // parent scope.
         let label = &mut ctx.heap[id];
         label.relative_pos_in_block = relative_pos;
         label.in_sync = in_sync;
         let label = &ctx.heap[id];
         let mut scope = &self.cur_scope;
         loop {
@@ @@ -1668,138 +1804,136 @@ impl PassValidationLinking { @@
+        }
         // No collisions
         let block = &mut ctx.heap[self.cur_scope.to_block()];
         block.labels.push(id);
         Ok(())
+    }
     /// Finds a particular labeled statement by its identifier. Once found it
     /// will make sure that the target label does not skip over any variable
     /// declarations within the scope in which the label was found.
     fn find_label(&self, ctx: &Ctx, identifier: &Identifier) -> Result<LabeledStatementId, ParseError> {
         debug_assert!(self.cur_scope.is_block());
     fn find_label(mut scope: Scope, ctx: &Ctx, identifier: &Identifier) -> Result<LabeledStatementId, ParseError> {
         debug_assert!(scope.is_block());
         let mut scope = &self.cur_scope;
         loop {
             debug_assert!(scope.is_block(), "scope is not a block");
             let relative_scope_pos = ctx.heap[scope.to_block()].relative_pos_in_parent;
+            let relative_scope_pos = ctx.heap[scope.to_block()].scope_node.relative_pos_in_parent;
             let block = &ctx.heap[scope.to_block()];
             for label_id in &block.labels {
                 let label = &ctx.heap[*label_id];
                 if label.label == *identifier {
                     for local_id in &block.locals {
                         // TODO: Better to do this in control flow analysis, it
                         //  is legal to skip over a variable declaration if it
                         //  is not actually being used. I might be missing
                         //  something here when laying out the bytecode...
                         let local = &ctx.heap[*local_id];
                         if local.relative_pos_in_block > relative_scope_pos && local.relative_pos_in_block < label.relative_pos_in_block {
                             return Err(
                                 ParseError::new_error_str_at_span(&ctx.module().source, identifier.span, "this target label skips over a variable declaration")
                                 .with_info_str_at_span(&ctx.module().source, label.label.span, "because it jumps to this label")
                                 .with_info_str_at_span(&ctx.module().source, local.identifier.span, "which skips over this variable")
                             );
+                        }
+                    }
                     return Ok(*label_id);
+                }
+            }
-            scope = &block.scope_node.parent;
             scope = block.scope_node.parent;
             if !scope.is_block() {
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, identifier.span, "could not find this label"
                 ));
+            }
+        }
+    }
     /// This function will check if the provided while statement ID has a block
     /// statement that is one of our current parents.
     fn has_parent_while_scope(&self, ctx: &Ctx, id: WhileStatementId) -> bool {
         let mut scope = &self.cur_scope;
     fn has_parent_while_scope(mut scope: Scope, ctx: &Ctx, id: WhileStatementId) -> bool {
         let while_stmt = &ctx.heap[id];
         loop {
             debug_assert!(scope.is_block());
             let block = scope.to_block();
             if while_stmt.body == block {
                 return true;
+            }
             let block = &ctx.heap[block];
-            scope = &block.scope_node.parent;
             scope = block.scope_node.parent;
             if !scope.is_block() {
                 return false;
+            }
+        }
+    }
     /// This function should be called while dealing with break/continue
     /// statements. It will try to find the targeted while statement, using the
     /// target label if provided. If a valid target is found then the loop's
     /// ID will be returned, otherwise a parsing error is constructed.
     /// The provided input position should be the position of the break/continue
     /// statement.
-    fn resolve_break_or_continue_target(&self, ctx: &Ctx, span: InputSpan, label: &Option<Identifier>) -> Result<WhileStatementId, ParseError> {
+    fn resolve_break_or_continue_target(ctx: &Ctx, control_flow: &ControlFlowStatement, span: InputSpan, label: &Option<Identifier>) -> Result<WhileStatementId, ParseError> {
         let target = match label {
             Some(label) => {
-                let target_id = self.find_label(ctx, label)?;
+                let target_id = Self::find_label(control_flow.in_scope, ctx, label)?;
                 // Make sure break target is a while statement
                 let target = &ctx.heap[target_id];
                 if let Statement::While(target_stmt) = &ctx.heap[target.body] {
                     // Even though we have a target while statement, the break might not be
                     // present underneath this particular labeled while statement
-                    if !self.has_parent_while_scope(ctx, target_stmt.this) {
+                    if !Self::has_parent_while_scope(control_flow.in_scope, ctx, target_stmt.this) {
                         return Err(ParseError::new_error_str_at_span(
                             &ctx.module().source, label.span, "break statement is not nested under the target label's while statement"
                         ).with_info_str_at_span(
                             &ctx.module().source, target.label.span, "the targeted label is found here"
                         ));
+                    }
                     target_stmt.this
                 } else {
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module().source, label.span, "incorrect break target label, it must target a while loop"
                     ).with_info_str_at_span(
                         &ctx.module().source, target.label.span, "The targeted label is found here"
                     ));
+                }
             },
             None => {
                 // Use the enclosing while statement, the break must be
                 // nested within that while statement
-                if self.in_while.is_invalid() {
+                if control_flow.in_while.is_invalid() {
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module().source, span, "Break statement is not nested under a while loop"
                     ));
+                }
-                self.in_while
+                control_flow.in_while
+            }
         };
         // We have a valid target for the break statement. But we need to
         // make sure we will not break out of a synchronous block
+        {
             let target_while = &ctx.heap[target];
-            if target_while.in_sync != self.in_sync {
+            if target_while.in_sync != control_flow.in_sync {
                 // Break is nested under while statement, so can only escape a
                 // sync block if the sync is nested inside the while statement.
                 debug_assert!(!self.in_sync.is_invalid());
                 let sync_stmt = &ctx.heap[self.in_sync];
                 debug_assert!(!control_flow.in_sync.is_invalid());
                 let sync_stmt = &ctx.heap[control_flow.in_sync];
                 return Err(
                     ParseError::new_error_str_at_span(&ctx.module().source, span, "break may not escape the surrounding synchronous block")
                         .with_info_str_at_span(&ctx.module().source, target_while.span, "the break escapes out of this loop")
                         .with_info_str_at_span(&ctx.module().source, sync_stmt.span, "And would therefore escape this synchronous block")
                 );
+            }
+        }
         Ok(target)
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/token_parsing.rs

➞

Show inline comments

@@ @@ -38,24 +38,25 @@ pub(crate) const KW_FUNC_PRINT: &'static [u8] = b"print"; @@
 // Keywords - statements
 pub(crate) const KW_STMT_CHANNEL:  &'static [u8] = b"channel";
 pub(crate) const KW_STMT_IF:       &'static [u8] = b"if";
 pub(crate) const KW_STMT_ELSE:     &'static [u8] = b"else";
 pub(crate) const KW_STMT_WHILE:    &'static [u8] = b"while";
 pub(crate) const KW_STMT_BREAK:    &'static [u8] = b"break";
 pub(crate) const KW_STMT_CONTINUE: &'static [u8] = b"continue";
 pub(crate) const KW_STMT_GOTO:     &'static [u8] = b"goto";
 pub(crate) const KW_STMT_RETURN:   &'static [u8] = b"return";
 pub(crate) const KW_STMT_SYNC:     &'static [u8] = b"sync";
 pub(crate) const KW_STMT_FORK:     &'static [u8] = b"fork";
 pub(crate) const KW_STMT_SELECT:   &'static [u8] = b"select";
 pub(crate) const KW_STMT_OR:       &'static [u8] = b"or";
 pub(crate) const KW_STMT_NEW:      &'static [u8] = b"new";
 // Keywords - types
 // Since types are needed for returning diagnostic information to the user, the
 // string variants are put here as well.
 pub(crate) const KW_TYPE_IN_PORT_STR:  &'static str = "in";
 pub(crate) const KW_TYPE_OUT_PORT_STR: &'static str = "out";
 pub(crate) const KW_TYPE_MESSAGE_STR:  &'static str = "msg";
 pub(crate) const KW_TYPE_BOOL_STR:     &'static str = "bool";
 pub(crate) const KW_TYPE_UINT8_STR:    &'static str = "u8";
 pub(crate) const KW_TYPE_UINT16_STR:   &'static str = "u16";

src/protocol/parser/visitor.rs

➞

Show inline comments

@@ @@ -124,24 +124,29 @@ pub(crate) trait Visitor { @@
                 self.visit_continue_stmt(ctx, this)
             },
             Statement::Synchronous(stmt) => {
                 let this = stmt.this;
                 self.visit_synchronous_stmt(ctx, this)
             },
             Statement::EndSynchronous(_stmt) => Ok(()),
             Statement::Fork(stmt) => {
                 let this = stmt.this;
                 self.visit_fork_stmt(ctx, this)
             },
             Statement::EndFork(_stmt) => Ok(()),
             Statement::Select(stmt) => {
                 let this = stmt.this;
                 self.visit_select_stmt(ctx, this)
             },
             Statement::EndSelect(_stmt) => Ok(()),
             Statement::Return(stmt) => {
                 let this = stmt.this;
                 self.visit_return_stmt(ctx, this)
             },
             Statement::Goto(stmt) => {
                 let this = stmt.this;
                 self.visit_goto_stmt(ctx, this)
             },
             Statement::New(stmt) => {
                 let this = stmt.this;
                 self.visit_new_stmt(ctx, this)
             },
@@ @@ -167,24 +172,25 @@ pub(crate) trait Visitor { @@
     // --- enum variant handling
     fn visit_block_stmt(&mut self, _ctx: &mut Ctx, _id: BlockStatementId) -> VisitorResult { Ok(()) }
     fn visit_local_memory_stmt(&mut self, _ctx: &mut Ctx, _id: MemoryStatementId) -> VisitorResult { Ok(()) }
     fn visit_local_channel_stmt(&mut self, _ctx: &mut Ctx, _id: ChannelStatementId) -> VisitorResult { Ok(()) }
     fn visit_labeled_stmt(&mut self, _ctx: &mut Ctx, _id: LabeledStatementId) -> VisitorResult { Ok(()) }
     fn visit_if_stmt(&mut self, _ctx: &mut Ctx, _id: IfStatementId) -> VisitorResult { Ok(()) }
     fn visit_while_stmt(&mut self, _ctx: &mut Ctx, _id: WhileStatementId) -> VisitorResult { Ok(()) }
     fn visit_break_stmt(&mut self, _ctx: &mut Ctx, _id: BreakStatementId) -> VisitorResult { Ok(()) }
     fn visit_continue_stmt(&mut self, _ctx: &mut Ctx, _id: ContinueStatementId) -> VisitorResult { Ok(()) }
     fn visit_synchronous_stmt(&mut self, _ctx: &mut Ctx, _id: SynchronousStatementId) -> VisitorResult { Ok(()) }
     fn visit_fork_stmt(&mut self, _ctx: &mut Ctx, _id: ForkStatementId) -> VisitorResult { Ok(()) }
     fn visit_select_stmt(&mut self, _ctx: &mut Ctx, _id: SelectStatementId) -> VisitorResult { Ok(()) }
     fn visit_return_stmt(&mut self, _ctx: &mut Ctx, _id: ReturnStatementId) -> VisitorResult { Ok(()) }
     fn visit_goto_stmt(&mut self, _ctx: &mut Ctx, _id: GotoStatementId) -> VisitorResult { Ok(()) }
     fn visit_new_stmt(&mut self, _ctx: &mut Ctx, _id: NewStatementId) -> VisitorResult { Ok(()) }
     fn visit_expr_stmt(&mut self, _ctx: &mut Ctx, _id: ExpressionStatementId) -> VisitorResult { Ok(()) }
     // Expressions
     // --- enum matching
     fn visit_expr(&mut self, ctx: &mut Ctx, id: ExpressionId) -> VisitorResult {
         match &ctx.heap[id] {
             Expression::Assignment(expr) => {
                 let this = expr.this;
                 self.visit_assignment_expr(ctx, this)

src/protocol/tests/lexer.rs

➞

Show inline comments

deleted file

src/protocol/tests/mod.rs

➞

Show inline comments

@@ @@ -3,28 +3,28 @@ @@
+ *
  * Contains tests for various parts of the lexer/parser and the evaluator of the
  * code. These are intended to be temporary tests such that we're sure that we
  * don't break existing functionality.
+ *
  * In the future these should be replaced by proper testing protocols.
+ *
  * If any of these tests fail, and you think they're not needed anymore, feel
  * free to cast them out into oblivion, where dead code goes to die.
  */
 mod utils;
 mod lexer;
 mod parser_binding;
 mod parser_imports;
 mod parser_inference;
 mod parser_literals;
 mod parser_monomorphs;
 mod parser_types;
 mod parser_type_declaration;
 mod parser_type_layout;
 mod parser_validation;
 mod eval_binding;
 mod eval_calls;
 mod eval_casting;
 mod eval_operators;
 mod eval_silly;
 pub(crate) use utils::{Tester}; // the testing harness
 pub(crate) use crate::protocol::eval::value::*; // to test functions
@@ \ No newline at end of file @@

src/protocol/tests/parser_binding.rs

➞

Show inline comments

@@ @@ -51,24 +51,66 @@ fn test_incorrect_binding() { @@
+            }
             return false;
+        }
     ").error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "let a = ")
         .assert_msg_has(0, "nested binding")
         .assert_occurs_at(1, "let Struct")
         .assert_msg_has(1, "outer binding");
     });
+}
 #[test]
 fn test_incorrect_binding_variable() {
     // Note: if variable already exists then it is interpreted at the binding
     // expression as value. So the case where "the variable is already defined"
     // results in no binding variable.
     Tester::new_single_source_expect_err("binding var in next scope", "
         union Option<T>{ Some(T), None }
         func foo() -> bool {
             auto opt = Option::Some(false);
             if (let Option::Some(var) = opt) {
                 auto var = true; // should mismatch against binding 'var'
                 return var;
+            }
             return false;
+        }
     ").error(|e| { e
         .assert_num(2)
         .assert_msg_has(0, "variable name conflicts")
         .assert_occurs_at(0, "var = true;")
         .assert_occurs_at(1, "var) = opt");
     });
     Tester::new_single_source_expect_err("binding var in nested scope", "
         union LR<A, B>{ L(A), R(B) }
         func foo() -> u32 {
             LR<auto, u32> x = LR::L(5);
             if (let LR::L(y) = x) {
                 if (true) {
                     auto y = 5;
                     return y;
+                }
+            }
+        }
     ").error(|e| { e
         .assert_num(2)
         .assert_msg_has(0, "variable name conflicts")
         .assert_occurs_at(0, "y = 5")
         .assert_occurs_at(1, "y) = x");
     });
+}
 #[test]
 fn test_boolean_ops_on_binding() {
     Tester::new_single_source_expect_ok("apply && to binding result", "
         union TestUnion{ Two(u16), Four(u32), Eight(u64) }
         func foo() -> u32 {
             auto lit_2 = TestUnion::Two(2);
             auto lit_4 = TestUnion::Four(4);
             auto lit_8 = TestUnion::Eight(8);
             // Testing combined forms of bindings
             if (
                 let TestUnion::Two(test_2) = lit_2 &&

src/protocol/tests/parser_inference.rs

➞

Show inline comments

@@ @@ -459,24 +459,74 @@ fn test_failed_polymorph_inference() { @@
         func test() -> s32 {
             s8 assigned = 0;
             s64 another = 1;
             auto thing = construct(assigned, construct(another, 1));
             fix_poly(thing.r);
             thing.r.r = assigned;
             return 0;
+        }
         ",
     );
+}
 #[test]
 fn test_disallowed_inference() {
     Tester::new_single_source_expect_err(
         "argument auto inference",
         "func thing(auto arg) -> s32 { return 0; }"
     ).error(|e| { e
         .assert_msg_has(0, "inference is not allowed")
         .assert_occurs_at(0, "auto arg");
     });
     Tester::new_single_source_expect_err(
         "return type auto inference",
         "func thing(s32 arg) -> auto { return 0; }"
     ).error(|e| { e
         .assert_msg_has(0, "inference is not allowed")
         .assert_occurs_at(0, "auto {");
     });
     Tester::new_single_source_expect_err(
         "implicit polymorph argument auto inference",
         "func thing(in port) -> s32 { return port; }"
     ).error(|e| { e
         .assert_msg_has(0, "inference is not allowed")
         .assert_occurs_at(0, "in port");
     });
     Tester::new_single_source_expect_err(
         "explicit polymorph argument auto inference",
         "func thing(in<auto> port) -> s32 { return port; }"
     ).error(|e| { e
         .assert_msg_has(0, "inference is not allowed")
         .assert_occurs_at(0, "auto> port");
     });
     Tester::new_single_source_expect_err(
         "implicit polymorph return type auto inference",
         "func thing(in<msg> a, in<msg> b) -> in { return a; }"
     ).error(|e| { e
         .assert_msg_has(0, "inference is not allowed")
         .assert_occurs_at(0, "in {");
     });
     Tester::new_single_source_expect_err(
         "explicit polymorph return type auto inference",
         "func thing(in<msg> a) -> in<auto> { return a; }"
     ).error(|e| { e
         .assert_msg_has(0, "inference is not allowed")
         .assert_occurs_at(0, "auto> {");
     });
+}
 #[test]
 fn test_explicit_polymorph_argument() {
     // Failed because array was put at same type depth as u32. So interpreted
     // as a function with two polymorphic arguments
     Tester::new_single_source_expect_ok("explicit with array", "
     func foo<T>(T a, T b) -> T {
         return a @ b;
+    }
     func test() -> u32 {
         return foo<u32[]>({1}, {2})[1];
     }").for_function("test", |f| { f

src/protocol/tests/parser_type_declaration.rs

➞

Show inline comments

@@ new file 100644 @@
 use super::*;
 #[test]
 fn test_simple_struct_definition() {
     Tester::new_single_source_expect_ok(
         "empty struct",
         "struct Foo{}"
     ).for_struct("Foo", |t| { t.assert_num_fields(0); });
     Tester::new_single_source_expect_ok(
         "single field, no comma",
         "struct Foo{ s32 field }"
     ).for_struct("Foo", |t| { t
         .assert_num_fields(1)
         .for_field("field", |f| {
             f.assert_parser_type("s32");
         });
     });
     Tester::new_single_source_expect_ok(
         "single field, with comma",
         "struct Foo{ s32 field, }"
     ).for_struct("Foo", |t| { t
         .assert_num_fields(1)
         .for_field("field", |f| { f
             .assert_parser_type("s32");
         });
     });
     Tester::new_single_source_expect_ok(
         "multiple fields, no comma",
         "struct Foo{ u8 a, s16 b, s32 c }"
     ).for_struct("Foo", |t| { t
         .assert_num_fields(3)
         .for_field("a", |f| { f.assert_parser_type("u8"); })
         .for_field("b", |f| { f.assert_parser_type("s16"); })
         .for_field("c", |f| { f.assert_parser_type("s32"); });
     });
     Tester::new_single_source_expect_ok(
         "multiple fields, with comma",
         "struct Foo{
             u8 a,
             s16 b,
             s32 c,
         }"
     ).for_struct("Foo", |t| { t
         .assert_num_fields(3)
         .for_field("a", |f| { f.assert_parser_type("u8"); })
         .for_field("b", |f| { f.assert_parser_type("s16"); })
         .for_field("c", |f| { f.assert_parser_type("s32"); });
     });
+}
@@ \ No newline at end of file @@

src/protocol/tests/parser_type_layout.rs

➞

Show inline comments

file renamed from src/protocol/tests/parser_types.rs to src/protocol/tests/parser_type_layout.rs

src/protocol/tests/parser_validation.rs

➞

Show inline comments

 /// parser_validation.rs
 ///
 /// Simple tests for the validation phase
 use super::*;
 #[test]
 fn test_correct_struct_instance() {
     Tester::new_single_source_expect_ok(
         "single field",
+        "
         struct Foo { s32 a }
         func bar(s32 arg) -> Foo { return Foo{ a: arg }; }
+        "
     );
     Tester::new_single_source_expect_ok(
         "multiple fields",
@@ @@ -519,13 +521,263 @@ fn test_polymorph_array_types() { @@
     ).for_struct("Bar", |s| { s
         .for_field("world", |f| { f.assert_parser_type("Foo<u32>[]"); });
     });
     Tester::new_single_source_expect_ok(
         "array of port in struct",
+        "
         struct Bar { in<u32>[] inputs }
+        "
     ).for_struct("Bar", |s| { s
         .for_field("inputs", |f| { f.assert_parser_type("in<u32>[]"); });
     });
+}
 #[test]
 fn test_correct_modifying_operators() {
     // Not testing the types, just that it parses
     Tester::new_single_source_expect_ok(
         "valid uses",
+        "
         func f() -> u32 {
             auto a = 5;
             a += 2; a -= 2; a *= 2; a /= 2; a %= 2;
             a <<= 2; a >>= 2;
             a |= 2; a &= 2; a ^= 2;
             return a;
+        }
+        "
     );
+}
 #[test]
 fn test_incorrect_modifying_operators() {
     Tester::new_single_source_expect_err(
         "wrong declaration",
         "func f() -> u8 { auto a += 2; return a; }"
     ).error(|e| { e.assert_msg_has(0, "expected '='"); });
     Tester::new_single_source_expect_err(
         "inside function",
         "func f(u32 a) -> u32 { auto b = 0; auto c = f(a += 2); }"
     ).error(|e| { e.assert_msg_has(0, "assignments are statements"); });
     Tester::new_single_source_expect_err(
         "inside tuple",
         "func f(u32 a) -> u32 { auto b = (a += 2, a /= 2); return 0; }"
     ).error(|e| { e.assert_msg_has(0, "assignments are statements"); });
+}
 #[test]
 fn test_variable_introduction_in_scope() {
     Tester::new_single_source_expect_err(
         "variable use before declaration",
         "func f() -> u8 { return thing; auto thing = 5; }"
     ).error(|e| { e.assert_msg_has(0, "unresolved variable"); });
     Tester::new_single_source_expect_err(
         "variable use in declaration",
         "func f() -> u8 { auto thing = 5 + thing; return thing; }"
     ).error(|e| { e.assert_msg_has(0, "unresolved variable"); });
     Tester::new_single_source_expect_ok(
         "variable use after declaration",
         "func f() -> u8 { auto thing = 5; return thing; }"
     );
     Tester::new_single_source_expect_err(
         "variable use of closed scope",
         "func f() -> u8 { { auto thing = 5; } return thing; }"
     ).error(|e| { e.assert_msg_has(0, "unresolved variable"); });
+}
 #[test]
 fn test_correct_select_statement() {
     Tester::new_single_source_expect_ok(
         "guard variable decl",
+        "
         primitive f() {
             channel<u32> unused -> input;
             u32 outer_value = 0;
             sync select {
                 auto in_same_guard = get(input) -> {} // decl A1
                 auto in_same_gaurd = get(input) -> {} // decl A2
                 auto in_guard_and_block = get(input) -> {} // decl B1
                 outer_value = get(input) -> { auto in_guard_and_block = outer_value; } // decl B2
+            }
+        }
+        "
     );
     Tester::new_single_source_expect_ok(
         "empty select",
         "primitive f() { sync select {} }"
     );
     Tester::new_single_source_expect_ok(
         "mixed uses", "
         primitive f() {
             channel unused_output -> input;
             u32 outer_value = 0;
             sync select {
                 outer_value = get(input) -> outer_value = 0;
                 auto new_value = get(input) -> {
                     outer_value = new_value;
+                }
                 get(input) + get(input) ->
                     outer_value = 8;
                 get(input) ->
                     {}
                 outer_value %= get(input) -> {
                     outer_value *= outer_value;
                     auto new_value = get(input);
                     outer_value += new_value;
+                }
+            }
+        }
+        "
     );
+}
 #[test]
 fn test_incorrect_select_statement() {
     Tester::new_single_source_expect_err(
         "outside sync",
         "primitive f() { select {} }"
     ).error(|e| { e
         .assert_num(1)
         .assert_occurs_at(0, "select")
         .assert_msg_has(0, "inside sync blocks");
     });
     Tester::new_single_source_expect_err(
         "variable in previous block",
         "primitive f() {
             channel<u32> tx -> rx;
             u32 a = 0; // this one will be shadowed
             sync select { auto a = get(rx) -> {} }
         }"
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "a = get").assert_msg_has(0, "variable name conflicts")
         .assert_occurs_at(1, "a = 0").assert_msg_has(1, "Previous variable");
     });
     Tester::new_single_source_expect_err(
         "put inside arm",
         "primitive f() {
             channel<u32> a -> b;
             sync select { put(a) -> {} }
         }"
     ).error(|e| { e
         .assert_occurs_at(0, "put")
         .assert_msg_has(0, "may not occur");
     });
+}
 #[test]
 fn test_incorrect_goto_statement() {
     Tester::new_single_source_expect_err(
         "goto missing var in same scope",
         "func f() -> u32 {
             goto exit;
             auto v = 5;
             exit: return 0;
         }"
     ).error(|e| { e
         .assert_num(3)
         .assert_occurs_at(0, "exit;").assert_msg_has(0, "skips over a variable")
         .assert_occurs_at(1, "exit:").assert_msg_has(1, "jumps to this label")
         .assert_occurs_at(2, "v = 5").assert_msg_has(2, "skips over this variable");
     });
     Tester::new_single_source_expect_err(
         "goto missing var in outer scope",
         "func f() -> u32 {
             if (true) {
                 goto exit;
+            }
             auto v = 0;
             exit: return 1;
         }"
     ).error(|e| { e
         .assert_num(3)
         .assert_occurs_at(0, "exit;").assert_msg_has(0, "skips over a variable")
         .assert_occurs_at(1, "exit:").assert_msg_has(1, "jumps to this label")
         .assert_occurs_at(2, "v = 0").assert_msg_has(2, "skips over this variable");
     });
     Tester::new_single_source_expect_err(
         "goto jumping into scope",
         "func f() -> u32 {
             goto nested;
+            {
                 nested: return 0;
+            }
             return 1;
         }"
     ).error(|e| { e
         .assert_num(1)
         .assert_occurs_at(0, "nested;")
         .assert_msg_has(0, "could not find this label");
     });
     Tester::new_single_source_expect_err(
         "goto jumping outside sync",
         "primitive f() {
             sync { goto exit; }
             exit: u32 v = 0;
         }"
     ).error(|e| { e
         .assert_num(3)
         .assert_occurs_at(0, "goto exit;").assert_msg_has(0, "not escape the surrounding sync")
         .assert_occurs_at(1, "exit: u32 v").assert_msg_has(1, "target of the goto")
         .assert_occurs_at(2, "sync {").assert_msg_has(2, "jump past this");
     })
+}
 #[test]
 fn test_incorrect_while_statement() {
     // Just testing the error cases caught at compile-time. Other ones need
     // evaluation testing
     Tester::new_single_source_expect_err(
         "break wrong earlier loop",
         "func f() -> u32 {
             target: while (true) {}
             while (true) { break target; }
             return 0;
         }"
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "target; }").assert_msg_has(0, "not nested under the target")
         .assert_occurs_at(1, "target: while").assert_msg_has(1, "is found here");
     });
     Tester::new_single_source_expect_err(
         "break wrong later loop",
         "func f() -> u32 {
             while (true) { break target; }
             target: while (true) {}
             return 0;
         }"
     ).error(|e| { e
         .assert_num(2)
         .assert_occurs_at(0, "target; }").assert_msg_has(0, "not nested under the target")
         .assert_occurs_at(1, "target: while").assert_msg_has(1, "is found here");
     });
     Tester::new_single_source_expect_err(
         "break outside of sync",
         "primitive f() {
             outer: while (true) { //mark
                 sync while(true) { break outer; }
+            }
         }"
     ).error(|e| { e
         .assert_num(3)
         .assert_occurs_at(0, "break outer;").assert_msg_has(0, "may not escape the surrounding")
         .assert_occurs_at(1, "while (true) { //mark").assert_msg_has(1, "escapes out of this loop")
         .assert_occurs_at(2, "sync while").assert_msg_has(2, "escape this synchronous block");
     });
+}
@@ \ No newline at end of file @@

src/protocol/tests/utils.rs

➞

Show inline comments

@@ @@ -526,24 +526,25 @@ impl<'a> FunctionTester<'a> { @@
                         if var.identifier.value.as_str() == name {
                             return true;
+                        }
+                    }
+                }
                 false
+            }
         );
         let mut found_local_id = None;
         if let Some(block_id) = wrapping_block_id {
             // Found the right block, find the variable inside the block again
             let block_stmt = self.ctx.heap[block_id].as_block();
             for local_id in &block_stmt.locals {
                 let var = &self.ctx.heap[*local_id];
                 if var.identifier.value.as_str() == name {
                     found_local_id = Some(*local_id);
+                }
+            }
+        }
         assert!(
             found_local_id.is_some(), "[{}] Failed to find variable '{}' in {}",
             self.ctx.test_name, name, self.assert_postfix()
             None
         },
         Expression::Variable(_expr) => {
             None
+        }
+    }
+}
 fn seek_expr_in_stmt<F: Fn(&Expression) -> bool>(heap: &Heap, start: StatementId, f: &F) -> Option<ExpressionId> {
     let stmt = &heap[start];
     match stmt {
         Statement::Local(stmt) => {
             match stmt {
                 LocalStatement::Memory(stmt) => seek_expr_in_expr(heap, stmt.initial_expr.upcast(), f),
                 LocalStatement::Channel(_) => None
+            }
+        }
         Statement::Block(stmt) => {
             for stmt_id in &stmt.statements {
                 if let Some(id) = seek_expr_in_stmt(heap, *stmt_id, f) {
                     return Some(id)
+                }
+            }
             None
         },
         Statement::Labeled(stmt) => {
             seek_expr_in_stmt(heap, stmt.body, f)
         },
         Statement::If(stmt) => {

0 comments (0 inline, 0 general)