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

Changeset - ed4fe8216eb0

Parent rev.

Child rev.

[Not reviewed]

0 4 0

MH - 4 years ago 2021-05-27 16:48:06
contact@maxhenger.nl

Fix binding- and assignment-expression related typing issues.

Simpler solutions are better, so the typechecker is back to normal.
Instead we simply make sure that assignment expression is never
nested under another expression, and binding expressions may only
be nested under LogicalAnd-expressions. If only I knew why I thought
type shenanigans were a good idea in the first place...

4 files changed with 98 insertions and 39 deletions:

src/protocol/ast.rs

src/protocol/parser/pass_typing.rs

src/protocol/parser/pass_validation_linking.rs

src/protocol/tests/parser_binding.rs

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -1028,768 +1028,775 @@ impl Statement { @@
     pub fn as_if(&self) -> &IfStatement {
         match self {
             Statement::If(result) => result,
             _ => panic!("Unable to cast `Statement` to `IfStatement`"),
+        }
+    }
     pub fn as_if_mut(&mut self) -> &mut IfStatement {
         match self {
             Statement::If(result) => result,
             _ => panic!("Unable to cast 'Statement' to 'IfStatement'"),
+        }
+    }
     pub fn as_end_if(&self) -> &EndIfStatement {
         match self {
             Statement::EndIf(result) => result,
             _ => panic!("Unable to cast `Statement` to `EndIfStatement`"),
+        }
+    }
     pub fn is_while(&self) -> bool {
         match self {
             Statement::While(_) => true,
             _ => false,
+        }
+    }
     pub fn as_while(&self) -> &WhileStatement {
         match self {
             Statement::While(result) => result,
             _ => panic!("Unable to cast `Statement` to `WhileStatement`"),
+        }
+    }
     pub fn as_while_mut(&mut self) -> &mut WhileStatement {
         match self {
             Statement::While(result) => result,
             _ => panic!("Unable to cast `Statement` to `WhileStatement`"),
+        }
+    }
     pub fn as_end_while(&self) -> &EndWhileStatement {
         match self {
             Statement::EndWhile(result) => result,
             _ => panic!("Unable to cast `Statement` to `EndWhileStatement`"),
+        }
+    }
     pub fn as_break(&self) -> &BreakStatement {
         match self {
             Statement::Break(result) => result,
             _ => panic!("Unable to cast `Statement` to `BreakStatement`"),
+        }
+    }
     pub fn as_break_mut(&mut self) -> &mut BreakStatement {
         match self {
             Statement::Break(result) => result,
             _ => panic!("Unable to cast `Statement` to `BreakStatement`"),
+        }
+    }
     pub fn as_continue(&self) -> &ContinueStatement {
         match self {
             Statement::Continue(result) => result,
             _ => panic!("Unable to cast `Statement` to `ContinueStatement`"),
+        }
+    }
     pub fn as_continue_mut(&mut self) -> &mut ContinueStatement {
         match self {
             Statement::Continue(result) => result,
             _ => panic!("Unable to cast `Statement` to `ContinueStatement`"),
+        }
+    }
     pub fn as_synchronous(&self) -> &SynchronousStatement {
         match self {
             Statement::Synchronous(result) => result,
             _ => panic!("Unable to cast `Statement` to `SynchronousStatement`"),
+        }
+    }
     pub fn as_synchronous_mut(&mut self) -> &mut SynchronousStatement {
         match self {
             Statement::Synchronous(result) => result,
             _ => panic!("Unable to cast `Statement` to `SynchronousStatement`"),
+        }
+    }
     pub fn as_end_synchronous(&self) -> &EndSynchronousStatement {
         match self {
             Statement::EndSynchronous(result) => result,
             _ => panic!("Unable to cast `Statement` to `EndSynchronousStatement`"),
+        }
+    }
     pub fn as_return(&self) -> &ReturnStatement {
         match self {
             Statement::Return(result) => result,
             _ => panic!("Unable to cast `Statement` to `ReturnStatement`"),
+        }
+    }
     pub fn as_goto(&self) -> &GotoStatement {
         match self {
             Statement::Goto(result) => result,
             _ => panic!("Unable to cast `Statement` to `GotoStatement`"),
+        }
+    }
     pub fn as_goto_mut(&mut self) -> &mut GotoStatement {
         match self {
             Statement::Goto(result) => result,
             _ => panic!("Unable to cast `Statement` to `GotoStatement`"),
+        }
+    }
     pub fn as_new(&self) -> &NewStatement {
         match self {
             Statement::New(result) => result,
             _ => panic!("Unable to cast `Statement` to `NewStatement`"),
+        }
+    }
     pub fn as_expression(&self) -> &ExpressionStatement {
         match self {
             Statement::Expression(result) => result,
             _ => panic!("Unable to cast `Statement` to `ExpressionStatement`"),
+        }
+    }
     pub fn span(&self) -> InputSpan {
         match self {
             Statement::Block(v) => v.span,
             Statement::Local(v) => v.span(),
             Statement::Labeled(v) => v.label.span,
             Statement::If(v) => v.span,
             Statement::While(v) => v.span,
             Statement::Break(v) => v.span,
             Statement::Continue(v) => v.span,
             Statement::Synchronous(v) => v.span,
             Statement::Return(v) => v.span,
             Statement::Goto(v) => v.span,
             Statement::New(v) => v.span,
             Statement::Expression(v) => v.span,
             Statement::EndBlock(_) | Statement::EndIf(_) | Statement::EndWhile(_) | Statement::EndSynchronous(_) => unreachable!(),
+        }
+    }
     pub fn link_next(&mut self, next: StatementId) {
         match self {
             Statement::Block(_) => todo!(),
             Statement::EndBlock(stmt) => stmt.next = next,
             Statement::Local(stmt) => match stmt {
                 LocalStatement::Channel(stmt) => stmt.next = next,
                 LocalStatement::Memory(stmt) => stmt.next = next,
             },
             Statement::EndIf(stmt) => stmt.next = next,
             Statement::EndWhile(stmt) => stmt.next = next,
             Statement::EndSynchronous(stmt) => stmt.next = next,
             Statement::New(stmt) => stmt.next = next,
             Statement::Expression(stmt) => stmt.next = next,
             Statement::Return(_)
             | Statement::Break(_)
             | Statement::Continue(_)
             | Statement::Synchronous(_)
             | Statement::Goto(_)
             | Statement::While(_)
             | Statement::Labeled(_)
             | Statement::If(_) => unreachable!(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct BlockStatement {
     pub this: BlockStatementId,
     // Phase 1: parser
     pub is_implicit: bool,
     pub span: InputSpan, // of the complete block
     pub statements: Vec<StatementId>,
     pub end_block: EndBlockStatementId,
     // Phase 2: linker
     pub scope_node: ScopeNode,
     pub first_unique_id_in_scope: i32, // Temporary fix until proper bytecode/asm is generated
     pub next_unique_id_in_scope: i32, // Temporary fix until proper bytecode/asm is generated
     pub relative_pos_in_parent: u32,
     pub locals: Vec<VariableId>,
     pub labels: Vec<LabeledStatementId>,
+}
 #[derive(Debug, Clone)]
 pub struct EndBlockStatement {
     pub this: EndBlockStatementId,
     // Parser
     pub start_block: BlockStatementId,
     // Validation/Linking
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub enum LocalStatement {
     Memory(MemoryStatement),
     Channel(ChannelStatement),
+}
 impl LocalStatement {
     pub fn this(&self) -> LocalStatementId {
         match self {
             LocalStatement::Memory(stmt) => stmt.this.upcast(),
             LocalStatement::Channel(stmt) => stmt.this.upcast(),
+        }
+    }
     pub fn as_memory(&self) -> &MemoryStatement {
         match self {
             LocalStatement::Memory(result) => result,
             _ => panic!("Unable to cast `LocalStatement` to `MemoryStatement`"),
+        }
+    }
     pub fn as_channel(&self) -> &ChannelStatement {
         match self {
             LocalStatement::Channel(result) => result,
             _ => panic!("Unable to cast `LocalStatement` to `ChannelStatement`"),
+        }
+    }
     pub fn span(&self) -> InputSpan {
         match self {
             LocalStatement::Channel(v) => v.span,
             LocalStatement::Memory(v) => v.span,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct MemoryStatement {
     pub this: MemoryStatementId,
     // Phase 1: parser
     pub span: InputSpan,
     pub variable: VariableId,
     // Phase 2: linker
     pub next: StatementId,
+}
 /// ChannelStatement is the declaration of an input and output port associated
 /// with the same channel. Note that the polarity of the ports are from the
 /// point of view of the component. So an output port is something that a
 /// component uses to send data over (i.e. it is the "input end" of the
 /// channel), and vice versa.
 #[derive(Debug, Clone)]
 pub struct ChannelStatement {
     pub this: ChannelStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "channel" keyword
     pub from: VariableId, // output
     pub to: VariableId,   // input
     // Phase 2: linker
     pub relative_pos_in_block: u32,
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct LabeledStatement {
     pub this: LabeledStatementId,
     // Phase 1: parser
     pub label: Identifier,
     pub body: StatementId,
     // Phase 2: linker
     pub relative_pos_in_block: u32,
     pub in_sync: SynchronousStatementId, // may be invalid
+}
 #[derive(Debug, Clone)]
 pub struct IfStatement {
     pub this: IfStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "if" keyword
     pub test: ExpressionId,
     pub true_body: BlockStatementId,
     pub false_body: Option<BlockStatementId>,
     pub end_if: EndIfStatementId,
+}
 #[derive(Debug, Clone)]
 pub struct EndIfStatement {
     pub this: EndIfStatementId,
     pub start_if: IfStatementId,
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct WhileStatement {
     pub this: WhileStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "while" keyword
     pub test: ExpressionId,
     pub body: BlockStatementId,
     pub end_while: EndWhileStatementId,
     pub in_sync: SynchronousStatementId, // may be invalid
+}
 #[derive(Debug, Clone)]
 pub struct EndWhileStatement {
     pub this: EndWhileStatementId,
     pub start_while: WhileStatementId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct BreakStatement {
     pub this: BreakStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "break" keyword
     pub label: Option<Identifier>,
     // Phase 2: linker
     pub target: Option<EndWhileStatementId>,
+}
 #[derive(Debug, Clone)]
 pub struct ContinueStatement {
     pub this: ContinueStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "continue" keyword
     pub label: Option<Identifier>,
     // Phase 2: linker
     pub target: Option<WhileStatementId>,
+}
 #[derive(Debug, Clone)]
 pub struct SynchronousStatement {
     pub this: SynchronousStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "sync" keyword
     pub body: BlockStatementId,
     // Phase 2: linker
     pub end_sync: EndSynchronousStatementId,
+}
 #[derive(Debug, Clone)]
 pub struct EndSynchronousStatement {
     pub this: EndSynchronousStatementId,
     pub start_sync: SynchronousStatementId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct ReturnStatement {
     pub this: ReturnStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "return" keyword
     pub expressions: Vec<ExpressionId>,
+}
 #[derive(Debug, Clone)]
 pub struct GotoStatement {
     pub this: GotoStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "goto" keyword
     pub label: Identifier,
     // Phase 2: linker
     pub target: Option<LabeledStatementId>,
+}
 #[derive(Debug, Clone)]
 pub struct NewStatement {
     pub this: NewStatementId,
     // Phase 1: parser
     pub span: InputSpan, // of the "new" keyword
     pub expression: CallExpressionId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, Clone)]
 pub struct ExpressionStatement {
     pub this: ExpressionStatementId,
     // Phase 1: parser
     pub span: InputSpan,
     pub expression: ExpressionId,
     // Phase 2: linker
     pub next: StatementId,
+}
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum ExpressionParent {
     None, // only set during initial parsing
     If(IfStatementId),
     While(WhileStatementId),
     Return(ReturnStatementId),
     New(NewStatementId),
     ExpressionStmt(ExpressionStatementId),
     Expression(ExpressionId, u32) // index within expression (e.g LHS or RHS of expression)
+}
 impl ExpressionParent {
     pub fn is_new(&self) -> bool {
         match self {
             ExpressionParent::New(_) => true,
             _ => false,
+        }
+    }
     pub fn as_expression(&self) -> ExpressionId {
         match self {
             ExpressionParent::Expression(id, _) => *id,
             _ => panic!("called as_expression() on {:?}", self),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub enum Expression {
     Assignment(AssignmentExpression),
     Binding(BindingExpression),
     Conditional(ConditionalExpression),
     Binary(BinaryExpression),
     Unary(UnaryExpression),
     Indexing(IndexingExpression),
     Slicing(SlicingExpression),
     Select(SelectExpression),
     Literal(LiteralExpression),
     Cast(CastExpression),
     Call(CallExpression),
     Variable(VariableExpression),
+}
 impl Expression {
     pub fn as_assignment(&self) -> &AssignmentExpression {
         match self {
             Expression::Assignment(result) => result,
             _ => panic!("Unable to cast `Expression` to `AssignmentExpression`"),
+        }
+    }
     pub fn as_conditional(&self) -> &ConditionalExpression {
         match self {
             Expression::Conditional(result) => result,
             _ => panic!("Unable to cast `Expression` to `ConditionalExpression`"),
+        }
+    }
     pub fn as_binary(&self) -> &BinaryExpression {
         match self {
             Expression::Binary(result) => result,
             _ => panic!("Unable to cast `Expression` to `BinaryExpression`"),
+        }
+    }
     pub fn as_unary(&self) -> &UnaryExpression {
         match self {
             Expression::Unary(result) => result,
             _ => panic!("Unable to cast `Expression` to `UnaryExpression`"),
+        }
+    }
     pub fn as_indexing(&self) -> &IndexingExpression {
         match self {
             Expression::Indexing(result) => result,
             _ => panic!("Unable to cast `Expression` to `IndexingExpression`"),
+        }
+    }
     pub fn as_slicing(&self) -> &SlicingExpression {
         match self {
             Expression::Slicing(result) => result,
             _ => panic!("Unable to cast `Expression` to `SlicingExpression`"),
+        }
+    }
     pub fn as_select(&self) -> &SelectExpression {
         match self {
             Expression::Select(result) => result,
             _ => panic!("Unable to cast `Expression` to `SelectExpression`"),
+        }
+    }
     pub fn as_call(&self) -> &CallExpression {
         match self {
             Expression::Call(result) => result,
             _ => panic!("Unable to cast `Expression` to `CallExpression`"),
+        }
+    }
     pub fn as_call_mut(&mut self) -> &mut CallExpression {
         match self {
             Expression::Call(result) => result,
             _ => panic!("Unable to cast `Expression` to `CallExpression`"),
+        }
+    }
     pub fn as_variable(&self) -> &VariableExpression {
         match self {
             Expression::Variable(result) => result,
             _ => panic!("Unable to cast `Expression` to `VariableExpression`"),
+        }
+    }
     pub fn as_variable_mut(&mut self) -> &mut VariableExpression {
         match self {
             Expression::Variable(result) => result,
             _ => panic!("Unable to cast `Expression` to `VariableExpression`"),
+        }
+    }
     pub fn span(&self) -> InputSpan {
         match self {
             Expression::Assignment(expr) => expr.span,
             Expression::Binding(expr) => expr.span,
             Expression::Conditional(expr) => expr.span,
             Expression::Binary(expr) => expr.span,
             Expression::Unary(expr) => expr.span,
             Expression::Indexing(expr) => expr.span,
             Expression::Slicing(expr) => expr.span,
             Expression::Select(expr) => expr.span,
             Expression::Literal(expr) => expr.span,
             Expression::Cast(expr) => expr.span,
             Expression::Call(expr) => expr.span,
             Expression::Variable(expr) => expr.identifier.span,
+        }
+    }
     // TODO: @cleanup
     pub fn parent(&self) -> &ExpressionParent {
         match self {
             Expression::Assignment(expr) => &expr.parent,
             Expression::Binding(expr) => &expr.parent,
             Expression::Conditional(expr) => &expr.parent,
             Expression::Binary(expr) => &expr.parent,
             Expression::Unary(expr) => &expr.parent,
             Expression::Indexing(expr) => &expr.parent,
             Expression::Slicing(expr) => &expr.parent,
             Expression::Select(expr) => &expr.parent,
             Expression::Literal(expr) => &expr.parent,
             Expression::Cast(expr) => &expr.parent,
             Expression::Call(expr) => &expr.parent,
             Expression::Variable(expr) => &expr.parent,
+        }
+    }
     // TODO: @cleanup
     pub fn parent_expr_id(&self) -> Option<ExpressionId> {
         if let ExpressionParent::Expression(id, _) = self.parent() {
             Some(*id)
         } else {
             None
+        }
+    }
     // TODO: @cleanup
     pub fn set_parent(&mut self, parent: ExpressionParent) {
         match self {
             Expression::Assignment(expr) => expr.parent = parent,
             Expression::Binding(expr) => expr.parent = parent,
             Expression::Conditional(expr) => expr.parent = parent,
             Expression::Binary(expr) => expr.parent = parent,
             Expression::Unary(expr) => expr.parent = parent,
             Expression::Indexing(expr) => expr.parent = parent,
             Expression::Slicing(expr) => expr.parent = parent,
             Expression::Select(expr) => expr.parent = parent,
             Expression::Literal(expr) => expr.parent = parent,
             Expression::Cast(expr) => expr.parent = parent,
             Expression::Call(expr) => expr.parent = parent,
             Expression::Variable(expr) => expr.parent = parent,
+        }
+    }
     pub fn get_unique_id_in_definition(&self) -> i32 {
         match self {
             Expression::Assignment(expr) => expr.unique_id_in_definition,
             Expression::Binding(expr) => expr.unique_id_in_definition,
             Expression::Conditional(expr) => expr.unique_id_in_definition,
             Expression::Binary(expr) => expr.unique_id_in_definition,
             Expression::Unary(expr) => expr.unique_id_in_definition,
             Expression::Indexing(expr) => expr.unique_id_in_definition,
             Expression::Slicing(expr) => expr.unique_id_in_definition,
             Expression::Select(expr) => expr.unique_id_in_definition,
             Expression::Literal(expr) => expr.unique_id_in_definition,
             Expression::Cast(expr) => expr.unique_id_in_definition,
             Expression::Call(expr) => expr.unique_id_in_definition,
             Expression::Variable(expr) => expr.unique_id_in_definition,
+        }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum AssignmentOperator {
     Set,
     Multiplied,
     Divided,
     Remained,
     Added,
     Subtracted,
     ShiftedLeft,
     ShiftedRight,
     BitwiseAnded,
     BitwiseXored,
     BitwiseOred,
+}
 #[derive(Debug, Clone)]
 pub struct AssignmentExpression {
     pub this: AssignmentExpressionId,
     // Parsing
     pub span: InputSpan, // of the operator
     pub left: ExpressionId,
     pub operation: AssignmentOperator,
     pub right: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct BindingExpression {
     pub this: BindingExpressionId,
     // Parsing
     pub span: InputSpan, // of the binding keyword
     pub bound_to: ExpressionId,
     pub bound_from: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct ConditionalExpression {
     pub this: ConditionalExpressionId,
     // Parsing
     pub span: InputSpan, // of question mark operator
     pub test: ExpressionId,
     pub true_expression: ExpressionId,
     pub false_expression: ExpressionId,
     // Validator/Linking
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum BinaryOperator {
     Concatenate,
     LogicalOr,
     LogicalAnd,
     BitwiseOr,
     BitwiseXor,
     BitwiseAnd,
     Equality,
     Inequality,
     LessThan,
     GreaterThan,
     LessThanEqual,
     GreaterThanEqual,
     ShiftLeft,
     ShiftRight,
     Add,
     Subtract,
     Multiply,
     Divide,
     Remainder,
+}
 #[derive(Debug, Clone)]
 pub struct BinaryExpression {
     pub this: BinaryExpressionId,
     // Parsing
     pub span: InputSpan, // of the operator
     pub left: ExpressionId,
     pub operation: BinaryOperator,
     pub right: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum UnaryOperator {
     Positive,
     Negative,
     BitwiseNot,
     LogicalNot,
+}
 #[derive(Debug, Clone)]
 pub struct UnaryExpression {
     pub this: UnaryExpressionId,
     // Parsing
     pub span: InputSpan, // of the operator
     pub operation: UnaryOperator,
     pub expression: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct IndexingExpression {
     pub this: IndexingExpressionId,
     // Parsing
     pub span: InputSpan,
     pub subject: ExpressionId,
     pub index: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct SlicingExpression {
     pub this: SlicingExpressionId,
     // Parsing
     pub span: InputSpan, // from '[' to ']';
     pub subject: ExpressionId,
     pub from_index: ExpressionId,
     pub to_index: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct SelectExpression {
     pub this: SelectExpressionId,
     // Parsing
     pub span: InputSpan, // of the '.'
     pub subject: ExpressionId,
     pub field_name: Identifier,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct CastExpression {
     pub this: CastExpressionId,
     // Parsing
     pub span: InputSpan, // of the "cast" keyword,
     pub to_type: ParserType,
     pub subject: ExpressionId,
     // Validator/linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub struct CallExpression {
     pub this: CallExpressionId,
     // Parsing
     pub span: InputSpan,
     pub parser_type: ParserType, // of the function call, not the return type
     pub method: Method,
     pub arguments: Vec<ExpressionId>,
     pub definition: DefinitionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Method {
     // Builtin
     Get,
     Put,
     Fires,
     Create,
     Length,
     Assert,
     UserFunction,
     UserComponent,
+}
 #[derive(Debug, Clone)]
 pub struct MethodSymbolic {
     pub(crate) parser_type: ParserType,
     pub(crate) definition: DefinitionId
+}
 #[derive(Debug, Clone)]
 pub struct LiteralExpression {
     pub this: LiteralExpressionId,
     // Parsing
     pub span: InputSpan,
     pub value: Literal,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone)]
 pub enum Literal {
     Null, // message
     True,
     False,
     Character(char),
     String(StringRef<'static>),
     Integer(LiteralInteger),
     Struct(LiteralStruct),
     Enum(LiteralEnum),
     Union(LiteralUnion),
     Array(Vec<ExpressionId>),
+}
 impl Literal {
     pub(crate) fn as_struct(&self) -> &LiteralStruct {
         if let Literal::Struct(literal) = self{
             literal
         } else {
             unreachable!("Attempted to obtain {:?} as Literal::Struct", self)

src/protocol/parser/pass_typing.rs

➞

Show inline comments

 /// pass_typing
 ///
 /// Performs type inference and type checking. Type inference is implemented by
 /// applying constraints on (sub)trees of types. During this process the
 /// resolver takes the `ParserType` structs (the representation of the types
 /// written by the programmer), converts them to `InferenceType` structs (the
 /// temporary data structure used during type inference) and attempts to arrive
 /// at `ConcreteType` structs (the representation of a fully checked and
 /// validated type).
 ///
 /// The resolver will visit every statement and expression relevant to the
 /// procedure and insert and determine its initial type based on context (e.g. a
 /// return statement's expression must match the function's return type, an
 /// if statement's test expression must evaluate to a boolean). When all are
 /// visited we attempt to make progress in evaluating the types. Whenever a type
 /// is progressed we queue the related expressions for further type progression.
 /// Once no more expressions are in the queue the algorithm is finished. At this
 /// point either all types are inferred (or can be trivially implicitly
 /// determined), or we have incomplete types. In the latter case we return an
 /// error.
 ///
 /// TODO: Needs a thorough rewrite:
 ///  0. polymorph_progress is intentionally broken at the moment. Make it work
 ///     again and use a normal VecSomething.
 ///  1. The foundation for doing all of the work with predetermined indices
 ///     instead of with HashMaps is there, but it is not really used because of
 ///     time constraints. When time is available, rewrite the system such that
 ///     AST IDs are not needed, and only indices into arrays are used.
 ///  2. We're doing a lot of extra work. It seems better to apply the initial
 ///     type based on expression parents, and immediately apply forced
 ///     constraints (arg to a fires() call must be port-like). All of the \
 ///     progress_xxx calls should then only be concerned with "transmitting"
 ///     type inference across their parent/child expressions.
 ///  3. Remove the `msg` type?
 ///  4. Disallow certain types in certain operations (e.g. `Void`).
 macro_rules! debug_log_enabled {
     () => { false };
+}
 macro_rules! debug_log {
     ($format:literal) => {
         enabled_debug_print!(false, "types", $format);
     };
     ($format:literal, $($args:expr),*) => {
         enabled_debug_print!(false, "types", $format, $($args),*);
     };
+}
 use std::collections::{HashMap, HashSet};
 use crate::collections::DequeSet;
 use crate::protocol::ast::*;
 use crate::protocol::input_source::ParseError;
 use crate::protocol::parser::ModuleCompilationPhase;
 use crate::protocol::parser::type_table::*;
 use crate::protocol::parser::token_parsing::*;
 use super::visitor::{
     STMT_BUFFER_INIT_CAPACITY,
     EXPR_BUFFER_INIT_CAPACITY,
     Ctx,
     Visitor2,
     VisitorResult
 };
 const VOID_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Void ];
 const MESSAGE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Message, InferenceTypePart::UInt8 ];
 const BOOL_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Bool ];
 const BOOLLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::BoolLike ];
 const BINDING_BOOL_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::BindingBool ];
 const CHARACTER_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::Character ];
 const STRING_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::String ];
 const NUMBERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::NumberLike ];
 const INTEGERLIKE_TEMPLATE: [InferenceTypePart; 1] = [ InferenceTypePart::IntegerLike ];
 const ARRAY_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Array, InferenceTypePart::Unknown ];
 const SLICE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::Slice, InferenceTypePart::Unknown ];
 const ARRAYLIKE_TEMPLATE: [InferenceTypePart; 2] = [ InferenceTypePart::ArrayLike, InferenceTypePart::Unknown ];
 /// TODO: @performance Turn into PartialOrd+Ord to simplify checks
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub(crate) enum InferenceTypePart {
     // When we infer types of AST elements that support polymorphic arguments,
     // then we might have the case that multiple embedded types depend on the
     // polymorphic type (e.g. func bla(T a, T[] b) -> T[][]). If we can infer
     // the type in one place (e.g. argument a), then we may propagate this
     // information to other types (e.g. argument b and the return type). For
     // this reason we place markers in the `InferenceType` instances such that
     // we know which part of the type was originally a polymorphic argument.
     Marker(u32),
     // Completely unknown type, needs to be inferred
     Unknown,
     // Partially known type, may be inferred to to be the appropriate related
     // type.
     // IndexLike,      // index into array/slice
     BoolLike,       // boolean or binding boolean
     NumberLike,     // any kind of integer/float
     IntegerLike,    // any kind of integer
     ArrayLike,      // array or slice. Note that this must have a subtype
     PortLike,       // input or output port
     // Special types that cannot be instantiated by the user
     Void, // For builtin functions that do not return anything
     // Concrete types without subtypes
     BindingBool,    // boolean result from a binding expression
     Bool,
     UInt8,
     UInt16,
     UInt32,
     UInt64,
     SInt8,
     SInt16,
     SInt32,
     SInt64,
     Character,
     String,
     // One subtype
     Message,
     Array,
     Slice,
     Input,
     Output,
     // A user-defined type with any number of subtypes
     Instance(DefinitionId, u32)
+}
 impl InferenceTypePart {
     fn is_marker(&self) -> bool {
         match self {
             InferenceTypePart::Marker(_) => true,
             _ => false,
+        }
+    }
     /// Checks if the type is concrete, markers are interpreted as concrete
     /// types.
     fn is_concrete(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
-            ITP::Unknown | ITP::BoolLike | ITP::NumberLike |
             ITP::Unknown | ITP::NumberLike |
             ITP::IntegerLike | ITP::ArrayLike | ITP::PortLike => false,
             _ => true
+        }
+    }
     fn is_concrete_number(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::UInt8 | ITP::UInt16 | ITP::UInt32 | ITP::UInt64 |
             ITP::SInt8 | ITP::SInt16 | ITP::SInt32 | ITP::SInt64 => true,
             _ => false,
+        }
+    }
     fn is_concrete_integer(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::UInt8 | ITP::UInt16 | ITP::UInt32 | ITP::UInt64 |
             ITP::SInt8 | ITP::SInt16 | ITP::SInt32 | ITP::SInt64 => true,
             _ => false,
+        }
+    }
     fn is_concrete_msg_array_or_slice(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::Array | ITP::Slice | ITP::Message => true,
             _ => false,
+        }
+    }
     fn is_concrete_port(&self) -> bool {
         use InferenceTypePart as ITP;
         match self {
             ITP::Input | ITP::Output => true,
             _ => false,
+        }
+    }
     /// Checks if a part is less specific than the argument. Only checks for
     /// single-part inference (i.e. not the replacement of an `Unknown` variant
     /// with the argument)
     fn may_be_inferred_from(&self, arg: &InferenceTypePart) -> bool {
         use InferenceTypePart as ITP;
         (*self == ITP::IntegerLike && arg.is_concrete_integer()) ||
         (*self == ITP::NumberLike && (arg.is_concrete_number() || *arg == ITP::IntegerLike)) ||
         (*self == ITP::ArrayLike && arg.is_concrete_msg_array_or_slice()) ||
         (*self == ITP::PortLike && arg.is_concrete_port()) ||
         (*self == ITP::BoolLike && (*arg == ITP::Bool || *arg == ITP::BindingBool)) ||
         (*self == ITP::Bool && *arg == ITP::BindingBool)
         (*self == ITP::PortLike && arg.is_concrete_port())
+    }
     /// Checks if a part is more specific
     /// Returns the change in "iteration depth" when traversing this particular
     /// part. The iteration depth is used to traverse the tree in a linear
     /// fashion. It is basically `number_of_subtypes - 1`
     fn depth_change(&self) -> i32 {
         use InferenceTypePart as ITP;
         match &self {
             ITP::Unknown | ITP::NumberLike | ITP::IntegerLike |
-            ITP::Void | ITP::BoolLike | ITP::Bool | ITP::BindingBool |
             ITP::Void | ITP::Bool |
             ITP::UInt8 | ITP::UInt16 | ITP::UInt32 | ITP::UInt64 |
             ITP::SInt8 | ITP::SInt16 | ITP::SInt32 | ITP::SInt64 |
             ITP::Character | ITP::String => {
                 -1
             },
             ITP::Marker(_) |
             ITP::ArrayLike | ITP::Message | ITP::Array | ITP::Slice |
             ITP::PortLike | ITP::Input | ITP::Output => {
                 // One subtype, so do not modify depth
             },
             ITP::Instance(_, num_args) => {
                 (*num_args as i32) - 1
+            }
+        }
+    }
+}
 impl From<ConcreteTypePart> for InferenceTypePart {
     fn from(v: ConcreteTypePart) -> InferenceTypePart {
         use ConcreteTypePart as CTP;
         use InferenceTypePart as ITP;
         match v {
             CTP::Void => ITP::Void,
             CTP::Message => ITP::Message,
             CTP::Bool => ITP::Bool,
             CTP::UInt8 => ITP::UInt8,
             CTP::UInt16 => ITP::UInt16,
             CTP::UInt32 => ITP::UInt32,
             CTP::UInt64 => ITP::UInt64,
             CTP::SInt8 => ITP::SInt8,
             CTP::SInt16 => ITP::SInt16,
             CTP::SInt32 => ITP::SInt32,
             CTP::SInt64 => ITP::SInt64,
             CTP::Character => ITP::Character,
             CTP::String => ITP::String,
             CTP::Array => ITP::Array,
             CTP::Slice => ITP::Slice,
             CTP::Input => ITP::Input,
             CTP::Output => ITP::Output,
             CTP::Instance(id, num) => ITP::Instance(id, num),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 struct InferenceType {
     has_marker: bool,
     is_done: bool,
     parts: Vec<InferenceTypePart>,
+}
 impl InferenceType {
     /// Generates a new InferenceType. The two boolean flags will be checked in
     /// debug mode.
     fn new(has_marker: bool, is_done: bool, parts: Vec<InferenceTypePart>) -> Self {
         if cfg!(debug_assertions) {
             debug_assert!(!parts.is_empty());
             let parts_body_marker = parts.iter().any(|v| v.is_marker());
             debug_assert_eq!(has_marker, parts_body_marker);
             let parts_done = parts.iter().all(|v| v.is_concrete());
             debug_assert_eq!(is_done, parts_done, "{:?}", parts);
+        }
         Self{ has_marker, is_done, parts }
+    }
     /// Replaces a type subtree with the provided subtree. The caller must make
     /// sure the the replacement is a well formed type subtree.
     fn replace_subtree(&mut self, start_idx: usize, with: &[InferenceTypePart]) {
         let end_idx = Self::find_subtree_end_idx(&self.parts, start_idx);
         debug_assert_eq!(with.len(), Self::find_subtree_end_idx(with, 0));
         self.parts.splice(start_idx..end_idx, with.iter().cloned());
         self.recompute_is_done();
+    }
     // TODO: @performance, might all be done inline in the type inference methods
     fn recompute_is_done(&mut self) {
         self.is_done = self.parts.iter().all(|v| v.is_concrete());
+    }
     /// Seeks a body marker starting at the specified position. If a marker is
     /// found then its value and the index of the type subtree that follows it
     /// is returned.
     fn find_marker(&self, mut start_idx: usize) -> Option<(u32, usize)> {
         while start_idx < self.parts.len() {
             if let InferenceTypePart::Marker(marker) = &self.parts[start_idx] {
                 return Some((*marker, start_idx + 1))
+            }
             start_idx += 1;
+        }
         None
+    }
     /// Returns an iterator over all body markers and the partial type tree that
     /// follows those markers. If it is a problem that `InferenceType` is
     /// borrowed by the iterator, then use `find_body_marker`.
     fn marker_iter(&self) -> InferenceTypeMarkerIter {
         InferenceTypeMarkerIter::new(&self.parts)
+    }
     /// Given that the `parts` are a depth-first serialized tree of types, this
     /// function finds the subtree anchored at a specific node. The returned
     /// index is exclusive.
     fn find_subtree_end_idx(parts: &[InferenceTypePart], start_idx: usize) -> usize {
         let mut depth = 1;
         let mut idx = start_idx;
         while idx < parts.len() {
             depth += parts[idx].depth_change();
             if depth == 0 {
                 return idx + 1;
+            }
             idx += 1;
+        }
         // If here, then the inference type is malformed
         unreachable!();
+    }
     /// Call that attempts to infer the part at `to_infer.parts[to_infer_idx]`
     /// using the subtree at `template.parts[template_idx]`. Will return
     /// `Some(depth_change_due_to_traversal)` if type inference has been
     /// applied. In this case the indices will also be modified to point to the
     /// next part in both templates. If type inference has not (or: could not)
     /// be applied then `None` will be returned. Note that this might mean that
     /// the types are incompatible.
     ///
     /// As this is a helper functions, some assumptions: the parts are not
     /// exactly equal, and neither of them contains a marker. Also: only the
     /// `to_infer` parts are checked for inference. It might be that this
     /// function returns `None`, but that that `template` is still compatible
     /// with `to_infer`, e.g. when `template` has an `Unknown` part.
     fn infer_part_for_single_type(
         to_infer: &mut InferenceType, to_infer_idx: &mut usize,
         template_parts: &[InferenceTypePart], template_idx: &mut usize,
     ) -> Option<i32> {
         use InferenceTypePart as ITP;
         let to_infer_part = &to_infer.parts[*to_infer_idx];
         let template_part = &template_parts[*template_idx];
         // Check for programmer mistakes
         debug_assert_ne!(to_infer_part, template_part);
         debug_assert!(!to_infer_part.is_marker(), "marker encountered in 'infer part'");
         debug_assert!(!template_part.is_marker(), "marker encountered in 'template part'");
         // Inference of a somewhat-specified type
         if to_infer_part.may_be_inferred_from(template_part) {
             let depth_change = to_infer_part.depth_change();
             debug_assert_eq!(depth_change, template_part.depth_change());
             to_infer.parts[*to_infer_idx] = template_part.clone();
             *to_infer_idx += 1;
             *template_idx += 1;
             return Some(depth_change);
+        }
         // Inference of a completely unknown type
         if *to_infer_part == ITP::Unknown {
             // template part is different, so cannot be unknown, hence copy the
             // entire subtree. Make sure not to copy markers.
             let template_end_idx = Self::find_subtree_end_idx(template_parts, *template_idx);
             to_infer.parts[*to_infer_idx] = template_parts[*template_idx].clone(); // first element
             *to_infer_idx += 1;
             for template_idx in *template_idx + 1..template_end_idx {
                 let template_part = &template_parts[template_idx];
                 if !template_part.is_marker() {
                     to_infer.parts.insert(*to_infer_idx, template_part.clone());
                     *to_infer_idx += 1;
+                }
+            }
             *template_idx = template_end_idx;
             // Note: by definition the LHS was Unknown and the RHS traversed a
             // full subtree.
             return Some(-1);
+        }
         None
+    }
     /// Call that checks if the `to_check` part is compatible with the `infer`
     /// part. This is essentially a copy of `infer_part_for_single_type`, but
     /// without actually copying the type parts.
     fn check_part_for_single_type(
         to_check_parts: &[InferenceTypePart], to_check_idx: &mut usize,
         template_parts: &[InferenceTypePart], template_idx: &mut usize
     ) -> Option<i32> {
         use InferenceTypePart as ITP;
         let to_check_part = &to_check_parts[*to_check_idx];
         let template_part = &template_parts[*template_idx];
         // Checking programmer errors
         debug_assert_ne!(to_check_part, template_part);
         debug_assert!(!to_check_part.is_marker(), "marker encountered in 'to_check part'");
         debug_assert!(!template_part.is_marker(), "marker encountered in 'template part'");
         if to_check_part.may_be_inferred_from(template_part) {
             let depth_change = to_check_part.depth_change();
             debug_assert_eq!(depth_change, template_part.depth_change());
             *to_check_idx += 1;
             *template_idx += 1;
             return Some(depth_change);
+        }
         if *to_check_part == ITP::Unknown {
             *to_check_idx += 1;
             *template_idx = Self::find_subtree_end_idx(template_parts, *template_idx);
             // By definition LHS and RHS had depth change of -1
             return Some(-1);
+        }
         None
+    }
     /// Attempts to infer types between two `InferenceType` instances. This
     /// function is unsafe as it accepts pointers to work around Rust's
     /// borrowing rules. The caller must ensure that the pointers are distinct.
     unsafe fn infer_subtrees_for_both_types(
         type_a: *mut InferenceType, start_idx_a: usize,
         type_b: *mut InferenceType, start_idx_b: usize
     ) -> DualInferenceResult {
         debug_assert!(!std::ptr::eq(type_a, type_b), "encountered pointers to the same inference type");
         let type_a = &mut *type_a;
         let type_b = &mut *type_b;
         let mut modified_a = false;
         let mut modified_b = false;
         let mut idx_a = start_idx_a;
         let mut idx_b = start_idx_b;
         let mut depth = 1;
         while depth > 0 {
             // Advance indices if we encounter markers or equal parts
             let part_a = &type_a.parts[idx_a];
             let part_b = &type_b.parts[idx_b];
             if part_a == part_b {
                 let depth_change = part_a.depth_change();
                 depth += depth_change;
                 debug_assert_eq!(depth_change, part_b.depth_change());
                 idx_a += 1;
                 idx_b += 1;
                 continue;
+            }
             if part_a.is_marker() { idx_a += 1; continue; }
             if part_b.is_marker() { idx_b += 1; continue; }
             // Types are not equal and are both not markers
             if let Some(depth_change) = Self::infer_part_for_single_type(type_a, &mut idx_a, &type_b.parts, &mut idx_b) {
                 depth += depth_change;
                 modified_a = true;
                 continue;
+            }
             if let Some(depth_change) = Self::infer_part_for_single_type(type_b, &mut idx_b, &type_a.parts, &mut idx_a) {
                 depth += depth_change;
                 modified_b = true;
                 continue;
+            }
             // Types can not be inferred in any way: types must be incompatible
             return DualInferenceResult::Incompatible;
+        }
         if modified_a { type_a.recompute_is_done(); }
         if modified_b { type_b.recompute_is_done(); }
         // If here then we completely inferred the subtrees.
         match (modified_a, modified_b) {
             (false, false) => DualInferenceResult::Neither,
             (false, true) => DualInferenceResult::Second,
             (true, false) => DualInferenceResult::First,
             (true, true) => DualInferenceResult::Both
+        }
+    }
     /// Attempts to infer the first subtree based on the template. Like
     /// `infer_subtrees_for_both_types`, but now only applying inference to
     /// `to_infer` based on the type information in `template`.
     ///
     /// The `forced_template` flag controls whether `to_infer` is considered
     /// valid if it is more specific then the template. When `forced_template`
     /// is false, then as long as the `to_infer` and `template` types are
     /// compatible the inference will succeed. If `forced_template` is true,
     /// then `to_infer` MUST be less specific than `template` (e.g.
     /// `IntegerLike` is less specific than `UInt32`. Likewise `Bool` is less
     /// specific than `BindingBool`)
     /// `IntegerLike` is less specific than `UInt32`)
     fn infer_subtree_for_single_type(
         to_infer: &mut InferenceType, mut to_infer_idx: usize,
         template: &[InferenceTypePart], mut template_idx: usize,
         forced_template: bool,
     ) -> SingleInferenceResult {
         let mut modified = false;
         let mut depth = 1;
         while depth > 0 {
             let to_infer_part = &to_infer.parts[to_infer_idx];
             let template_part = &template[template_idx];
             if to_infer_part == template_part {
                 let depth_change = to_infer_part.depth_change();
                 depth += depth_change;
                 debug_assert_eq!(depth_change, template_part.depth_change());
                 to_infer_idx += 1;
                 template_idx += 1;
                 continue;
+            }
             if to_infer_part.is_marker() { to_infer_idx += 1; continue; }
             if template_part.is_marker() { template_idx += 1; continue; }
             // Types are not equal and not markers. So check if we can infer
             // anything
             if let Some(depth_change) = Self::infer_part_for_single_type(
                 to_infer, &mut to_infer_idx, template, &mut template_idx
             ) {
                 depth += depth_change;
                 modified = true;
                 continue;
+            }
             if !forced_template {
                 // We cannot infer anything, but the template may still be
                 // compatible with the type we're inferring
                 if let Some(depth_change) = Self::check_part_for_single_type(
                     template, &mut template_idx, &to_infer.parts, &mut to_infer_idx
                 ) {
                     depth += depth_change;
                     continue;
+                }
+            }
             return SingleInferenceResult::Incompatible
+        }
         if modified {
             to_infer.recompute_is_done();
             return SingleInferenceResult::Modified;
         } else {
             return SingleInferenceResult::Unmodified;
+        }
+    }
     /// Checks if both types are compatible, doesn't perform any inference
     fn check_subtrees(
         type_parts_a: &[InferenceTypePart], start_idx_a: usize,
         type_parts_b: &[InferenceTypePart], start_idx_b: usize
     ) -> bool {
         let mut depth = 1;
         let mut idx_a = start_idx_a;
         let mut idx_b = start_idx_b;
         while depth > 0 {
             let part_a = &type_parts_a[idx_a];
             let part_b = &type_parts_b[idx_b];
             if part_a == part_b {
                 let depth_change = part_a.depth_change();
                 depth += depth_change;
                 debug_assert_eq!(depth_change, part_b.depth_change());
                 idx_a += 1;
                 idx_b += 1;
                 continue;
+            }
             if part_a.is_marker() { idx_a += 1; continue; }
             if part_b.is_marker() { idx_b += 1; continue; }
             if let Some(depth_change) = Self::check_part_for_single_type(
                 type_parts_a, &mut idx_a, type_parts_b, &mut idx_b
             ) {
                 depth += depth_change;
                 continue;
+            }
             if let Some(depth_change) = Self::check_part_for_single_type(
                 type_parts_b, &mut idx_b, type_parts_a, &mut idx_a
             ) {
                 depth += depth_change;
                 continue;
+            }
             return false;
+        }
         true
+    }
     /// Performs the conversion of the inference type into a concrete type.
     /// By calling this function you must make sure that no unspecified types
     /// (e.g. Unknown or IntegerLike) exist in the type.
     fn write_concrete_type(&self, concrete_type: &mut ConcreteType) {
         use InferenceTypePart as ITP;
         use ConcreteTypePart as CTP;
         // Make sure inference type is specified but concrete type is not yet specified
         debug_assert!(!self.parts.is_empty());
         debug_assert!(concrete_type.parts.is_empty());
         concrete_type.parts.reserve(self.parts.len());
         let mut idx = 0;
         while idx < self.parts.len() {
             let part = &self.parts[idx];
             let converted_part = match part {
                 ITP::Marker(_) => {
                     // Markers are removed when writing to the concrete type.
                     idx += 1;
                     continue;
                 },
-                ITP::Unknown | ITP::BoolLike | ITP::NumberLike |
                 ITP::Unknown | ITP::NumberLike |
                 ITP::IntegerLike | ITP::ArrayLike | ITP::PortLike => {
                     // Should not happen if type inferencing works correctly: we
                     // should have returned a programmer-readable error or have
                     // inferred all types.
                     unreachable!("attempted to convert inference type part {:?} into concrete type", part);
                 },
                 ITP::Void => CTP::Void,
                 ITP::Message => CTP::Message,
                 ITP::BindingBool => CTP::Bool,
                 ITP::Bool => CTP::Bool,
                 ITP::UInt8 => CTP::UInt8,
                 ITP::UInt16 => CTP::UInt16,
                 ITP::UInt32 => CTP::UInt32,
                 ITP::UInt64 => CTP::UInt64,
                 ITP::SInt8 => CTP::SInt8,
                 ITP::SInt16 => CTP::SInt16,
                 ITP::SInt32 => CTP::SInt32,
                 ITP::SInt64 => CTP::SInt64,
                 ITP::Character => CTP::Character,
                 ITP::String => CTP::String,
                 ITP::Array => CTP::Array,
                 ITP::Slice => CTP::Slice,
                 ITP::Input => CTP::Input,
                 ITP::Output => CTP::Output,
                 ITP::Instance(id, num) => CTP::Instance(*id, *num),
             };
             concrete_type.parts.push(converted_part);
             idx += 1;
+        }
+    }
     /// Writes a human-readable version of the type to a string. This is used
     /// to display error messages
     fn write_display_name(
         buffer: &mut String, heap: &Heap, parts: &[InferenceTypePart], mut idx: usize
     ) -> usize {
         use InferenceTypePart as ITP;
         match &parts[idx] {
             ITP::Marker(_marker_idx) => {
                 if debug_log_enabled!() {
                     buffer.push_str(&format!("{{Marker:{}}}", *_marker_idx));
+                }
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
             },
             ITP::Unknown => buffer.push_str("?"),
             ITP::BoolLike => buffer.push_str("boollike"),
             ITP::NumberLike => buffer.push_str("numberlike"),
             ITP::IntegerLike => buffer.push_str("integerlike"),
             ITP::ArrayLike => {
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push_str("[?]");
             },
             ITP::PortLike => {
                 buffer.push_str("portlike<");
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
+            }
             ITP::Void => buffer.push_str("void"),
             ITP::BindingBool => buffer.push_str("binding result"),
             ITP::Bool => buffer.push_str(KW_TYPE_BOOL_STR),
             ITP::UInt8 => buffer.push_str(KW_TYPE_UINT8_STR),
             ITP::UInt16 => buffer.push_str(KW_TYPE_UINT16_STR),
             ITP::UInt32 => buffer.push_str(KW_TYPE_UINT32_STR),
             ITP::UInt64 => buffer.push_str(KW_TYPE_UINT64_STR),
             ITP::SInt8 => buffer.push_str(KW_TYPE_SINT8_STR),
             ITP::SInt16 => buffer.push_str(KW_TYPE_SINT16_STR),
             ITP::SInt32 => buffer.push_str(KW_TYPE_SINT32_STR),
             ITP::SInt64 => buffer.push_str(KW_TYPE_SINT64_STR),
             ITP::Character => buffer.push_str(KW_TYPE_CHAR_STR),
             ITP::String => buffer.push_str(KW_TYPE_STRING_STR),
             ITP::Message => {
                 buffer.push_str(KW_TYPE_MESSAGE_STR);
                 buffer.push('<');
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
             },
             ITP::Array => {
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push_str("[]");
             },
             ITP::Slice => {
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push_str("[..]");
             },
             ITP::Input => {
                 buffer.push_str(KW_TYPE_IN_PORT_STR);
                 buffer.push('<');
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
             },
             ITP::Output => {
                 buffer.push_str(KW_TYPE_OUT_PORT_STR);
                 buffer.push('<');
                 idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                 buffer.push('>');
             },
             ITP::Instance(definition_id, num_sub) => {
                 let definition = &heap[*definition_id];
                 buffer.push_str(definition.identifier().value.as_str());
                 if *num_sub > 0 {
                     buffer.push('<');
                     idx = Self::write_display_name(buffer, heap, parts, idx + 1);
                     for _sub_idx in 1..*num_sub {
                         buffer.push_str(", ");
                         idx = Self::write_display_name(buffer, heap, parts, idx + 1);
+                    }
                     buffer.push('>');
+                }
             },
+        }
         idx
+    }
     /// Returns the display name of a (part of) the type tree. Will allocate a
     /// string.
     fn partial_display_name(heap: &Heap, parts: &[InferenceTypePart]) -> String {
         let mut buffer = String::with_capacity(parts.len() * 6);
         Self::write_display_name(&mut buffer, heap, parts, 0);
         buffer
+    }
     /// Returns the display name of the full type tree. Will allocate a string.
     fn display_name(&self, heap: &Heap) -> String {
         Self::partial_display_name(heap, &self.parts)
+    }
+}
 impl Default for InferenceType {
     fn default() -> Self {
         Self{
             has_marker: false,
             is_done: false,
             parts: Vec::new(),
+        }
+    }
+}
 /// Iterator over the subtrees that follow a marker in an `InferenceType`
 /// instance. Returns immutable slices over the internal parts
 struct InferenceTypeMarkerIter<'a> {
     parts: &'a [InferenceTypePart],
     idx: usize,
+}
 impl<'a> InferenceTypeMarkerIter<'a> {
     fn new(parts: &'a [InferenceTypePart]) -> Self {
         Self{ parts, idx: 0 }
+    }
+}
 impl<'a> Iterator for InferenceTypeMarkerIter<'a> {
     type Item = (u32, &'a [InferenceTypePart]);
     fn next(&mut self) -> Option<Self::Item> {
         // Iterate until we find a marker
         while self.idx < self.parts.len() {
             if let InferenceTypePart::Marker(marker) = self.parts[self.idx] {
                 // Found a marker, find the subtree end
                 let start_idx = self.idx + 1;
                 let end_idx = InferenceType::find_subtree_end_idx(self.parts, start_idx);
                 // Modify internal index, then return items
                 self.idx = end_idx;
                 return Some((marker, &self.parts[start_idx..end_idx]));
+            }
             self.idx += 1;
+        }
         None
+    }
+}
 #[derive(Debug, PartialEq, Eq)]
 enum DualInferenceResult {
     Neither,        // neither argument is clarified
     First,          // first argument is clarified using the second one
     Second,         // second argument is clarified using the first one
     Both,           // both arguments are clarified
     Incompatible,   // types are incompatible: programmer error
+}
 impl DualInferenceResult {
     fn modified_lhs(&self) -> bool {
         match self {
             DualInferenceResult::First | DualInferenceResult::Both => true,
             _ => false
+        }
+    }
     fn modified_rhs(&self) -> bool {
         match self {
             DualInferenceResult::Second | DualInferenceResult::Both => true,
             _ => false
+        }
+    }
+}
 #[derive(Debug, PartialEq, Eq)]
 enum SingleInferenceResult {
     Unmodified,
     Modified,
     Incompatible
+}
 enum DefinitionType{
     Component(ComponentDefinitionId),
     Function(FunctionDefinitionId),
+}
 impl DefinitionType {
     fn definition_id(&self) -> DefinitionId {
         match self {
             DefinitionType::Component(v) => v.upcast(),
             DefinitionType::Function(v) => v.upcast(),
+        }
+    }
+}
 pub(crate) struct ResolveQueueElement {
     pub(crate) root_id: RootId,
     pub(crate) definition_id: DefinitionId,
     pub(crate) monomorph_types: Vec<ConcreteType>,
     pub(crate) reserved_monomorph_idx: i32,
+}
 impl PartialEq for ResolveQueueElement {
     fn eq(&self, other: &Self) -> bool {
         return
             self.root_id == other.root_id &&
             self.definition_id == other.definition_id &&
             self.monomorph_types == other.monomorph_types;
+    }
+}
 impl Eq for ResolveQueueElement {}
 pub(crate) type ResolveQueue = Vec<ResolveQueueElement>;
 #[derive(Clone)]
 struct InferenceExpression {
     expr_type: InferenceType,       // result type from expression
     expr_id: ExpressionId,          // expression that is evaluated
     field_or_monomorph_idx: i32,    // index of field, of index of monomorph array in type table
     extra_data_idx: i32,     // index of extra data needed for inference
+}
 impl Default for InferenceExpression {
     fn default() -> Self {
         Self{
             expr_type: InferenceType::default(),
             expr_id: ExpressionId::new_invalid(),
             field_or_monomorph_idx: -1,
             extra_data_idx: -1,
+        }
+    }
+}
 /// This particular visitor will recurse depth-first into the AST and ensures
 /// that all expressions have the appropriate types.
 pub(crate) struct PassTyping {
     // Current definition we're typechecking.
     reserved_idx: i32,
     definition_type: DefinitionType,
     poly_vars: Vec<ConcreteType>,
     // Buffers for iteration over substatements and subexpressions
     stmt_buffer: Vec<StatementId>,
     expr_buffer: Vec<ExpressionId>,
     // Mapping from parser type to inferred type. We attempt to continue to
     // specify these types until we're stuck or we've fully determined the type.
     var_types: HashMap<VariableId, VarData>,            // types of variables
     expr_types: Vec<InferenceExpression>,                     // will be transferred to type table at end
     extra_data: Vec<ExtraData>,       // data for polymorph inference
     // Keeping track of which expressions need to be reinferred because the
     // expressions they're linked to made progression on an associated type
     expr_queued: DequeSet<i32>,
+}
 // TODO: @Rename, this is used for a lot of type inferencing. It seems like
 //  there is a different underlying architecture waiting to surface.
 struct ExtraData {
     expr_id: ExpressionId, // the expression with which this data is associated
     definition_id: DefinitionId, // the definition, only used for user feedback
     /// Progression of polymorphic variables (if any)
     poly_vars: Vec<InferenceType>,
     /// Progression of types of call arguments or struct members
     embedded: Vec<InferenceType>,
     returned: InferenceType,
+}
 impl Default for ExtraData {
     fn default() -> Self {
         Self{
             expr_id: ExpressionId::new_invalid(),
             definition_id: DefinitionId::new_invalid(),
             poly_vars: Vec::new(),
             embedded: Vec::new(),
             returned: InferenceType::default(),
+        }
+    }
+}
 struct VarData {
     /// Type of the variable
     var_type: InferenceType,
     /// VariableExpressions that use the variable
     used_at: Vec<ExpressionId>,
     /// For channel statements we link to the other variable such that when one
     /// channel's interior type is resolved, we can also resolve the other one.
     linked_var: Option<VariableId>,
+}
 impl VarData {
     fn new_channel(var_type: InferenceType, other_port: VariableId) -> Self {
         Self{ var_type, used_at: Vec::new(), linked_var: Some(other_port) }
+    }
     fn new_local(var_type: InferenceType) -> Self {
         Self{ var_type, used_at: Vec::new(), linked_var: None }
+    }
+}
 impl PassTyping {
     pub(crate) fn new() -> Self {
         PassTyping {
             reserved_idx: -1,
             definition_type: DefinitionType::Function(FunctionDefinitionId::new_invalid()),
             poly_vars: Vec::new(),
             stmt_buffer: Vec::with_capacity(STMT_BUFFER_INIT_CAPACITY),
             expr_buffer: Vec::with_capacity(EXPR_BUFFER_INIT_CAPACITY),
             var_types: HashMap::new(),
             expr_types: Vec::new(),
             extra_data: Vec::new(),
             expr_queued: DequeSet::new(),
+        }
+    }
     // TODO: @cleanup Unsure about this, maybe a pattern will arise after
     //  a while.
     pub(crate) fn queue_module_definitions(ctx: &mut Ctx, queue: &mut ResolveQueue) {
         debug_assert_eq!(ctx.module.phase, ModuleCompilationPhase::ValidatedAndLinked);
         let root_id = ctx.module.root_id;
         let root = &ctx.heap.protocol_descriptions[root_id];
         for definition_id in &root.definitions {
             let definition = &ctx.heap[*definition_id];
             let should_add_to_queue = match definition {
                 Definition::Function(definition) => definition.poly_vars.is_empty(),
                 Definition::Component(definition) => definition.poly_vars.is_empty(),
                 Definition::Enum(_) | Definition::Struct(_) | Definition::Union(_) => false,
             };
             if should_add_to_queue {
                 let reserved_idx = ctx.types.reserve_procedure_monomorph_index(definition_id, None);
                 queue.push(ResolveQueueElement{
                     root_id,
                     definition_id: *definition_id,
                     monomorph_types: Vec::new(),
                     reserved_monomorph_idx: reserved_idx,
                 })
+            }
+        }
+    }
     pub(crate) fn handle_module_definition(
         &mut self, ctx: &mut Ctx, queue: &mut ResolveQueue, element: ResolveQueueElement
     ) -> VisitorResult {
         // Visit the definition
         debug_assert_eq!(ctx.module.root_id, element.root_id);
         self.reset();
         debug_assert!(self.poly_vars.is_empty());
         self.reserved_idx = element.reserved_monomorph_idx;
         self.poly_vars = element.monomorph_types;
         self.visit_definition(ctx, element.definition_id)?;
         // Keep resolving types
         self.resolve_types(ctx, queue)?;
         Ok(())
+    }
     fn reset(&mut self) {
         self.reserved_idx = -1;
         self.definition_type = DefinitionType::Function(FunctionDefinitionId::new_invalid());
         self.poly_vars.clear();
         self.stmt_buffer.clear();
         self.expr_buffer.clear();
         self.var_types.clear();
         self.expr_types.clear();
         self.extra_data.clear();
         self.expr_queued.clear();
+    }
+}
 impl Visitor2 for PassTyping {
     // Definitions
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {
         self.definition_type = DefinitionType::Component(id);
         let comp_def = &ctx.heap[id];
         debug_assert_eq!(comp_def.poly_vars.len(), self.poly_vars.len(), "component polyvars do not match imposed polyvars");
         debug_log!("{}", "-".repeat(50));
         debug_log!("Visiting component '{}': {}", comp_def.identifier.value.as_str(), id.0.index);
         debug_log!("{}", "-".repeat(50));
         // Reserve data for expression types
         debug_assert!(self.expr_types.is_empty());
         self.expr_types.resize(comp_def.num_expressions_in_body as usize, Default::default());
         // Visit parameters
         for param_id in comp_def.parameters.clone() {
             let param = &ctx.heap[param_id];
             let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);
             debug_assert!(var_type.is_done, "expected component arguments to be concrete types");
             self.var_types.insert(param_id, VarData::new_local(var_type));
+        }
         // Visit the body and all of its expressions
         let body_stmt_id = ctx.heap[id].body;
         self.visit_block_stmt(ctx, body_stmt_id)
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionDefinitionId) -> VisitorResult {
         self.definition_type = DefinitionType::Function(id);
         let func_def = &ctx.heap[id];
         debug_assert_eq!(func_def.poly_vars.len(), self.poly_vars.len(), "function polyvars do not match imposed polyvars");
         debug_log!("{}", "-".repeat(50));
         debug_log!("Visiting function '{}': {}", func_def.identifier.value.as_str(), id.0.index);
         if debug_log_enabled!() {
             debug_log!("Polymorphic variables:");
             for (idx, poly_var) in self.poly_vars.iter().enumerate() {
                 let mut infer_type_parts = Vec::new();
                 for concrete_part in &poly_var.parts {
                     infer_type_parts.push(InferenceTypePart::from(*concrete_part));
+                }
                 let infer_type = InferenceType::new(false, true, infer_type_parts);
                 debug_log!(" - [{:03}] {:?}", idx, infer_type.display_name(&ctx.heap));
+            }
+        }
         debug_log!("{}", "-".repeat(50));
@@ @@ -1290,936 +1280,936 @@ impl Visitor2 for PassTyping { @@
         self.progress_select_expr(ctx, id)
+    }
     fn visit_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let literal_expr = &ctx.heap[id];
         match &literal_expr.value {
             Literal::Null | Literal::False | Literal::True |
             Literal::Integer(_) | Literal::Character(_) | Literal::String(_) => {
                 // No subexpressions
             },
             Literal::Struct(literal) => {
                 // TODO: @performance
                 let expr_ids: Vec<_> = literal.fields
                     .iter()
                     .map(|f| f.value)
                     .collect();
                 self.insert_initial_struct_polymorph_data(ctx, id);
                 for expr_id in expr_ids {
                     self.visit_expr(ctx, expr_id)?;
+                }
             },
             Literal::Enum(_) => {
                 // Enumerations do not carry any subexpressions, but may still
                 // have a user-defined polymorphic marker variable. For this
                 // reason we may still have to apply inference to this
                 // polymorphic variable
                 self.insert_initial_enum_polymorph_data(ctx, id);
             },
             Literal::Union(literal) => {
                 // May carry subexpressions and polymorphic arguments
                 // TODO: @performance
                 let expr_ids = literal.values.clone();
                 self.insert_initial_union_polymorph_data(ctx, id);
                 for expr_id in expr_ids {
                     self.visit_expr(ctx, expr_id)?;
+                }
             },
             Literal::Array(expressions) => {
                 // TODO: @performance
                 let expr_ids = expressions.clone();
                 for expr_id in expr_ids {
                     self.visit_expr(ctx, expr_id)?;
+                }
+            }
+        }
         self.progress_literal_expr(ctx, id)
+    }
     fn visit_cast_expr(&mut self, ctx: &mut Ctx, id: CastExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let cast_expr = &ctx.heap[id];
         let subject_expr_id = cast_expr.subject;
         self.visit_expr(ctx, subject_expr_id)?;
         self.progress_cast_expr(ctx, id)
+    }
     fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         self.insert_initial_call_polymorph_data(ctx, id);
         // By default we set the polymorph idx for calls to 0. If the call ends
         // up not being a polymorphic one, then we will select the default
         // expression types in the type table
         let call_expr = &ctx.heap[id];
         self.expr_types[call_expr.unique_id_in_definition as usize].field_or_monomorph_idx = 0;
         // Visit all arguments
         for arg_expr_id in call_expr.arguments.clone() { // TODO: @Performance
             self.visit_expr(ctx, arg_expr_id)?;
+        }
         self.progress_call_expr(ctx, id)
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         self.insert_initial_expr_inference_type(ctx, upcast_id)?;
         let var_expr = &ctx.heap[id];
         debug_assert!(var_expr.declaration.is_some());
         // Not pretty: if a binding expression, then this is the first time we
         // encounter the variable, so we still need to insert the variable data.
         let declaration = &ctx.heap[var_expr.declaration.unwrap()];
         if !self.var_types.contains_key(&declaration.this)  {
             debug_assert!(declaration.kind == VariableKind::Binding);
             let var_type = self.determine_inference_type_from_parser_type_elements(
                 &declaration.parser_type.elements, true
             );
             self.var_types.insert(declaration.this, VarData{
                 var_type,
                 used_at: vec![upcast_id],
                 linked_var: None
             });
         } else {
             let var_data = self.var_types.get_mut(&declaration.this).unwrap();
             var_data.used_at.push(upcast_id);
+        }
         self.progress_variable_expr(ctx, id)
+    }
+}
 impl PassTyping {
     fn temp_get_display_name(&self, ctx: &Ctx, expr_id: ExpressionId) -> String {
         let expr_idx = ctx.heap[expr_id].get_unique_id_in_definition();
         let expr_type = &self.expr_types[expr_idx as usize].expr_type;
         expr_type.display_name(&ctx.heap)
+    }
     fn resolve_types(&mut self, ctx: &mut Ctx, queue: &mut ResolveQueue) -> Result<(), ParseError> {
         // Keep inferring until we can no longer make any progress
         while !self.expr_queued.is_empty() {
             let next_expr_idx = self.expr_queued.pop_front().unwrap();
             self.progress_expr(ctx, next_expr_idx)?;
+        }
         // Helper for transferring polymorphic variables to concrete types and
         // checking if they're completely specified
         fn poly_inference_to_concrete_type(
             ctx: &Ctx, expr_id: ExpressionId, inference: &Vec<InferenceType>
         ) -> Result<Vec<ConcreteType>, ParseError> {
             let mut concrete = Vec::with_capacity(inference.len());
             for (poly_idx, poly_type) in inference.iter().enumerate() {
                 if !poly_type.is_done {
                     let expr = &ctx.heap[expr_id];
                     let definition = match expr {
                         Expression::Call(expr) => expr.definition,
                         Expression::Literal(expr) => match &expr.value {
                             Literal::Enum(lit) => lit.definition,
                             Literal::Union(lit) => lit.definition,
                             Literal::Struct(lit) => lit.definition,
                             _ => unreachable!()
                         },
                         _ => unreachable!(),
                     };
                     let poly_vars = ctx.heap[definition].poly_vars();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, expr.span(), format!(
                             "could not fully infer the type of polymorphic variable '{}' of this expression (got '{}')",
                             poly_vars[poly_idx].value.as_str(), poly_type.display_name(&ctx.heap)
+                        )
                     ));
+                }
                 let mut concrete_type = ConcreteType::default();
                 poly_type.write_concrete_type(&mut concrete_type);
                 concrete.push(concrete_type);
+            }
             Ok(concrete)
+        }
         // Inference is now done. But we may still have uninferred types. So we
         // check for these.
         for (infer_expr_idx, infer_expr) in self.expr_types.iter_mut().enumerate() {
             let expr_type = &mut infer_expr.expr_type;
             if !expr_type.is_done {
                 // Auto-infer numberlike/integerlike types to a regular int
                 if expr_type.parts.len() == 1 && expr_type.parts[0] == InferenceTypePart::IntegerLike {
                     expr_type.parts[0] = InferenceTypePart::SInt32;
                     self.expr_queued.push_back(infer_expr_idx as i32);
                 } else {
                     let expr = &ctx.heap[infer_expr.expr_id];
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, expr.span(), format!(
                             "could not fully infer the type of this expression (got '{}')",
                             expr_type.display_name(&ctx.heap)
+                        )
                     ));
+                }
+            }
             // Expression is fine, check if any extra data is attached
             if infer_expr.extra_data_idx < 0 { continue; }
             // Extra data is attached, perform typechecking and transfer
             // resolved information to the expression
             let extra_data = &self.extra_data[infer_expr.extra_data_idx as usize];
             if extra_data.poly_vars.is_empty() { continue; }
             // Note that only call and literal expressions need full inference.
             // Select expressions also use `extra_data`, but only for temporary
             // storage of the struct type whose field it is selecting.
             match &ctx.heap[extra_data.expr_id] {
                 Expression::Call(expr) => {
                     if expr.method != Method::UserFunction && expr.method != Method::UserComponent {
                         // Builtin function
                         continue;
+                    }
                     let definition_id = expr.definition;
                     let poly_types = poly_inference_to_concrete_type(ctx, extra_data.expr_id, &extra_data.poly_vars)?;
                     match ctx.types.get_procedure_monomorph_index(&definition_id, &poly_types) {
                         Some(reserved_idx) => {
                             // Already typechecked, or already put into the resolve queue
                             infer_expr.field_or_monomorph_idx = reserved_idx;
                         },
                         None => {
                             // Not typechecked yet, so add an entry in the queue
                             let reserved_idx = ctx.types.reserve_procedure_monomorph_index(&definition_id, Some(poly_types.clone()));
                             infer_expr.field_or_monomorph_idx = reserved_idx;
                             queue.push(ResolveQueueElement{
                                 root_id: ctx.heap[definition_id].defined_in(),
                                 definition_id,
                                 monomorph_types: poly_types,
                                 reserved_monomorph_idx: reserved_idx,
                             });
+                        }
+                    }
                 },
                 Expression::Literal(expr) => {
                     let definition_id = match &expr.value {
                         Literal::Enum(lit) => lit.definition,
                         Literal::Union(lit) => lit.definition,
                         Literal::Struct(lit) => lit.definition,
                         _ => unreachable!(),
                     };
                     let poly_types = poly_inference_to_concrete_type(ctx, extra_data.expr_id, &extra_data.poly_vars)?;
                     let mono_index = ctx.types.add_data_monomorph(&definition_id, poly_types);
                     infer_expr.field_or_monomorph_idx = mono_index;
                 },
                 Expression::Select(_) => {
                     debug_assert!(infer_expr.field_or_monomorph_idx >= 0);
                 },
                 _ => {
                     unreachable!("handling extra data for expression {:?}", &ctx.heap[extra_data.expr_id]);
+                }
+            }
+        }
         // If we did any implicit type forcing, then our queue isn't empty
         // anymore
         while !self.expr_queued.is_empty() {
             let expr_idx = self.expr_queued.pop_back().unwrap();
             self.progress_expr(ctx, expr_idx)?;
+        }
         // Every expression checked, and new monomorphs are queued. Transfer the
         // expression information to the type table.
         let definition_id = match &self.definition_type {
             DefinitionType::Component(id) => id.upcast(),
             DefinitionType::Function(id) => id.upcast(),
         };
         let target = ctx.types.get_procedure_expression_data_mut(&definition_id, self.reserved_idx);
         debug_assert!(target.poly_args == self.poly_vars);
         debug_assert!(target.expr_data.is_empty()); // makes sure we never queue something twice
         target.expr_data.reserve(self.expr_types.len());
         for infer_expr in self.expr_types.iter() {
             let mut concrete = ConcreteType::default();
             infer_expr.expr_type.write_concrete_type(&mut concrete);
             target.expr_data.push(MonomorphExpression{
                 expr_type: concrete,
                 field_or_monomorph_idx: infer_expr.field_or_monomorph_idx
             });
+        }
         Ok(())
+    }
     fn progress_expr(&mut self, ctx: &mut Ctx, idx: i32) -> Result<(), ParseError> {
         let id = self.expr_types[idx as usize].expr_id; // TODO: @Temp
         match &ctx.heap[id] {
             Expression::Assignment(expr) => {
                 let id = expr.this;
                 self.progress_assignment_expr(ctx, id)
             },
             Expression::Binding(expr) => {
                 let id = expr.this;
                 self.progress_binding_expr(ctx, id)
             },
             Expression::Conditional(expr) => {
                 let id = expr.this;
                 self.progress_conditional_expr(ctx, id)
             },
             Expression::Binary(expr) => {
                 let id = expr.this;
                 self.progress_binary_expr(ctx, id)
             },
             Expression::Unary(expr) => {
                 let id = expr.this;
                 self.progress_unary_expr(ctx, id)
             },
             Expression::Indexing(expr) => {
                 let id = expr.this;
                 self.progress_indexing_expr(ctx, id)
             },
             Expression::Slicing(expr) => {
                 let id = expr.this;
                 self.progress_slicing_expr(ctx, id)
             },
             Expression::Select(expr) => {
                 let id = expr.this;
                 self.progress_select_expr(ctx, id)
             },
             Expression::Literal(expr) => {
                 let id = expr.this;
                 self.progress_literal_expr(ctx, id)
             },
             Expression::Cast(expr) => {
                 let id = expr.this;
                 self.progress_cast_expr(ctx, id)
             },
             Expression::Call(expr) => {
                 let id = expr.this;
                 self.progress_call_expr(ctx, id)
             },
             Expression::Variable(expr) => {
                 let id = expr.this;
                 self.progress_variable_expr(ctx, id)
+            }
+        }
+    }
     fn progress_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> Result<(), ParseError> {
         use AssignmentOperator as AO;
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_expr_id = expr.left;
         let arg2_expr_id = expr.right;
         debug_log!("Assignment expr '{:?}': {}", expr.operation, upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Arg1 type: {}", self.temp_get_display_name(ctx, arg1_expr_id));
         debug_log!("   - Arg2 type: {}", self.temp_get_display_name(ctx, arg2_expr_id));
         debug_log!("   - Expr type: {}", self.temp_get_display_name(ctx, upcast_id));
         // Assignment does not return anything (it operates like a statement)
         let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &VOID_TEMPLATE)?;
         // Apply forced constraint to LHS value
         let progress_forced = match expr.operation {
             AO::Set =>
                 false,
             AO::Multiplied | AO::Divided | AO::Added | AO::Subtracted =>
                 self.apply_template_constraint(ctx, arg1_expr_id, &NUMBERLIKE_TEMPLATE)?,
             AO::Remained | AO::ShiftedLeft | AO::ShiftedRight |
             AO::BitwiseAnded | AO::BitwiseXored | AO::BitwiseOred =>
                 self.apply_template_constraint(ctx, arg1_expr_id, &INTEGERLIKE_TEMPLATE)?,
         };
         let (progress_arg1, progress_arg2) = self.apply_equal2_constraint(
             ctx, upcast_id, arg1_expr_id, 0, arg2_expr_id, 0
         )?;
         debug_assert!(if progress_forced { progress_arg2 } else { true });
         debug_log!(" * After:");
         debug_log!("   - Arg1 type [{}]: {}", progress_forced || progress_arg1, self.temp_get_display_name(ctx, arg1_expr_id));
         debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.temp_get_display_name(ctx, arg2_expr_id));
         debug_log!("   - Expr type [{}]: {}", progress_expr, self.temp_get_display_name(ctx, upcast_id));
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_forced || progress_arg1 { self.queue_expr(ctx, arg1_expr_id); }
         if progress_arg2 { self.queue_expr(ctx, arg2_expr_id); }
         Ok(())
+    }
     fn progress_binding_expr(&mut self, ctx: &mut Ctx, id: BindingExpressionId) -> Result<(), ParseError> {
         let upcast_id = id.upcast();
         let binding_expr = &ctx.heap[id];
         let bound_from_id = binding_expr.bound_from;
         let bound_to_id = binding_expr.bound_to;
         // Output of a binding expression is a special kind of boolean that can
         // only be used in binary-and expressions
         let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BINDING_BOOL_TEMPLATE)?;
         // Output is always a boolean. The two arguments should be of equal
         // type.
         let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
         let (progress_from, progress_to) = self.apply_equal2_constraint(ctx, upcast_id, bound_from_id, 0, bound_to_id, 0)?;
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_from { self.queue_expr(ctx, bound_from_id); }
         if progress_to { self.queue_expr(ctx, bound_to_id); }
         Ok(())
+    }
     fn progress_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> Result<(), ParseError> {
         // Note: test expression type is already enforced
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_expr_id = expr.true_expression;
         let arg2_expr_id = expr.false_expression;
         debug_log!("Conditional expr: {}", upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Arg1 type: {}", self.temp_get_display_name(ctx, arg1_expr_id));
         debug_log!("   - Arg2 type: {}", self.temp_get_display_name(ctx, arg2_expr_id));
         debug_log!("   - Expr type: {}", self.temp_get_display_name(ctx, upcast_id));
         // I keep confusing myself: this applies equality of types between the
         // condition branches' types, and the result from the conditional
         // expression, because the result from the conditional is one of the
         // branches.
         let (progress_expr, progress_arg1, progress_arg2) = self.apply_equal3_constraint(
             ctx, upcast_id, arg1_expr_id, arg2_expr_id, 0
         )?;
         debug_log!(" * After:");
         debug_log!("   - Arg1 type [{}]: {}", progress_arg1, self.temp_get_display_name(ctx, arg1_expr_id));
         debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.temp_get_display_name(ctx, arg2_expr_id));
         debug_log!("   - Expr type [{}]: {}", progress_expr, self.temp_get_display_name(ctx, upcast_id));
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg1 { self.queue_expr(ctx, arg1_expr_id); }
         if progress_arg2 { self.queue_expr(ctx, arg2_expr_id); }
         Ok(())
+    }
     fn progress_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> Result<(), ParseError> {
         // Note: our expression type might be fixed by our parent, but we still
         // need to make sure it matches the type associated with our operation.
         use BinaryOperator as BO;
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg1_id = expr.left;
         let arg2_id = expr.right;
         debug_log!("Binary expr '{:?}': {}", expr.operation, upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Arg1 type: {}", self.temp_get_display_name(ctx, arg1_id));
         debug_log!("   - Arg2 type: {}", self.temp_get_display_name(ctx, arg2_id));
         debug_log!("   - Expr type: {}", self.temp_get_display_name(ctx, upcast_id));
         let (progress_expr, progress_arg1, progress_arg2) = match expr.operation {
             BO::Concatenate => {
                 // Arguments may be arrays/slices, output is always an array
                 let progress_expr = self.apply_template_constraint(ctx, upcast_id, &ARRAY_TEMPLATE)?;
                 let progress_arg1 = self.apply_template_constraint(ctx, arg1_id, &ARRAYLIKE_TEMPLATE)?;
                 let progress_arg2 = self.apply_template_constraint(ctx, arg2_id, &ARRAYLIKE_TEMPLATE)?;
                 // If they're all arraylike, then we want the subtype to match
                 let (subtype_expr, subtype_arg1, subtype_arg2) =
                     self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 1)?;
                 (progress_expr || subtype_expr, progress_arg1 || subtype_arg1, progress_arg2 || subtype_arg2)
             },
             BO::LogicalAnd => {
                 // Logical AND may operate both on normal booleans and on
                 // booleans that are the result of a binding expression. So we
                 // force the expression to bool-like, then apply an equal_3
                 // constraint. Any BindingBool will promote all the other Bool
                 // types.
                 let base_expr = self.apply_template_constraint(ctx, upcast_id, &BOOLLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg1, progress_arg2) =
                     self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 0)?;
                 // Forced boolean on all
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg1 = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg2 = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
-                (base_expr || progress_expr, progress_arg1, progress_arg2)
                 (progress_expr, progress_arg1, progress_arg2)
             },
             BO::LogicalOr => {
                 // Forced boolean on all
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg1 = self.apply_forced_constraint(ctx, arg1_id, &BOOL_TEMPLATE)?;
                 let progress_arg2 = self.apply_forced_constraint(ctx, arg2_id, &BOOL_TEMPLATE)?;
                 (progress_expr, progress_arg1, progress_arg2)
             },
             BO::BitwiseOr | BO::BitwiseXor | BO::BitwiseAnd | BO::Remainder | BO::ShiftLeft | BO::ShiftRight => {
                 // All equal of integer type
                 let progress_base = self.apply_template_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg1, progress_arg2) =
                     self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg1, progress_base || progress_arg2)
             },
             BO::Equality | BO::Inequality => {
                 // Equal2 on args, forced boolean output
-                let progress_expr = self.apply_template_constraint(ctx, upcast_id, &BOOLLIKE_TEMPLATE)?;
+                let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let (progress_arg1, progress_arg2) =
                     self.apply_equal2_constraint(ctx, upcast_id, arg1_id, 0, arg2_id, 0)?;
                 (progress_expr, progress_arg1, progress_arg2)
             },
             BO::LessThan | BO::GreaterThan | BO::LessThanEqual | BO::GreaterThanEqual => {
                 // Equal2 on args with numberlike type, forced boolean output
-                let progress_expr = self.apply_template_constraint(ctx, upcast_id, &BOOLLIKE_TEMPLATE)?;
+                let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg_base = self.apply_template_constraint(ctx, arg1_id, &NUMBERLIKE_TEMPLATE)?;
                 let (progress_arg1, progress_arg2) =
                     self.apply_equal2_constraint(ctx, upcast_id, arg1_id, 0, arg2_id, 0)?;
                 (progress_expr, progress_arg_base || progress_arg1, progress_arg_base || progress_arg2)
             },
             BO::Add | BO::Subtract | BO::Multiply | BO::Divide => {
                 // All equal of number type
                 let progress_base = self.apply_template_constraint(ctx, upcast_id, &NUMBERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg1, progress_arg2) =
                     self.apply_equal3_constraint(ctx, upcast_id, arg1_id, arg2_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg1, progress_base || progress_arg2)
             },
         };
         debug_log!(" * After:");
         debug_log!("   - Arg1 type [{}]: {}", progress_arg1, self.temp_get_display_name(ctx, arg1_id));
         debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.temp_get_display_name(ctx, arg2_id));
         debug_log!("   - Expr type [{}]: {}", progress_expr, self.temp_get_display_name(ctx, upcast_id));
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg1 { self.queue_expr(ctx, arg1_id); }
         if progress_arg2 { self.queue_expr(ctx, arg2_id); }
         Ok(())
+    }
     fn progress_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> Result<(), ParseError> {
         use UnaryOperator as UO;
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let arg_id = expr.expression;
         debug_log!("Unary expr '{:?}': {}", expr.operation, upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Arg  type: {}", self.temp_get_display_name(ctx, arg_id));
         debug_log!("   - Expr type: {}", self.temp_get_display_name(ctx, upcast_id));
         let (progress_expr, progress_arg) = match expr.operation {
             UO::Positive | UO::Negative => {
                 // Equal types of numeric class
                 let progress_base = self.apply_template_constraint(ctx, upcast_id, &NUMBERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg) =
                     self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, arg_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg)
             },
             UO::BitwiseNot => {
                 // Equal types of integer class
                 let progress_base = self.apply_template_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?;
                 let (progress_expr, progress_arg) =
                     self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, arg_id, 0)?;
                 (progress_base || progress_expr, progress_base || progress_arg)
             },
             UO::LogicalNot => {
-                // Both booleans
+                // Both bools
                 let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 let progress_arg = self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?;
                 (progress_expr, progress_arg)
+            }
         };
         debug_log!(" * After:");
         debug_log!("   - Arg  type [{}]: {}", progress_arg, self.temp_get_display_name(ctx, arg_id));
         debug_log!("   - Expr type [{}]: {}", progress_expr, self.temp_get_display_name(ctx, upcast_id));
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_arg { self.queue_expr(ctx, arg_id); }
         Ok(())
+    }
     fn progress_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> Result<(), ParseError> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let subject_id = expr.subject;
         let index_id = expr.index;
         debug_log!("Indexing expr: {}", upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Subject type: {}", self.temp_get_display_name(ctx, subject_id));
         debug_log!("   - Index   type: {}", self.temp_get_display_name(ctx, index_id));
         debug_log!("   - Expr    type: {}", self.temp_get_display_name(ctx, upcast_id));
         // Make sure subject is arraylike and index is integerlike
         let progress_subject_base = self.apply_template_constraint(ctx, subject_id, &ARRAYLIKE_TEMPLATE)?;
         let progress_index = self.apply_template_constraint(ctx, index_id, &INTEGERLIKE_TEMPLATE)?;
         // Make sure if output is of T then subject is Array<T>
         let (progress_expr, progress_subject) =
             self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 0, subject_id, 1)?;
         debug_log!(" * After:");
         debug_log!("   - Subject type [{}]: {}", progress_subject_base || progress_subject, self.temp_get_display_name(ctx, subject_id));
         debug_log!("   - Index   type [{}]: {}", progress_index, self.temp_get_display_name(ctx, index_id));
         debug_log!("   - Expr    type [{}]: {}", progress_expr, self.temp_get_display_name(ctx, upcast_id));
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_subject_base || progress_subject { self.queue_expr(ctx, subject_id); }
         if progress_index { self.queue_expr(ctx, index_id); }
         Ok(())
+    }
     fn progress_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> Result<(), ParseError> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let subject_id = expr.subject;
         let from_id = expr.from_index;
         let to_id = expr.to_index;
         debug_log!("Slicing expr: {}", upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Subject type: {}", self.temp_get_display_name(ctx, subject_id));
         debug_log!("   - FromIdx type: {}", self.temp_get_display_name(ctx, from_id));
         debug_log!("   - ToIdx   type: {}", self.temp_get_display_name(ctx, to_id));
         debug_log!("   - Expr    type: {}", self.temp_get_display_name(ctx, upcast_id));
         // Make sure subject is arraylike and indices are of equal integerlike
         let progress_subject_base = self.apply_template_constraint(ctx, subject_id, &ARRAYLIKE_TEMPLATE)?;
         let progress_idx_base = self.apply_template_constraint(ctx, from_id, &INTEGERLIKE_TEMPLATE)?;
         let (progress_from, progress_to) = self.apply_equal2_constraint(ctx, upcast_id, from_id, 0, to_id, 0)?;
         // Make sure if output is of Slice<T> then subject is Array<T>
         let progress_expr_base = self.apply_template_constraint(ctx, upcast_id, &SLICE_TEMPLATE)?;
         let (progress_expr, progress_subject) =
             self.apply_equal2_constraint(ctx, upcast_id, upcast_id, 1, subject_id, 1)?;
         debug_log!(" * After:");
         debug_log!("   - Subject type [{}]: {}", progress_subject_base || progress_subject, self.temp_get_display_name(ctx, subject_id));
         debug_log!("   - FromIdx type [{}]: {}", progress_idx_base || progress_from, self.temp_get_display_name(ctx, from_id));
         debug_log!("   - ToIdx   type [{}]: {}", progress_idx_base || progress_to, self.temp_get_display_name(ctx, to_id));
         debug_log!("   - Expr    type [{}]: {}", progress_expr, self.temp_get_display_name(ctx, upcast_id));
         if progress_expr_base || progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         if progress_subject_base || progress_subject { self.queue_expr(ctx, subject_id); }
         if progress_idx_base || progress_from { self.queue_expr(ctx, from_id); }
         if progress_idx_base || progress_to { self.queue_expr(ctx, to_id); }
         Ok(())
+    }
     fn progress_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> Result<(), ParseError> {
         let upcast_id = id.upcast();
         debug_log!("Select expr: {}", upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Subject type: {}", self.temp_get_display_name(ctx, ctx.heap[id].subject));
         debug_log!("   - Expr    type: {}", self.temp_get_display_name(ctx, upcast_id));
         let subject_id = ctx.heap[id].subject;
         let subject_expr_idx = ctx.heap[subject_id].get_unique_id_in_definition();
         let select_expr = &ctx.heap[id];
         let expr_idx = select_expr.unique_id_in_definition;
         let infer_expr = &self.expr_types[expr_idx as usize];
         let extra_idx = infer_expr.extra_data_idx;
         fn determine_inference_type_instance<'a>(types: &'a TypeTable, infer_type: &InferenceType) -> Result<Option<&'a DefinedType>, ()> {
             for part in &infer_type.parts {
                 if part.is_marker() || !part.is_concrete() {
                     continue;
+                }
                 // Part is concrete, check if it is an instance of something
                 if let InferenceTypePart::Instance(definition_id, _num_sub) = part {
                     // Lookup type definition and ensure the specified field
                     // name exists on the struct
                     let definition = types.get_base_definition(definition_id);
                     debug_assert!(definition.is_some());
                     let definition = definition.unwrap();
                     return Ok(Some(definition))
                 } else {
                     // Expected an instance of something
                     return Err(())
+                }
+            }
             // Nothing is concrete yet
             Ok(None)
+        }
         if infer_expr.field_or_monomorph_idx < 0 {
             // We don't know the field or the definition it is pointing to yet
             // Not yet known, check if we can determine it
             let subject_type = &self.expr_types[subject_expr_idx as usize].expr_type;
             let type_def = determine_inference_type_instance(&ctx.types, subject_type);
             match type_def {
                 Ok(Some(type_def)) => {
                     // Subject type is known, check if it is a
                     // struct and the field exists on the struct
                     let struct_def = if let DefinedTypeVariant::Struct(struct_def) = &type_def.definition {
                         struct_def
                     } else {
                         return Err(ParseError::new_error_at_span(
                             &ctx.module.source, select_expr.field_name.span, format!(
                                 "Can only apply field access to structs, got a subject of type '{}'",
                                 subject_type.display_name(&ctx.heap)
+                            )
                         ));
                     };
                     let mut struct_def_id = None;
                     for (field_def_idx, field_def) in struct_def.fields.iter().enumerate() {
                         if field_def.identifier == select_expr.field_name {
                             // Set field definition and index
                             let infer_expr = &mut self.expr_types[expr_idx as usize];
                             infer_expr.field_or_monomorph_idx = field_def_idx as i32;
                             struct_def_id = Some(type_def.ast_definition);
                             break;
+                        }
+                    }
                     if struct_def_id.is_none() {
                         let ast_struct_def = ctx.heap[type_def.ast_definition].as_struct();
                         return Err(ParseError::new_error_at_span(
                             &ctx.module.source, select_expr.field_name.span, format!(
                                 "this field does not exist on the struct '{}'",
                                 ast_struct_def.identifier.value.as_str()
+                            )
                         ))
+                    }
                     // Encountered definition and field index for the
                     // first time
                     self.insert_initial_select_polymorph_data(ctx, id, struct_def_id.unwrap());
                 },
                 Ok(None) => {
                     // Type of subject is not yet known, so we
                     // cannot make any progress yet
                     return Ok(())
                 },
                 Err(()) => {
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, select_expr.field_name.span, format!(
                             "Can only apply field access to structs, got a subject of type '{}'",
                             subject_type.display_name(&ctx.heap)
+                        )
                     ));
+                }
+            }
+        }
         // If here then field index is known, and the referenced struct type
         // information is inserted into `extra_data`. Check to see if we can
         // do some mutual inference.
         let poly_data = &mut self.extra_data[extra_idx as usize];
         let mut poly_progress = HashSet::new();
         // Apply to struct's type
         let signature_type: *mut _ = &mut poly_data.embedded[0];
         let subject_type: *mut _ = &mut self.expr_types[subject_expr_idx as usize].expr_type;
         let (_, progress_subject) = Self::apply_equal2_signature_constraint(
             ctx, upcast_id, Some(subject_id), poly_data, &mut poly_progress,
             signature_type, 0, subject_type, 0
         )?;
         if progress_subject {
             self.expr_queued.push_back(subject_expr_idx);
+        }
         // Apply to field's type
         let signature_type: *mut _ = &mut poly_data.returned;
         let expr_type: *mut _ = &mut self.expr_types[expr_idx as usize].expr_type;
         let (_, progress_expr) = Self::apply_equal2_signature_constraint(
             ctx, upcast_id, None, poly_data, &mut poly_progress,
             signature_type, 0, expr_type, 0
         )?;
         if progress_expr {
             if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {
                 let parent_idx = ctx.heap[parent_id].get_unique_id_in_definition();
                 self.expr_queued.push_back(parent_idx);
+            }
+        }
         // Reapply progress in polymorphic variables to struct's type
         let signature_type: *mut _ = &mut poly_data.embedded[0];
         let subject_type: *mut _ = &mut self.expr_types[subject_expr_idx as usize].expr_type;
         let progress_subject = Self::apply_equal2_polyvar_constraint(
             poly_data, &poly_progress, signature_type, subject_type
         );
         let signature_type: *mut _ = &mut poly_data.returned;
         let expr_type: *mut _ = &mut self.expr_types[expr_idx as usize].expr_type;
         let progress_expr = Self::apply_equal2_polyvar_constraint(
             poly_data, &poly_progress, signature_type, expr_type
         );
         if progress_subject { self.queue_expr(ctx, subject_id); }
         if progress_expr { self.queue_expr_parent(ctx, upcast_id); }
         debug_log!(" * After:");
         debug_log!("   - Subject type [{}]: {}", progress_subject, self.temp_get_display_name(ctx, subject_id));
         debug_log!("   - Expr    type [{}]: {}", progress_expr, self.temp_get_display_name(ctx, upcast_id));
         Ok(())
+    }
     fn progress_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> Result<(), ParseError> {
         let upcast_id = id.upcast();
         let expr = &ctx.heap[id];
         let expr_idx = expr.unique_id_in_definition;
         let extra_idx = self.expr_types[expr_idx as usize].extra_data_idx;
         debug_log!("Literal expr: {}", upcast_id.index);
         debug_log!(" * Before:");
         debug_log!("   - Expr type: {}", self.temp_get_display_name(ctx, upcast_id));
         let progress_expr = match &expr.value {
             Literal::Null => {
                 self.apply_template_constraint(ctx, upcast_id, &MESSAGE_TEMPLATE)?
             },
             Literal::Integer(_) => {
                 self.apply_template_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?
             },
             Literal::True | Literal::False => {
                 self.apply_forced_constraint(ctx, upcast_id, &BOOL_TEMPLATE)?
             },
             Literal::Character(_) => {
                 self.apply_forced_constraint(ctx, upcast_id, &CHARACTER_TEMPLATE)?
             },
             Literal::String(_) => {
                 self.apply_forced_constraint(ctx, upcast_id, &STRING_TEMPLATE)?
             },
             Literal::Struct(data) => {
                 let extra = &mut self.extra_data[extra_idx as usize];
                 for _poly in &extra.poly_vars {
                     debug_log!(" * Poly: {}", _poly.display_name(&ctx.heap));
+                }
                 let mut poly_progress = HashSet::new();
                 debug_assert_eq!(extra.embedded.len(), data.fields.len());
                 debug_log!(" * During (inferring types from fields and struct type):");
                 // Mutually infer field signature/expression types
                 for (field_idx, field) in data.fields.iter().enumerate() {
                     let field_expr_id = field.value;
                     let field_expr_idx = ctx.heap[field_expr_id].get_unique_id_in_definition();
                     let signature_type: *mut _ = &mut extra.embedded[field_idx];
                     let field_type: *mut _ = &mut self.expr_types[field_expr_idx as usize].expr_type;
                     let (_, progress_arg) = Self::apply_equal2_signature_constraint(
                         ctx, upcast_id, Some(field_expr_id), extra, &mut poly_progress,
                         signature_type, 0, field_type, 0
                     )?;
                     debug_log!(
                         "   - Field {} type | sig: {}, field: {}", field_idx,
                         unsafe{&*signature_type}.display_name(&ctx.heap),
                         unsafe{&*field_type}.display_name(&ctx.heap)
                     );
                     if progress_arg {
                         self.expr_queued.push_back(field_expr_idx);
+                    }
+                }
                 debug_log!("   - Field poly progress | {:?}", poly_progress);
                 // Same for the type of the struct itself
                 let signature_type: *mut _ = &mut extra.returned;
                 let expr_type: *mut _ = &mut self.expr_types[expr_idx as usize].expr_type;
                 let (_, progress_expr) = Self::apply_equal2_signature_constraint(
                     ctx, upcast_id, None, extra, &mut poly_progress,
                     signature_type, 0, expr_type, 0
                 )?;
                 debug_log!(
                     "   - Ret type | sig: {}, expr: {}",
                     unsafe{&*signature_type}.display_name(&ctx.heap),
                     unsafe{&*expr_type}.display_name(&ctx.heap)
                 );
                 debug_log!("   - Ret poly progress | {:?}", poly_progress);
                 if progress_expr {
                     // TODO: @cleanup, cannot call utility self.queue_parent thingo
                     if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {
                         let parent_idx = ctx.heap[parent_id].get_unique_id_in_definition();
                         self.expr_queued.push_back(parent_idx);
+                    }
+                }
                 // Check which expressions use the polymorphic arguments. If the
                 // polymorphic variables have been progressed then we try to
                 // progress them inside the expression as well.
                 debug_log!(" * During (reinferring from progressed polyvars):");
                 // For all field expressions
                 for field_idx in 0..extra.embedded.len() {
                     // Note: fields in extra.embedded are in the same order as
                     // they are specified in the literal. Whereas
                     // `data.fields[...].field_idx` points to the field in the
                     // struct definition.
                     let signature_type: *mut _ = &mut extra.embedded[field_idx];
                     let field_expr_id = data.fields[field_idx].value;
                     let field_expr_idx = ctx.heap[field_expr_id].get_unique_id_in_definition();
                     let field_type: *mut _ = &mut self.expr_types[field_expr_idx as usize].expr_type;
                     let progress_arg = Self::apply_equal2_polyvar_constraint(
                         extra, &poly_progress, signature_type, field_type
                     );
                     debug_log!(
                         "   - Field {} type | sig: {}, field: {}", field_idx,
                         unsafe{&*signature_type}.display_name(&ctx.heap),
                         unsafe{&*field_type}.display_name(&ctx.heap)
                     );
                     if progress_arg {
                         self.expr_queued.push_back(field_expr_idx);
+                    }
+                }
                 // For the return type
                 let signature_type: *mut _ = &mut extra.returned;
                 let expr_type: *mut _ = &mut self.expr_types[expr_idx as usize].expr_type;
                 let progress_expr = Self::apply_equal2_polyvar_constraint(
                     extra, &poly_progress, signature_type, expr_type
                 );
                 progress_expr
             },
             Literal::Enum(_) => {
                 let extra = &mut self.extra_data[extra_idx as usize];
                 for _poly in &extra.poly_vars {
                     debug_log!(" * Poly: {}", _poly.display_name(&ctx.heap));
+                }
                 let mut poly_progress = HashSet::new();
                 debug_log!(" * During (inferring types from return type)");
                 let signature_type: *mut _ = &mut extra.returned;

src/protocol/parser/pass_validation_linking.rs

➞

Show inline comments

@@ @@ -25,815 +25,870 @@ impl DefinitionType { @@
     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(),
+        }
+    }
+}
 /// 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.
 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_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,
     // Parent expression (the previous stmt/expression we visited that could be
     // used as an expression parent)
     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
     next_expr_index: i32, // to arrive at a unique ID for all expressions within a definition
     // 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_test_expr: StatementId::new_invalid(),
             in_binding_expr: BindingExpressionId::new_invalid(),
             in_binding_expr_lhs: false,
             cur_scope: Scope::Definition(DefinitionId::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,
             variable_buffer: ScopedBuffer::new_reserved(128),
             definition_buffer: ScopedBuffer::new_reserved(128),
             statement_buffer: ScopedBuffer::new_reserved(STMT_BUFFER_INIT_CAPACITY),
             expression_buffer: ScopedBuffer::new_reserved(EXPR_BUFFER_INIT_CAPACITY),
+        }
+    }
     fn reset_state(&mut self) {
         self.in_sync = SynchronousStatementId::new_invalid();
         self.in_while = WhileStatementId::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.def_type = DefinitionType::Function(FunctionDefinitionId::new_invalid());
         self.expr_parent = ExpressionParent::None;
         self.must_be_assignable = None;
         self.relative_pos_in_block = 0;
         self.next_expr_index = 0
+    }
+}
 impl Visitor2 for PassValidationLinking {
     fn visit_module(&mut self, ctx: &mut Ctx) -> VisitorResult {
         debug_assert_eq!(ctx.module.phase, ModuleCompilationPhase::TypesAddedToTable);
         let root = &ctx.heap[ctx.module.root_id];
         let section = self.definition_buffer.start_section_initialized(&root.definitions);
         for definition_idx in 0..section.len() {
             let definition_id = section[definition_idx];
             self.visit_definition(ctx, definition_id)?;
+        }
         section.forget();
         ctx.module.phase = ModuleCompilationPhase::ValidatedAndLinked;
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Definition visitors
     //--------------------------------------------------------------------------
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {
         self.reset_state();
         self.def_type = match &ctx.heap[id].variant {
             ComponentVariant::Primitive => DefinitionType::Primitive(id),
             ComponentVariant::Composite => DefinitionType::Composite(id),
         };
         self.cur_scope = Scope::Definition(id.upcast());
         self.expr_parent = ExpressionParent::None;
         // Visit parameters and assign a unique scope ID
         let definition = &ctx.heap[id];
         let body_id = definition.body;
         let section = self.variable_buffer.start_section_initialized(&definition.parameters);
         for variable_idx in 0..section.len() {
             let variable_id = section[variable_idx];
             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());
         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;
         // Visit parameters and assign a unique scope ID
         let definition = &ctx.heap[id];
         let body_id = definition.body;
         let section = self.variable_buffer.start_section_initialized(&definition.parameters);
         for variable_idx in 0..section.len() {
             let variable_id = section[variable_idx];
             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());
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Statement visitors
     //--------------------------------------------------------------------------
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         self.visit_block_stmt_with_hint(ctx, id, None)
+    }
     fn visit_local_memory_stmt(&mut self, _ctx: &mut Ctx, _id: MemoryStatementId) -> VisitorResult {
         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 {
         let body_id = ctx.heap[id].body;
         self.visit_stmt(ctx, body_id)?;
         Ok(())
+    }
     fn visit_if_stmt(&mut self, ctx: &mut Ctx, id: IfStatementId) -> VisitorResult {
         let if_stmt = &ctx.heap[id];
         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);
         debug_assert!(self.in_test_expr.is_invalid());
         self.in_test_expr = id.upcast();
         self.expr_parent = ExpressionParent::If(id);
         self.visit_expr(ctx, test_expr_id)?;
         self.in_test_expr = StatementId::new_invalid();
         self.expr_parent = ExpressionParent::None;
         self.visit_block_stmt(ctx, true_stmt_id)?;
         if let Some(false_id) = false_stmt_id {
             self.visit_block_stmt(ctx, false_id)?;
+        }
         Ok(())
+    }
     fn visit_while_stmt(&mut self, ctx: &mut Ctx, id: WhileStatementId) -> VisitorResult {
         let (test_id, body_id) = {
             let stmt = &ctx.heap[id];
             (stmt.test, stmt.body)
         };
         let old_while = self.in_while;
         self.in_while = id;
         // Visit test expression
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         debug_assert!(self.in_test_expr.is_invalid());
         self.in_test_expr = id.upcast();
         self.expr_parent = ExpressionParent::While(id);
         self.visit_expr(ctx, test_id)?;
         self.in_test_expr = StatementId::new_invalid();
         self.expr_parent = ExpressionParent::None;
         self.visit_block_stmt(ctx, body_id)?;
         self.in_while = old_while;
         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
         };
         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)?
         };
         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 cur_sync_span = ctx.heap[id].span;
         if !self.in_sync.is_invalid() {
             // Nested synchronous statement
             let old_sync_span = ctx.heap[self.in_sync].span;
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, cur_sync_span, "Illegal nested synchronous statement"
             ).with_info_str_at_span(
                 &ctx.module.source, old_sync_span, "It is nested in this synchronous statement"
             ));
+        }
         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"
             ));
+        }
         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))?;
         self.in_sync = SynchronousStatementId::new_invalid();
         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
         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")
             );
+        }
         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"
             ));
+        }
         // Recurse into call expression (which will check the expression parent
         // to ensure that the "new" statment instantiates a component)
         let call_expr_id = ctx.heap[id].expression;
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         self.expr_parent = ExpressionParent::New(id);
         self.visit_call_expr(ctx, call_expr_id)?;
         self.expr_parent = ExpressionParent::None;
         Ok(())
+    }
     fn visit_expr_stmt(&mut self, ctx: &mut Ctx, id: ExpressionStatementId) -> VisitorResult {
         let expr_id = ctx.heap[id].expression;
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         self.expr_parent = ExpressionParent::ExpressionStmt(id);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = ExpressionParent::None;
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Expression visitors
     //--------------------------------------------------------------------------
     fn visit_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> VisitorResult {
         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 {
             ExpressionParent::ExpressionStmt(_) => {},
             _ => return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, assignment_expr.span,
                 "assignments may only appear at the statement level"
             )),
+        }
         let left_expr_id = assignment_expr.left;
         let right_expr_id = assignment_expr.right;
         let old_expr_parent = self.expr_parent;
         assignment_expr.parent = old_expr_parent;
         assignment_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.must_be_assignable = Some(assignment_expr.span);
         self.visit_expr(ctx, left_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.must_be_assignable = None;
         self.visit_expr(ctx, right_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_binding_expr(&mut self, ctx: &mut Ctx, id: BindingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let binding_expr = &mut ctx.heap[id];
         // Check for valid context of binding expression
         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 binding expression"
             ));
+        }
         if self.in_test_expr.is_invalid() {
             let binding_expr = &ctx.heap[id];
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, binding_expr.span,
                 "binding expressions can only be used inside the testing expression of 'if' and 'while' statements"
             ));
+        }
         if !self.in_binding_expr.is_invalid() {
             let binding_expr = &ctx.heap[id];
             let previous_expr = &ctx.heap[self.in_binding_expr];
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, binding_expr.span,
                 "nested binding expressions are not allowed"
             ).with_info_str_at_span(
                 &ctx.module.source, previous_expr.span,
                 "the outer binding expression is found here"
             ));
+        }
         let mut seeking_parent = self.expr_parent;
         loop {
             // Perform upward search to make sure only LogicalAnd is applied to
             // the binding expression
             let valid = match seeking_parent {
                 ExpressionParent::If(_) | ExpressionParent::While(_) => {
                     // Every parent expression (if any) were LogicalAnd.
                     break;
+                }
                 ExpressionParent::Expression(parent_id, _) => {
                     let parent_expr = &ctx.heap[parent_id];
                     match parent_expr {
                         Expression::Binary(parent_expr) => {
                             // Set new parent to continue the search. Otherwise
                             // halt and provide an error using the current
                             // parent.
                             if parent_expr.operation == BinaryOperator::LogicalAnd {
                                 seeking_parent = parent_expr.parent;
                                 true
                             } else {
                                 false
+                            }
                         },
                         _ => false,
+                    }
                 },
                 _ => unreachable!(), // nested under if/while, so always expressions as parents
             };
             if !valid {
                 let binding_expr = &ctx.heap[id];
                 let parent_expr = &ctx.heap[seeking_parent.as_expression()];
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module.source, binding_expr.span,
                     "only the logical-and operator (&&) may be applied to binding expressions"
                 ).with_info_str_at_span(
                     &ctx.module.source, parent_expr.span(),
                     "this was the disallowed operation applied to the result from a binding expression"
                 ));
+            }
+        }
         // Perform all of the index/parent assignment magic
         let binding_expr = &mut ctx.heap[id];
         let old_expr_parent = self.expr_parent;
         binding_expr.parent = old_expr_parent;
         binding_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         self.in_binding_expr = id;
         // Perform preliminary check on children: binding expressions only make
         // sense if the left hand side is just a variable expression, or if it
         // is a literal of some sort. The typechecker will take care of the rest
         let bound_to_id = binding_expr.bound_to;
         let bound_from_id = binding_expr.bound_from;
         match &ctx.heap[bound_to_id] {
             // Variables may not be binding variables, and literals may
             // actually not contain binding variables. But in that case we just
             // perform an equality check.
             Expression::Variable(_) => {}
             Expression::Literal(_) => {},
             _ => {
                 let binding_expr = &ctx.heap[id];
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module.source, binding_expr.span,
                     "the left hand side of a binding expression may only be a variable or a literal expression"
                 ));
             },
+        }
         // Visit the children themselves
         self.in_binding_expr_lhs = true;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, bound_to_id)?;
         self.in_binding_expr_lhs = false;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, bound_from_id)?;
         self.expr_parent = old_expr_parent;
         self.in_binding_expr = BindingExpressionId::new_invalid();
         Ok(())
+    }
     fn visit_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let conditional_expr = &mut 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 conditional expression"
             ))
+        }
         let test_expr_id = conditional_expr.test;
         let true_expr_id = conditional_expr.true_expression;
         let false_expr_id = conditional_expr.false_expression;
         let old_expr_parent = self.expr_parent;
         conditional_expr.parent = old_expr_parent;
         conditional_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, test_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, true_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 2);
         self.visit_expr(ctx, false_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let binary_expr = &mut 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 binary expression"
             ))
+        }
         let left_expr_id = binary_expr.left;
         let right_expr_id = binary_expr.right;
         let old_expr_parent = self.expr_parent;
         binary_expr.parent = old_expr_parent;
         binary_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, left_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, right_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> VisitorResult {
         let unary_expr = &mut ctx.heap[id];
         let expr_id = unary_expr.expression;
         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 unary expression"
             ))
+        }
         let old_expr_parent = self.expr_parent;
         unary_expr.parent = old_expr_parent;
         unary_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         self.expr_parent = ExpressionParent::Expression(id.upcast(), 0);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let indexing_expr = &mut ctx.heap[id];
         let subject_expr_id = indexing_expr.subject;
         let index_expr_id = indexing_expr.index;
         let old_expr_parent = self.expr_parent;
         indexing_expr.parent = old_expr_parent;
         indexing_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, subject_expr_id)?;
         let old_assignable = self.must_be_assignable.take();
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, index_expr_id)?;
         self.must_be_assignable = old_assignable;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> VisitorResult {
         let upcast_id = id.upcast();
         let slicing_expr = &mut ctx.heap[id];
         let subject_expr_id = slicing_expr.subject;
         let from_expr_id = slicing_expr.from_index;
         let to_expr_id = slicing_expr.to_index;
         let old_expr_parent = self.expr_parent;
         slicing_expr.parent = old_expr_parent;
         slicing_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, subject_expr_id)?;
         let old_assignable = self.must_be_assignable.take();
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, from_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 2);
         self.visit_expr(ctx, to_expr_id)?;
         self.must_be_assignable = old_assignable;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> VisitorResult {
         let select_expr = &mut ctx.heap[id];
         let expr_id = select_expr.subject;
         let old_expr_parent = self.expr_parent;
         select_expr.parent = old_expr_parent;
         select_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         self.expr_parent = ExpressionParent::Expression(id.upcast(), 0);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> VisitorResult {
         let literal_expr = &mut ctx.heap[id];
         let old_expr_parent = self.expr_parent;
         literal_expr.parent = old_expr_parent;
         literal_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module.source, span, "cannot assign to a literal expression"
             ))
+        }
         match &mut literal_expr.value {
             Literal::Null | Literal::True | Literal::False |
             Literal::Character(_) | Literal::String(_) | Literal::Integer(_) => {
                 // Just the parent has to be set, done above
             },
             Literal::Struct(literal) => {
                 let upcast_id = id.upcast();
                 // Retrieve type definition
                 let type_definition = ctx.types.get_base_definition(&literal.definition).unwrap();
                 let struct_definition = type_definition.definition.as_struct();
                 // Make sure all fields are specified, none are specified twice
                 // and all fields exist on the struct definition
                 let mut specified = Vec::new(); // TODO: @performance
                 specified.resize(struct_definition.fields.len(), false);
                 for field in &mut literal.fields {
                     // Find field in the struct definition
                     let field_idx = struct_definition.fields.iter().position(|v| v.identifier == field.identifier);
                     if field_idx.is_none() {
                         let field_span = field.identifier.span;
                         let literal = ctx.heap[id].value.as_struct();
                         let ast_definition = &ctx.heap[literal.definition];
                         return Err(ParseError::new_error_at_span(
                             &ctx.module.source, field_span, format!(
                                 "This field does not exist on the struct '{}'",
                                 ast_definition.identifier().value.as_str()
+                            )
                         ));
+                    }
                     field.field_idx = field_idx.unwrap();
                     // Check if specified more than once
                     if specified[field.field_idx] {
                         return Err(ParseError::new_error_str_at_span(
                             &ctx.module.source, field.identifier.span,
                             "This field is specified more than once"
                         ));
+                    }
                     specified[field.field_idx] = true;
+                }
                 if !specified.iter().all(|v| *v) {
                     // Some fields were not specified
                     let mut not_specified = String::new();
                     let mut num_not_specified = 0;
                     for (def_field_idx, is_specified) in specified.iter().enumerate() {
                         if !is_specified {
                             if !not_specified.is_empty() { not_specified.push_str(", ") }
                             let field_ident = &struct_definition.fields[def_field_idx].identifier;
                             not_specified.push_str(field_ident.value.as_str());
                             num_not_specified += 1;
+                        }
+                    }
                     debug_assert!(num_not_specified > 0);
                     let msg = if num_not_specified == 1 {
                         format!("not all fields are specified, '{}' is missing", not_specified)
                     } else {
                         format!("not all fields are specified, [{}] are missing", not_specified)
                     };
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, literal.parser_type.elements[0].full_span, msg
                     ));
+                }
                 // Need to traverse fields expressions in struct and evaluate
                 // the poly args
                 let mut expr_section = self.expression_buffer.start_section();
                 for field in &literal.fields {
                     expr_section.push(field.value);
+                }
                 for expr_idx in 0..expr_section.len() {
                     let expr_id = expr_section[expr_idx];
                     self.expr_parent = ExpressionParent::Expression(upcast_id, expr_idx as u32);
                     self.visit_expr(ctx, expr_id)?;
+                }
                 expr_section.forget();
             },
             Literal::Enum(literal) => {
                 // Make sure the variant exists
                 let type_definition = ctx.types.get_base_definition(&literal.definition).unwrap();
                 let enum_definition = type_definition.definition.as_enum();
                 let variant_idx = enum_definition.variants.iter().position(|v| {
                     v.identifier == literal.variant
                 });
                 if variant_idx.is_none() {
                     let literal = ctx.heap[id].value.as_enum();
                     let ast_definition = ctx.heap[literal.definition].as_enum();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, literal.parser_type.elements[0].full_span, format!(
                             "the variant '{}' does not exist on the enum '{}'",
                             literal.variant.value.as_str(), ast_definition.identifier.value.as_str()
+                        )
                     ));
+                }
                 literal.variant_idx = variant_idx.unwrap();
             },
             Literal::Union(literal) => {
                 // Make sure the variant exists
                 let type_definition = ctx.types.get_base_definition(&literal.definition).unwrap();
                 let union_definition = type_definition.definition.as_union();
                 let variant_idx = union_definition.variants.iter().position(|v| {
                     v.identifier == literal.variant
                 });
                 if variant_idx.is_none() {
                     let literal = ctx.heap[id].value.as_union();
                     let ast_definition = ctx.heap[literal.definition].as_union();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, literal.parser_type.elements[0].full_span, format!(
                             "the variant '{}' does not exist on the union '{}'",
                             literal.variant.value.as_str(), ast_definition.identifier.value.as_str()
+                        )
                     ));
+                }
                 literal.variant_idx = variant_idx.unwrap();
                 // Make sure the number of specified values matches the expected
                 // number of embedded values in the union variant.
                 let union_variant = &union_definition.variants[literal.variant_idx];
                 if union_variant.embedded.len() != literal.values.len() {
                     let literal = ctx.heap[id].value.as_union();
                     let ast_definition = ctx.heap[literal.definition].as_union();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module.source, literal.parser_type.elements[0].full_span, format!(
                             "The variant '{}' of union '{}' expects {} embedded values, but {} were specified",
                             literal.variant.value.as_str(), ast_definition.identifier.value.as_str(),
                             union_variant.embedded.len(), literal.values.len()
                         ),
                     ))
+                }
                 // Traverse embedded values of union (if any) and evaluate the
                 // polymorphic arguments
                 let upcast_id = id.upcast();
                 let mut expr_section = self.expression_buffer.start_section();
                 for value in &literal.values {
                     expr_section.push(*value);
+                }
                 for expr_idx in 0..expr_section.len() {
                     let expr_id = expr_section[expr_idx];
                     self.expr_parent = ExpressionParent::Expression(upcast_id, expr_idx as u32);
                     self.visit_expr(ctx, expr_id)?;
+                }
                 expr_section.forget();
             },
             Literal::Array(literal) => {
                 // Visit all expressions in the array
                 let upcast_id = id.upcast();
                 let expr_section = self.expression_buffer.start_section_initialized(literal);
                 for expr_idx in 0..expr_section.len() {
                     let expr_id = expr_section[expr_idx];
                     self.expr_parent = ExpressionParent::Expression(upcast_id, expr_idx as u32);
                     self.visit_expr(ctx, expr_id)?;
+                }
                 expr_section.forget();
+            }
+        }
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_cast_expr(&mut self, ctx: &mut Ctx, id: CastExpressionId) -> VisitorResult {
         let cast_expr = &mut 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 cast expression"
             ))

src/protocol/tests/parser_binding.rs

➞

Show inline comments

 use super::*;
 #[test]
 fn test_correct_binding() {
     Tester::new_single_source_expect_ok("binding bare", "
         enum TestEnum{ A, B }
         union TestUnion{ A(u32), B }
         struct TestStruct{ u32 field }
         func foo() -> u32 {
             auto lit_enum_a = TestEnum::A;
             auto lit_enum_b = TestEnum::B;
             auto lit_union_a = TestUnion::A(0);
             auto lit_union_b = TestUnion::B;
             auto lit_struct = TestStruct{ field: 0 };
             if (let test_enum_a = lit_enum_a)   { auto can_use = test_enum_a; }
             if (let test_enum_b = lit_enum_b)   { auto can_use = test_enum_b; }
             if (let test_union_a = lit_union_a) { auto can_use = test_union_a; }
             if (let test_union_b = lit_union_b) { auto can_use = test_union_b; }
             if (let test_struct = lit_struct)   { auto can_use = test_struct; }
             return 0;
+        }
     ").for_function("foo", |f| { f
         .for_variable("test_enum_a", |v| { v.assert_concrete_type("TestEnum"); })
         .for_variable("test_enum_b", |v| { v.assert_concrete_type("TestEnum"); })
         .for_variable("test_union_a", |v| { v.assert_concrete_type("TestUnion"); })
         .for_variable("test_union_b", |v| { v.assert_concrete_type("TestUnion"); })
         .for_variable("test_struct", |v| { v.assert_concrete_type("TestStruct"); });
     });
+}
 #[test]
 fn test_incorrect_binding() {
     Tester::new_single_source_expect_err("binding at statement level", "
         func foo() -> bool {
             return let a = 5;
+        }
     ").error(|e| { e
         .assert_num(1)
         .assert_occurs_at(0, "let")
         .assert_msg_has(0, "only be used inside the testing expression");
     });
     Tester::new_single_source_expect_err("nested bindings", "
         struct Struct{ bool field }
         func foo() -> bool {
             if (let Struct{ field: let a = Struct{ field: false } } = Struct{ field: true }) {
                 return test;
+            }
             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_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 &&
                 let TestUnion::Four(test_4) = lit_4 &&
                 let TestUnion::Eight(test_8) = lit_8
             ) {
                 auto valid_2 = test_2;
                 auto valid_4 = test_4;
                 auto valid_8 = test_8;
+            }
             // Testing in combination with regular expressions, and to the correct
             // literals
             if (let TestUnion::Two(inter_a) = lit_2 && 5 + 2 == 7)               { inter_a = 0; }
             if (5 + 2 == 7 && let TestUnion::Two(inter_b) = lit_2)               { inter_b = 0; }
             if (2 + 2 == 4 && let TestUnion::Two(inter_c) = lit_2 && 3 + 3 == 8) { inter_c = 0; }
             // Testing with the 'incorrect' target union
             if (let TestUnion::Four(nope) = lit_2 && let TestUnion::Two(zilch) = lit_8) { }
             return 0;
+        }
     ").for_function("foo", |f| { f
         .for_variable("valid_2", |v| { v.assert_concrete_type("u16"); })
         .for_variable("valid_4", |v| { v.assert_concrete_type("u32"); })
         .for_variable("valid_8", |v| { v.assert_concrete_type("u64"); })
         .for_variable("inter_a", |v| { v.assert_concrete_type("u16"); })
         .for_variable("inter_b", |v| { v.assert_concrete_type("u16"); })
         .for_variable("inter_c", |v| { v.assert_concrete_type("u16"); });
     });
     Tester::new_single_source_expect_err("apply || before binding", "
         enum Test{ A, B }
         func foo() -> u32 {
             if (let a = Test::A || 5 + 2 == 7) {
                 auto mission_impossible = 5;
+            }
             return 0;
+        }
     ").error(|e| { e
         .assert_num(1)
         .assert_occurs_at(0, "let")
         .assert_msg_has(0, "expected a 'bool'");
         .assert_num(2)
         .assert_occurs_at(0, "let a")
         .assert_msg_has(0, "only the logical-and operator")
         .assert_occurs_at(1, "||")
         .assert_msg_has(1, "disallowed operation");
     });
     Tester::new_single_source_expect_err("apply || after binding", "
         enum Test{ A, B }
         func foo() -> u32 {
             if (5 + 2 == 7 || let b = Test::B) {
                 auto magic_number = 7;
+            }
             return 0;
+        }
     ").error(|e| { e
         .assert_num(1)
         .assert_occurs_at(0, "let")
         .assert_msg_has(0, "expected a 'bool'");
         .assert_num(2)
         .assert_occurs_at(0, "let b")
         .assert_msg_has(0, "only the logical-and operator")
         .assert_occurs_at(1, "||")
         .assert_msg_has(1, "disallowed operation");
     });
     Tester::new_single_source_expect_err("apply || before and after binding", "
         enum Test{ A, B }
         func foo() -> u32 {
             if (1 + 2 == 3 || (let a = Test::A && let b = Test::B) || (2 + 2 == 4)) {
                 auto darth_vader_says = \"Noooooooooo\";
+            }
             return 0;
+        }
     ").error(|e| { e
         .assert_num(1)
         .assert_msg_has(0, "expected a 'bool'");
         .assert_num(2)
         .assert_occurs_at(0, "let a")
         .assert_msg_has(0, "only the logical-and operator")
         .assert_occurs_at(1, "|| (let a")
         .assert_msg_has(1, "disallowed operation");
     });
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)